rbs 4.0.3 → 4.1.0.pre.2

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/ruby_vm.rbs

@@ -371,6 +371,46 @@ class RubyVM::InstructionSequence < Object
   # event_symbol] pair.
   #
   def trace_points: () -> Array[untyped]
+
+  # <!--
+  #   rdoc-file=iseq.c
+  #   - of(p1)
+  # -->
+  # Returns the instruction sequence containing the given proc or method.
+  #
+  # For example, using irb:
+  #
+  #     # a proc
+  #     > p = proc { num = 1 + 2 }
+  #     > RubyVM::InstructionSequence.of(p)
+  #     > #=> <RubyVM::InstructionSequence:block in irb_binding@(irb)>
+  #
+  #     # for a method
+  #     > def foo(bar); puts bar; end
+  #     > RubyVM::InstructionSequence.of(method(:foo))
+  #     > #=> <RubyVM::InstructionSequence:foo@(irb)>
+  #
+  # Using ::compile_file:
+  #
+  #     # /tmp/iseq_of.rb
+  #     def hello
+  #       puts "hello, world"
+  #     end
+  #
+  #     $a_global_proc = proc { str = 'a' + 'b' }
+  #
+  #     # in irb
+  #     > require '/tmp/iseq_of.rb'
+  #
+  #     # first the method hello
+  #     > RubyVM::InstructionSequence.of(method(:hello))
+  #     > #=> #<RubyVM::InstructionSequence:0x007fb73d7cb1d0>
+  #
+  #     # then the global proc
+  #     > RubyVM::InstructionSequence.of($a_global_proc)
+  #     > #=> #<RubyVM::InstructionSequence:0x007fb73d7caf78>
+  #
+  def self.of: (Proc | Method | UnboundMethod body) -> RubyVM::InstructionSequence?
 end
 
 # <!-- rdoc-file=ast.rb -->

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

data/core/thread.rbs

@@ -1604,7 +1604,7 @@ end
 #
 #     consumer.join
 #
-class Thread::Queue[Elem = untyped] < Object
+class Thread::Queue[E = untyped] < Object
   # <!-- rdoc-file=thread_sync.c -->
   # Pushes the given `object` to the queue.
   #
@@ -1719,7 +1719,7 @@ class Thread::Queue[Elem = untyped] < Object
   # If `timeout` seconds have passed and no data is available `nil` is returned.
   # If `timeout` is `0` it returns immediately.
   #
-  def pop: (?boolish non_block, ?timeout: _ToF?) -> Elem?
+  def pop: (?boolish non_block, ?timeout: _ToF?) -> E?
 
   # <!--
   #   rdoc-file=thread_sync.c
@@ -1729,7 +1729,7 @@ class Thread::Queue[Elem = untyped] < Object
   # -->
   # Pushes the given `object` to the queue.
   #
-  def push: (Elem obj) -> void
+  def push: (E obj) -> void
 
   # <!--
   #   rdoc-file=thread_sync.rb
@@ -1750,7 +1750,7 @@ end
 #
 # See Thread::Queue for an example of how a Thread::SizedQueue works.
 #
-class Thread::SizedQueue[Elem = untyped] < Thread::Queue[Elem]
+class Thread::SizedQueue[E = untyped] < Thread::Queue[E]
   # <!--
   #   rdoc-file=thread_sync.rb
   #   - <<(object, non_block = false, timeout: nil)
@@ -1813,8 +1813,8 @@ class Thread::SizedQueue[Elem = untyped] < Thread::Queue[Elem]
   # If `timeout` seconds have passed and no space is available `nil` is returned.
   # If `timeout` is `0` it returns immediately. Otherwise it returns `self`.
   #
-  def push: (Elem obj, ?boolish non_block) -> void
-          | (Elem obj, timeout: _ToF?) -> self?
+  def push: (E obj, ?boolish non_block) -> void
+          | (E obj, timeout: _ToF?) -> self?
 end
 
 class ConditionVariable = Thread::ConditionVariable

data/docs/CONTRIBUTING.md

@@ -12,7 +12,8 @@
 The RBS repository contains the type definitions of Core API and Standard Libraries.
 There are some discussions whether if it is the best to have them in this repository, but we have them and continue updating the files meanwhile.
 
