rbs 4.1.0.pre.1 → 4.1.0

data/core/range.rbs

@@ -235,8 +235,8 @@
 #
 #     require 'json/add/range'
 #
-class Range[out Elem] < Object
-  include Enumerable[Elem]
+class Range[out E] < Object
+  include Enumerable[E]
 
   # <!--
   #   rdoc-file=range.c
@@ -260,8 +260,8 @@ class Range[out Elem] < Object
   #     (0..7) % 2 #=> ((0..7).%(2)) -- as expected
   #     0..7 % 2 #=> 0..1 -- parsed as 0..(7 % 2)
   #
-  def %: (Numeric | int n) -> Enumerator[Elem, self]
-       | (Numeric | int n) { (Elem element) -> void } -> self
+  def %: (Numeric | int n) -> Enumerator[E, self]
+       | (Numeric | int n) { (E element) -> void } -> self
 
   # <!--
   #   rdoc-file=range.c
@@ -345,7 +345,7 @@ class Range[out Elem] < Object
   #
   # Related: Range#first, Range#end.
   #
-  def begin: () -> Elem
+  def begin: () -> E
 
   # <!--
   #   rdoc-file=range.c
@@ -355,9 +355,9 @@ class Range[out Elem] < Object
   #
   # See [Binary Searching](rdoc-ref:language/bsearch.rdoc).
   #
-  def bsearch: () -> ::Enumerator[Elem, Elem?]
-             | () { (Elem) -> (true | false) } -> Elem?
-             | () { (Elem) -> ::Integer } -> Elem?
+  def bsearch: () -> ::Enumerator[E, E?]
+             | () { (E) -> (true | false) } -> E?
+             | () { (E) -> ::Integer } -> E?
 
   # <!--
   #   rdoc-file=range.c
@@ -500,8 +500,8 @@ class Range[out Elem] < Object
   #
   # With no block given, returns an enumerator.
   #
-  def each: () { (Elem arg0) -> untyped } -> self
-          | () -> ::Enumerator[Elem, self]
+  def each: () { (E arg0) -> untyped } -> self
+          | () -> ::Enumerator[E, self]
 
   # <!--
   #   rdoc-file=range.c
@@ -515,7 +515,7 @@ class Range[out Elem] < Object
   #
   # Related: Range#begin, Range#last.
   #
-  def end: () -> Elem
+  def end: () -> E
 
   # <!--
   #   rdoc-file=range.c
@@ -551,8 +551,8 @@ class Range[out Elem] < Object
   #
   #     (..4).first # Raises RangeError
   #
-  def first: () -> Elem
-           | (Integer n) -> ::Array[Elem]
+  def first: () -> E
+           | (Integer n) -> ::Array[E]
 
   # <!--
   #   rdoc-file=range.c
@@ -605,7 +605,7 @@ class Range[out Elem] < Object
   #     Range.new('a', 'd').to_a        # => ["a", "b", "c", "d"]
   #     Range.new('a', 'd', true).to_a  # => ["a", "b", "c"]
   #
-  def initialize: (Elem from, Elem to, ?boolish exclude_end) -> void
+  def initialize: (E from, E to, ?boolish exclude_end) -> void
 
   # <!--
   #   rdoc-file=range.c
@@ -661,8 +661,8 @@ class Range[out Elem] < Object
   #
   #     (1..).last # Raises RangeError
   #
-  def last: () -> Elem
-          | (Integer n) -> ::Array[Elem]
+  def last: () -> E
+          | (Integer n) -> ::Array[E]
 
   # <!--
   #   rdoc-file=range.c
@@ -958,8 +958,8 @@ class Range[out Elem] < Object
   #
   # With no block given, returns an enumerator.
   #
-  def reverse_each: () { (Elem) -> void } -> self
-                  | () -> ::Enumerator[Elem, self]
+  def reverse_each: () { (E) -> void } -> self
+                  | () -> ::Enumerator[E, self]
 
   # <!--
   #   rdoc-file=range.c
@@ -1016,7 +1016,7 @@ class Range[out Elem] < Object
   #
   def count: () -> (Integer | Float)
            | (untyped) -> Integer