-The target version of the bundled type definitions is the latest _release_ of Ruby -- `3.1` as of January 2022.
+The target version of the bundled type definitions is the [latest _release_ of Ruby](https://www.ruby-lang.org/en/downloads/branches/) -- `4.0` as of 2026.
+Note, however, that the CI currently retains the tests on Ruby 3.2 as well.
 
 **The core API** type definitions are in `core` directory.
 You will find the familiar class names in the directory, like `string.rbs` or `array.rbs`.

data/docs/inline.md

@@ -123,10 +123,38 @@ end
 
 This creates the types `::API`, `::API::V1`, and `::API::V1::Resources`.
 
+### `module-self` constraint
+
+The `module-self` constraint declares which classes or modules the module can be mixed into.
+
+```ruby
+# @rbs module-self: _Each[String]
+module Enumerable2
+end
+```
+
+This is equivalent to `module Enumerable2 : _Each[String]` in RBS, meaning `Enumerable2` can only be included in classes that satisfy the `_Each[String]` interface.
+
+Multiple `module-self` constraints can be declared with separate annotations:
+
+```ruby
+# @rbs module-self: _Each[String]
+# @rbs module-self: Comparable
+module StringCollection
+end
+```
+
+You can add a description after `--`:
+
+```ruby
+# @rbs module-self: Minitest::Test -- depending on assertion methods
+module TestHelper
+end
+```
+
 ### Current Limitations
 
 - Generic module definitions are not supported
-- Module self-type constraints are not supported
 
 ## Method Definitions
 
@@ -135,6 +163,8 @@ Inline RBS supports methods defined using the `def` syntax in Ruby.
 ```ruby
 class Calculator
   def add(x, y) = x+y
+
+  def self.zero = 0
 end
 ```
 
@@ -205,6 +235,18 @@ The type of both methods is `(Integer, Integer) -> Integer | (Float, Float) -> F
 > The `@rbs METHOD-TYPE` syntax allows overloads with the `|` operator, just like in RBS files.
 > Multiple `: METHOD-TYPE` declarations are required for overloads.
 
+The `#:` syntax can also be used as a trailing annotation to declare the return type of a method:
+
+```ruby
+class Calculator
+  def add(x, y) #: Integer
+    x + y
+  end
+
+  def subtract(x, y) = x - y #: Integer
+end
+```
+
 The `@rbs METHOD-TYPE` syntax allows having `...` at the last part.
 
 ```ruby
@@ -309,9 +351,10 @@ end
 
 ### Current Limitations
 
-- Class methods and singleton methods are not supported
-- Only positional and keyword parameters are supported. Splat parameters (`*x`, `**y`) and block parameter (`&block`) are not supported yet.
 - Method visibility declaration is not supported yet
+- The `class << self` syntax is not supported
+- Top-level method definitions (outside any class/module) are not supported
+- Method definitions with a non-self receiver (e.g. `def obj.foo`) are not supported
 
 ## Attributes
 
@@ -389,6 +432,7 @@ The attribute definitions are ignored because the names are given by string lite
 ### Current Limitations
 
 - Attribute visibility is not supported yet. All attributes are _public_
+- Top-level attribute definitions (outside any class/module) are not supported
 
 ## Mixin
 
@@ -487,7 +531,7 @@ end
 ```
 
 The `@rbs @VAR-NAME: TYPE` syntax enclosed in `class`/`module` syntax declares instance variables.
-You can add the documentation of the variable followed by two hyphones (`--`).
+You can add the documentation of the variable followed by two hyphens (`--`).
 
 Instance variable declarations must be under the `class`/`module` syntax, and they are ignored if written inside method definitions.
 
@@ -519,14 +563,16 @@ The types of constants may be automatically inferred when the right-hand side co
 - **Floats**: `RATE = 3.14` → `Float`
 - **Booleans**: `ENABLED = true` → `bool`
 - **Strings**: `NAME = "test"` → `String`
-- **Symbols**: `STATUS = :ready` → `:ready`
+- **Symbols**: `STATUS = :ready` → `Symbol`
+- **Nil**: `EMPTY = nil` → `nil`
 
 ```ruby
 MAX_SIZE = 100           # Inferred as Integer
 PI = 3.14159            # Inferred as Float
 DEBUG = false           # Inferred as bool
 APP_NAME = "MyApp"      # Inferred as String
-DEFAULT_MODE = :strict  # Inferred as :strict
+DEFAULT_MODE = :strict  # Inferred as Symbol
+NONE = nil              # Inferred as nil
 ```
 
 ### Explicit Type Annotations
@@ -567,10 +613,22 @@ MyKernel = Kernel #: module-alias
 
 This creates new type names that refer to the same class or module as the original.
 
-The annotations can have optional type name to specify the class/module name, for the case it cannot be infered through the right-hand-side of the constant declaration.
+The annotations can have optional type name to specify the class/module name, for the case it cannot be inferred through the right-hand-side of the constant declaration.
 
 ```ruby
 MyObject = object #: class-alias Object
 
 MyKernel = kernel #: module-alias Kernel
 ```
+
+## Skip Annotation
+
+The `@rbs skip` annotation makes inline RBS ignore the following declaration.
+
+```ruby
+class Calculator
+  # @rbs skip
+  def debug_internal
+  end
+end
+```