-           | () { (Elem) -> boolish } -> Integer
+           | () { (E) -> boolish } -> Integer
 
   # <!--
   #   rdoc-file=range.c
@@ -1096,10 +1096,10 @@ class Range[out Elem] < Object
   #     ('a'..'e').step { p _1 }
   #     # Default step 1; prints: a, b, c, d, e
   #
-  def step: (?Numeric | int) -> Enumerator[Elem, self]
-          | (?Numeric | int) { (Elem element) -> void } -> self
-          | (untyped) -> Enumerator[Elem, self]
-          | (untyped) { (Elem element) -> void } -> self
+  def step: (?Numeric | int) -> Enumerator[E, self]
+          | (?Numeric | int) { (E element) -> void } -> self
+          | (untyped) -> Enumerator[E, self]
+          | (untyped) { (E element) -> void } -> self
 
   # <!--
   #   rdoc-file=range.c

data/core/rbs/ops.rbs

@@ -0,0 +1,154 @@
+module RBS
+  module Ops
+    # An interface for types implementing the `+` operator
+    interface _Add[O, R]
+      # Perform the `+` operation
+      def +: (O other) -> R
+    end
+
+    # An interface for types implementing the `-` operator
+    interface _Subtract[O, R]
+      # Perform the `-` operation
+      def -: (O other) -> R
+    end
+
+    # An interface for types implementing the `*` operator
+    interface _Times[O, R]
+      # Perform the `*` operation
+      def *: (O other) -> R
+    end
+
+    # An interface for types implementing the `/` operator
+    interface _Divide[O, R]
+      # Perform the `/` operation
+      def /: (O other) -> R
+    end
+
+    # An interface for types implementing the `%` operator
+    interface _Modulo[O, R]
+      # Perform the `%` operation
+      def %: (O other) -> R
+    end
+
+    # An interface for types implementing the `**` operator
+    interface _Power[O, R]
+      # Perform the `**` operation
+      def **: (O other) -> R
+    end
+
+    # An interface for types implementing the `<` operator
+    interface _LessThan[O, R = bool]
+      # Perform the `<` operation
+      def <: (O other) -> R
+    end
+
+    # An interface for types implementing the `>` operator
+    interface _GreaterThan[O, R = bool]
+      # Perform the `>` operation
+      def >: (O other) -> R
+    end
+
+    # An interface for types implementing the `<=` operator
+    interface _LessThanOrEqual[O, R = bool]
+      # Perform the `<=` operation
+      def <=: (O other) -> R
+    end
+
+    # An interface for types implementing the `>=` operator
+    interface _GreaterThanOrEqual[O, R = bool]
+      # Perform the `>=` operation
+      def >=: (O other) -> R
+    end
+
+    # An interface for types implementing the `<=>` operator
+    interface _Compare[O = untyped, R = (-1 | 0 | 1)?]
+      # Perform the `<=>` operation
+      def <=>: (O other) -> R
+    end
+
+    # An interface for types implementing the `&` operator
+    interface _And[O, R]
+      # Perform the `&` operation
+      def &: (O other) -> R
+    end
+
+    # An interface for types implementing the `|` operator
+    interface _Or[O, R]
+      # Perform the `|` operation
+      def |: (O other) -> R
+    end
+
+    # An interface for types implementing the `^` operator
+    interface _Xor[O, R]
+      # Perform the `^` operation
+      def ^: (O other) -> R
+    end
+
+    # An interface for types implementing the `<<` operator
+    interface _LeftShift[O, R]
+      # Perform the `<<` operation
+      def <<: (O other) -> R
+    end
+
+    # An interface for types implementing the `>>` operator
+    interface _RightShift[O, R]
+      # Perform the `>>` operation
+      def >>: (O other) -> R
+    end
+
+    # An interface for types implementing the `~` operator
+    interface _Not[R]
+      # Perform the `~` operation
+      def ~: () -> R
+    end
+
+    # An interface for types implementing the `+@` operator
+    interface _UnaryPos[R]
+      # Perform the `+@` operation
+      def +@: () -> R
+    end
+
+    # An interface for types implementing the `-@` operator
+    interface _UnaryNeg[R]
+      # Perform the `-@` operation
+      def -@: () -> R
+    end
+
+    # An interface for types implementing the `!` operator
+    interface _LogicalNot[R = bool]
+      # Perform the `!` operation
+      def !: () -> R
+    end
+
+    # An interface for types implementing the `==` operator
+    interface _Equal[O = untyped, R = bool]
+      # Perform the `==` operation
+      def ==: (O other) -> R
+    end
+
+    # An interface for types implementing the `===` operator
+    interface _CaseEqual[O, R = bool]
+      # Perform the `===` operation
+      def ===: (O other) -> R
+    end
+
+    # An interface for types implementing the `=~` operator
+    interface _Matches[O, R]
+      # Perform the `=~` operation
+      def =~: (O other) -> R
+    end
+
+    # An interface for types implementing the `!=` operator
+    interface _NotEqual[O = untyped, R = bool]
+      # Perform the `!=` operation
+      def !=: (O other) -> R
+    end
+
+    # An interface for types implementing the `!~` operator
+    interface _NotMatches[O, R = bool]
+      # Perform the `!~` operation
+      def !~: (O other) -> R
+    end
+  end
+end
+

data/core/rbs/unnamed/argf.rbs

@@ -959,7 +959,7 @@ module RBS
       # ARGF#readpartial or ARGF#read_nonblock.
       #
       %a{annotate:rdoc:copy:ARGF#read}
-      def read: (?int? length, ?string outbuf) -> String?
+      def read: (?int? length, ?string? outbuf) -> String?
 
       # <!--
       #   rdoc-file=io.c
@@ -969,7 +969,7 @@ module RBS
       # Reads at most *maxlen* bytes from the ARGF stream in non-blocking mode.
       #
       %a{annotate:rdoc:copy:ARGF#read_nonblock}
-      def read_nonblock: (int maxlen, ?string buf, **untyped options) -> String
+      def read_nonblock: (int maxlen, ?string? buf, **untyped options) -> String
 
       # <!--
       #   rdoc-file=io.c
@@ -1070,7 +1070,7 @@ module RBS
       # last one.
       #
       %a{annotate:rdoc:copy:ARGF#readpartial}
-      def readpartial: (int maxlen, ?string outbuf) -> String
+      def readpartial: (int maxlen, ?string? outbuf) -> String
 
       # <!--
       #   rdoc-file=io.c

data/core/rubygems/errors.rbs

@@ -17,7 +17,7 @@
 # Further RubyGems documentation can be found at:
 #
 # *   [RubyGems Guides](https://guides.rubygems.org)
-# *   [RubyGems API](https://www.rubydoc.info/github/ruby/rubygems) (also
+# *   [RubyGems API](https://guides.rubygems.org/rubygems-org-api/) (also
 #     available from `gem server`)
 #
 # ## RubyGems Plugins
@@ -90,6 +90,9 @@
 #
 # -The RubyGems Team
 #
+# <!-- rdoc-file=lib/rubygems/version.rb -->
+# Workaround for directly loading Gem::Version in some cases
+#
 module Gem
   # <!-- rdoc-file=lib/rubygems/errors.rb -->
   # Raised when RubyGems is unable to load or activate a gem.  Contains the name

data/core/rubygems/requirement.rbs

@@ -123,18 +123,8 @@ module Gem
     #
     def satisfied_by?: (Gem::Version version) -> bool
 
-    # <!--
-    #   rdoc-file=lib/rubygems/requirement.rb
-    #   - ===(version)
-    # -->
-    #
     alias === satisfied_by?
 
-    # <!--
-    #   rdoc-file=lib/rubygems/requirement.rb
-    #   - =~(version)
-    # -->
-    #
     alias =~ satisfied_by?
 
     # <!--

data/core/rubygems/rubygems.rbs

@@ -17,7 +17,7 @@
 # Further RubyGems documentation can be found at:
 #
 # *   [RubyGems Guides](https://guides.rubygems.org)
-# *   [RubyGems API](https://www.rubydoc.info/github/ruby/rubygems) (also
+# *   [RubyGems API](https://guides.rubygems.org/rubygems-org-api/) (also
 #     available from `gem server`)
 #
 # ## RubyGems Plugins
@@ -90,6 +90,9 @@
 #
 # -The RubyGems Team
 #
+# <!-- rdoc-file=lib/rubygems/version.rb -->
+# Workaround for directly loading Gem::Version in some cases
+#
 module Gem
   interface _HashLike[K, V]
     def each_pair: () { ([ K, V ]) -> untyped } -> self

data/core/rubygems/specification.rbs

@@ -19,5 +19,13 @@
 # #metadata for restrictions on the format and size of metadata items you may
 # add to a specification.
 #
+# Specifications must be deterministic, as in the example above. For instance,
+# you cannot define attributes conditionally:
+#
+#     # INVALID: do not do this.
+#     unless RUBY_ENGINE == "jruby"
+#       s.extensions << "ext/example/extconf.rb"
+#     end
+#
 class Gem::Specification < Gem::BasicSpecification
 end

data/core/rubygems/version.rbs

@@ -1,165 +1,5 @@
 %a{annotate:rdoc:skip}
 module Gem
-  # <!-- rdoc-file=lib/rubygems/version.rb -->
-  # The Version class processes string versions into comparable values. A version
-  # string should normally be a series of numbers separated by periods. Each part
-  # (digits separated by periods) is considered its own number, and these are used
-  # for sorting. So for instance, 3.10 sorts higher than 3.2 because ten is
-  # greater than two.
-  #
-  # If any part contains letters (currently only a-z are supported) then that
-  # version is considered prerelease. Versions with a prerelease part in the Nth
-  # part sort less than versions with N-1 parts. Prerelease parts are sorted
-  # alphabetically using the normal Ruby string sorting rules. If a prerelease
-  # part contains both letters and numbers, it will be broken into multiple parts
-  # to provide expected sort behavior (1.0.a10 becomes 1.0.a.10, and is greater
-  # than 1.0.a9).
-  #
-  # Prereleases sort between real releases (newest to oldest):
-  #
-  # 1.  1.0
-  # 2.  1.0.b1
-  # 3.  1.0.a.2
-  # 4.  0.9
-  #
-  # If you want to specify a version restriction that includes both prereleases
-  # and regular releases of the 1.x series this is the best way:
-  #
-  #     s.add_dependency 'example', '>= 1.0.0.a', '< 2.0.0'
-  #
-  # ## How Software Changes
-  #
-  # Users expect to be able to specify a version constraint that gives them some
-  # reasonable expectation that new versions of a library will work with their
-  # software if the version constraint is true, and not work with their software
-  # if the version constraint is false.  In other words, the perfect system will
-  # accept all compatible versions of the library and reject all incompatible
-  # versions.
-  #
-  # Libraries change in 3 ways (well, more than 3, but stay focused here!).
-  #
-  # 1.  The change may be an implementation detail only and have no effect on the
-  #     client software.
-  # 2.  The change may add new features, but do so in a way that client software
-  #     written to an earlier version is still compatible.
-  # 3.  The change may change the public interface of the library in such a way
-  #     that old software is no longer compatible.
-  #
-  # Some examples are appropriate at this point.  Suppose I have a Stack class
-  # that supports a `push` and a `pop` method.
-  #
-  # ### Examples of Category 1 changes:
-  #
-  # *   Switch from an array based implementation to a linked-list based
-  #     implementation.
-  # *   Provide an automatic (and transparent) backing store for large stacks.
-  #
-  # ### Examples of Category 2 changes might be:
-  #
-  # *   Add a `depth` method to return the current depth of the stack.
-  # *   Add a `top` method that returns the current top of stack (without changing
-  #     the stack).
-  # *   Change `push` so that it returns the item pushed (previously it had no
-  #     usable return value).
-  #
-  # ### Examples of Category 3 changes might be:
-  #
-  # *   Changes `pop` so that it no longer returns a value (you must use `top` to
-  #     get the top of the stack).
-  # *   Rename the methods to `push_item` and `pop_item`.
-  #
-  # ## RubyGems Rational Versioning
-  #
-  # *   Versions shall be represented by three non-negative integers, separated by
-  #     periods (e.g. 3.1.4).  The first integers is the "major" version number,
-  #     the second integer is the "minor" version number, and the third integer is
-  #     the "build" number.
-  #
-  # *   A category 1 change (implementation detail) will increment the build
-  #     number.
-  #
-  # *   A category 2 change (backwards compatible) will increment the minor
-  #     version number and reset the build number.
-  #
-  # *   A category 3 change (incompatible) will increment the major build number
-  #     and reset the minor and build numbers.
-  #
-  # *   Any "public" release of a gem should have a different version.  Normally
-  #     that means incrementing the build number.  This means a developer can
-  #     generate builds all day long, but as soon as they make a public release,
-  #     the version must be updated.
-  #
-  # ### Examples
-  #
-  # Let's work through a project lifecycle using our Stack example from above.
-  #
-  # Version 0.0.1
-  # :   The initial Stack class is release.
-  #
-  # Version 0.0.2
-  # :   Switched to a linked=list implementation because it is cooler.
-  #
-  # Version 0.1.0
-  # :   Added a `depth` method.
-  #
-  # Version 1.0.0
-  # :   Added `top` and made `pop` return nil (`pop` used to return the  old top
-  #     item).
-  #
-  # Version 1.1.0
-  # :   `push` now returns the value pushed (it used it return nil).
-  #
-  # Version 1.1.1
-  # :   Fixed a bug in the linked list implementation.
-  #
-  # Version 1.1.2
-  # :   Fixed a bug introduced in the last fix.
-  #
-  #
-  # Client A needs a stack with basic push/pop capability.  They write to the
-  # original interface (no `top`), so their version constraint looks like:
-  #
-  #     gem 'stack', '>= 0.0'
-  #
-  # Essentially, any version is OK with Client A.  An incompatible change to the
-  # library will cause them grief, but they are willing to take the chance (we
-  # call Client A optimistic).
-  #
-  # Client B is just like Client A except for two things: (1) They use the `depth`
-  # method and (2) they are worried about future incompatibilities, so they write
-  # their version constraint like this:
-  #
-  #     gem 'stack', '~> 0.1'
-  #
-  # The `depth` method was introduced in version 0.1.0, so that version or
-  # anything later is fine, as long as the version stays below version 1.0 where
-  # incompatibilities are introduced.  We call Client B pessimistic because they
-  # are worried about incompatible future changes (it is OK to be pessimistic!).
-  #
-  # ## Preventing Version Catastrophe:
-  #
-  # From:
-  # https://www.zenspider.com/ruby/2008/10/rubygems-how-to-preventing-catastrophe.
-  # html
-  #
-  # Let's say you're depending on the fnord gem version 2.y.z. If you specify your
-  # dependency as ">= 2.0.0" then, you're good, right? What happens if fnord 3.0
-  # comes out and it isn't backwards compatible with 2.y.z? Your stuff will break
-  # as a result of using ">=". The better route is to specify your dependency with
-  # an "approximate" version specifier ("~>"). They're a tad confusing, so here is
-  # how the dependency specifiers work:
-  #
-  #     Specification From  ... To (exclusive)
-  #     ">= 3.0"      3.0   ... &infin;
-  #     "~> 3.0"      3.0   ... 4.0
-  #     "~> 3.0.0"    3.0.0 ... 3.1
-  #     "~> 3.5"      3.5   ... 4.0
-  #     "~> 3.5.0"    3.5.0 ... 3.6
-  #     "~> 3"        3.0   ... 4.0
-  #
-  # For the last example, single-digit versions are automatically extended with a
-  # zero to give a sensible result.
-  #
   class Version
     include Comparable
 

data/core/set.rbs

@@ -738,7 +738,7 @@ class Set[unchecked out A]
 end
 
 %a{annotate:rdoc:skip}
-module Enumerable[unchecked out Elem]
+module Enumerable[unchecked out E]
   # <!--
   #   rdoc-file=prelude.rb
   #   - to_set(*args, &block)
@@ -746,6 +746,6 @@ module Enumerable[unchecked out Elem]
   # Makes a set from the enumerable object with given arguments. Passing arguments
   # to this method is deprecated.
   #
-  def to_set: () -> Set[Elem]
-            | [T] () { (Elem) -> T } -> Set[T]
+  def to_set: () -> Set[E]
+            | [T] () { (E) -> T } -> Set[T]
 end

data/core/struct.rbs

@@ -104,8 +104,8 @@
 # *   #inspect (aliased as #to_s): Returns a string representation of `self`.
 # *   #to_h: Returns a hash of the member name/value pairs in `self`.
 #
-class Struct[Elem]
-  include Enumerable[Elem]
+class Struct[E]
+  include Enumerable[E]
 
   # The types that can be used when "indexing" into a `Struct` via `[]`, `[]=`, `dig`, and
   # `deconstruct_keys`.
@@ -362,7 +362,7 @@ class Struct[Elem]
   #
   # Related: #members.
   #
-  def to_a: () -> Array[Elem]
+  def to_a: () -> Array[E]
 
   # <!--
   #   rdoc-file=struct.c
@@ -385,8 +385,8 @@ class Struct[Elem]
   #
   # Raises ArgumentError if the block returns an inappropriate value.
   #
-  def to_h: () -> Hash[Symbol, Elem]
-          | [K, V] () { (Symbol key, Elem value) -> [K, V] } -> Hash[K, V]
+  def to_h: () -> Hash[Symbol, E]
+          | [K, V] () { (Symbol key, E value) -> [K, V] } -> Hash[K, V]
 
   # <!-- rdoc-file=struct.c -->
   # Returns the values in `self` as an array:
@@ -441,8 +441,8 @@ class Struct[Elem]
   #
   # Related: #each_pair.
   #
-  def each: () -> Enumerator[Elem, self]
-          | () { (Elem value) -> void } -> self
+  def each: () -> Enumerator[E, self]
+          | () { (E value) -> void } -> self
 
   # <!--
   #   rdoc-file=struct.c
@@ -465,8 +465,8 @@ class Struct[Elem]
   #
   # Related: #each.
   #
-  def each_pair: () -> Enumerator[[Symbol, Elem], self]
-               | () { ([Symbol, Elem] key_value) -> void } -> self
+  def each_pair: () -> Enumerator[[Symbol, E], self]
+               | () { ([Symbol, E] key_value) -> void } -> self
 
   # <!--
   #   rdoc-file=struct.c
@@ -492,7 +492,7 @@ class Struct[Elem]
   #
   # Raises IndexError if `n` is out of range.
   #
-  def []: (index name_or_position) -> Elem
+  def []: (index name_or_position) -> E
 
   # <!--
   #   rdoc-file=struct.c
@@ -521,7 +521,7 @@ class Struct[Elem]
   #
   # Raises IndexError if `n` is out of range.
   #
-  def []=: (index name_or_position, Elem value) -> Elem
+  def []=: (index name_or_position, E value) -> E
 
   # <!--
   #   rdoc-file=struct.c
@@ -540,8 +540,8 @@ class Struct[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def select: () -> Enumerator[Elem, Array[Elem]]
-            | () { (Elem value) -> boolish } -> Array[Elem]
+  def select: () -> Enumerator[E, Array[E]]
+            | () { (E value) -> boolish } -> Array[E]
 
   # <!-- rdoc-file=struct.c -->
   # With a block given, returns an array of values from `self` for which the block
@@ -591,7 +591,7 @@ class Struct[Elem]
   # Raises RangeError if any element of the range is negative and out of range;
   # see Array@Array+Indexes.
   #
-  def values_at: (*int | range[int?] positions) -> Array[Elem]
+  def values_at: (*int | range[int?] positions) -> Array[E]
 
   # <!--
   #   rdoc-file=struct.c
@@ -634,7 +634,7 @@ class Struct[Elem]
   #     f.dig(0, 0, :b, 0) # => 1
   #     f.dig(:b, 0) # => nil
   #
-  def dig: (index name_or_position) -> Elem
+  def dig: (index name_or_position) -> E
          | (index name_or_position, untyped, *untyped) -> untyped
 
   # <!-- rdoc-file=struct.c -->
@@ -664,5 +664,5 @@ class Struct[Elem]
   #     h = joe.deconstruct_keys(nil)
   #     h # => {:name=>"Joseph Smith, Jr.", :address=>"123 Maple, Anytown NC", :zip=>12345}
   #
-  def deconstruct_keys: (Array[index & Hash::_Key]? indices) -> Hash[index & Hash::_Key, Elem]
+  def deconstruct_keys: (Array[index & Hash::_Key]? indices) -> Hash[index & Hash::_Key, E]
 end