rbs 3.9.4 → 4.2.0

data/sig/source.rbs

@@ -0,0 +1,48 @@
+module RBS
+  module Source
+    type t = RBS | Ruby
+
+    class RBS
+      attr_reader buffer: Buffer
+
+      attr_reader directives: Array[AST::Directives::t]
+
+      attr_reader declarations: Array[AST::Declarations::t]
+
+      def initialize: (Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]) -> void
+
+      # Enumerates defined type names in the source
+      #
+      # The order is undefined. Deduplicated per source object.
+      #
+      def each_type_name: () { (TypeName) -> void } -> void
+                        | () -> Enumerator[TypeName]
+
+      private def each_declaration_type_name: (Set[TypeName], AST::Declarations::t) { (TypeName) -> void } -> void
+    end
+
+    class Ruby
+      attr_reader buffer: Buffer
+
+      attr_reader prism_result: Prism::ParseResult
+
+      attr_reader declarations: Array[AST::Ruby::Declarations::t]
+
+      attr_reader diagnostics: Array[InlineParser::Diagnostic::t]
+
+      def initialize: (Buffer, Prism::ParseResult, Array[AST::Ruby::Declarations::t], Array[InlineParser::Diagnostic::t]) -> void
+
+      def each_type_name: () { (TypeName) -> void } -> void
+                        | () -> Enumerator[TypeName]
+
+      private def each_declaration_type_name: (Set[TypeName], AST::Ruby::Declarations::t) { (TypeName) -> void } -> void
+
+      # Compares the type declaration between `self` and `other`
+      #
+      # The comparison is based on the AST structure.
+      # Differences on Ruby code implementation may be ignored.
+      #
+      def ==: (other: Ruby) -> bool
+    end
+  end
+end

data/sig/type_param.rbs

@@ -4,13 +4,14 @@ module RBS
       # Key
       # ^^^ name
       #
-      # unchecked out Elem < _ToJson = untyped
-      # ^^^^^^^^^                                 unchecked
-      #           ^^^                             variance
-      #               ^^^^                        name
-      #                    ^^^^^^^^^              upper_bound
-      #                              ^^^^^^^^^    default
-      type loc = Location[:name, :variance | :unchecked | :upper_bound | :default]
+      # unchecked out Elem < _ToJson > bot = untyped
+      # ^^^^^^^^^                                        unchecked
+      #           ^^^                                    variance
+      #               ^^^^                               name
+      #                    ^^^^^^^^^                     upper_bound
+      #                              ^^^^^               lower_bound
+      #                                      ^^^^^^^^    default
+      type loc = Location[:name, :variance | :unchecked | :upper_bound | :lower_bound | :default]
 
       type variance = :invariant | :covariant | :contravariant
 
@@ -24,9 +25,13 @@ module RBS
 
       attr_reader upper_bound_type: Types::t?
 
+      %a{pure} def lower_bound: () -> bound?
+
+      attr_reader lower_bound_type: Types::t?
+
       attr_reader default_type: Types::t?
 
-      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, location: loc?, ?default_type: Types::t?, ?unchecked: bool) -> void
+      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, lower_bound: Types::t?, location: loc?, ?default_type: Types::t?, ?unchecked: bool) -> void
 
       include _ToJson
 

data/sig/typename.rbs

@@ -28,6 +28,21 @@ module RBS
     #
     def initialize: (namespace: Namespace, name: Symbol) -> void
 
+    @hash: Integer?
+
+    self.@intern_mutex: Mutex
+
+    # Two-level Hash keyed by canonical Namespace identity (outer uses
+    # `compare_by_identity`) and name Symbol.
+    self.@intern_cache: Hash[Namespace, Hash[Symbol, TypeName]]
+
+    # Returns an interned `TypeName` instance.
+    #
+    # The given `namespace` is canonicalized so cached instances always hold an
+    # interned namespace. Subsequent calls with structurally equal arguments
+    # return the same object.
+    def self.[]: (Namespace namespace, Symbol name) -> TypeName
+
     def ==: (untyped other) -> bool
 
     def hash: () -> Integer
@@ -72,8 +87,3 @@ module RBS
     def self.parse: (String name) -> RBS::TypeName
   end
 end
-
-module Kernel
-  # Deprecated: Use `RBS::TypeName.parse` instead
-  %a{deprecated: Use `RBS::TypeName.parse` instead} def TypeName: (String name) -> RBS::TypeName
-end

data/sig/types.rbs

@@ -172,24 +172,23 @@ module RBS
     class ClassSingleton
       # singleton(::Foo)
       #           ^^^^^  => name
-      type loc = Location[:name, bot]
-
-      def initialize: (name: TypeName, location: loc?) -> void
+      type loc = Location[:name, :args]
 
-      attr_reader name: TypeName
+      def initialize: (name: TypeName, location: loc?, ?args: Array[t]) -> void
 
       attr_reader location: loc?
 
       include _TypeBase
-      include NoFreeVariables
-      include NoSubst
-      include EmptyEachType
+      include Application
 
       def ==: (untyped other) -> bool
 
       alias eql? ==
 
       def hash: () -> Integer
+              
+      def map_type: () { (t) -> t } -> ClassSingleton
+                  | () -> Enumerator[t, ClassSingleton]
     end
 
     module Application
@@ -386,6 +385,12 @@ module RBS
                     | -> Enumerator[t, Param]
       end
 
+      class ForwardingParam
+        attr_reader location: Location?
+
+        def initialize: (location: Location) -> void
+      end
+
       attr_reader required_positionals: Array[Param]
       attr_reader optional_positionals: Array[Param]
       attr_reader rest_positionals: Param?
@@ -393,6 +398,7 @@ module RBS
       attr_reader required_keywords: Hash[Symbol, Param]
       attr_reader optional_keywords: Hash[Symbol, Param]
       attr_reader rest_keywords: Param?
+      attr_reader forwarding: ForwardingParam?
       attr_reader return_type: t
 
       def initialize: (required_positionals: Array[Param],
@@ -402,7 +408,8 @@ module RBS
                        required_keywords: Hash[Symbol, Param],
                        optional_keywords: Hash[Symbol, Param],
                        rest_keywords: Param?,
-                       return_type: t) -> void
+                       return_type: t,
+                       ?forwarding: ForwardingParam?) -> void
 
       def free_variables: (?Set[Symbol]) -> Set[Symbol]
 
@@ -432,9 +439,11 @@ module RBS
                    ?required_keywords: Hash[Symbol, Param],
                    ?optional_keywords: Hash[Symbol, Param],
                    ?rest_keywords: Param?,
+                   ?forwarding: ForwardingParam?,
                    ?return_type: t) -> Function
 
       def empty?: () -> bool
+      def forwarding?: () -> bool
 
       def param_to_s: () -> String
       def return_to_s: () -> String
@@ -518,7 +527,10 @@ module RBS
 
       attr_reader self_type: t?
 
-      def initialize: (type: function, ?self_type: t?, required: boolish) -> void
+      type loc = Location[bot, bot]
+      attr_reader location: loc?
+
+      def initialize: (?location: loc?, type: function, ?self_type: t?, required: boolish) -> void
 
       def ==: (untyped other) -> bool
 

data/sig/unit_test/spy.rbs

@@ -20,11 +20,3 @@ module RBS
     end
   end
 end
-
-class Proc
-  def ruby2_keywords: () -> self
-end
-
-class Module
-  def ruby2_keywords: (*Symbol) -> void
-end

data/sig/unit_test/type_assertions.rbs

@@ -30,11 +30,11 @@ module RBS
       type target_type = Types::ClassInstance | Types::ClassSingleton
 
       interface _BaseAssertions
-        def assert: (untyped, ?String?) -> void
+        def assert: (untyped, ?(String | ^() -> String)?) -> void
 
         def refute: (untyped, ?String?) -> void
 
-        def assert_empty: (untyped, ?String?) -> void
+        def assert_empty: (untyped, ?(String | ^() -> String)?) -> void
 
         def assert_operator: (untyped, Symbol, *untyped) -> void
 
@@ -153,6 +153,17 @@ module RBS
       #
       def refute_send_type: (String | MethodType method_type, untyped receiver, Symbol method_name, *untyped args) ?{ () -> untyped } -> void
 
+      # Calls a method `method_name`, validates if it's compatible with RBS type definition, and ensures it raises the `exception` class.
+      #
+      # 1. It calls `method_name` with `receiver` passing `args` and given block,
+      # 2. Validates if it's compatible with given `method_type`, and
+      # 3. Validates if it's compatible with one of the overloads defined in RBS type definition
+      # 4. Ensures that `exception` is thrown
+      #
+      # See `assert_send_type` for the details.
+      #
+      def assert_send_type_error: (String | MethodType method_type, Class exception, untyped receiver, Symbol method_name, *untyped args) ?{ () -> untyped } -> void
+
       # Asserts if the constant `constant_name` has `constant_type`, and the RBS definition has compatible type
       #
       # ```ruby
@@ -168,6 +179,10 @@ module RBS
       #
       def assert_type: (String | Types::t value_type, untyped value) -> void
 
+      # Asserts if RBS definition declares given `method_name` with `visibility`
+      #
+      def assert_visibility: (:private | :public visibility, Symbol method_name) -> void
+
       # Allow non _simple-type_ method types given to `assert_send_type` and `refute_send_type`
       #
       # ```ruby

data/sig/wasm/deserializer.rbs

@@ -0,0 +1,66 @@
+module RBS
+  module WASM
+    # Rebuilds RBS::AST objects from the binary buffer produced by
+    # `rbs_serialize_node` (src/serialize.c), driven by SerializationSchema.
+    class Deserializer
+      @bytes: String
+
+      @buffer: Buffer
+
+      @encoding: Encoding
+
+      @pos: Integer
+
+      @class_cache: Hash[String, untyped]
+
+      # Deserialize a buffer produced for a whole signature, returning
+      # `[directives, declarations]` to match RBS::Parser._parse_signature.
+      def self.deserialize: (String bytes, Buffer buffer) -> untyped
+
+      # Deserialize a bare node list (RBS::Parser._parse_type_params).
+      def self.deserialize_node_list: (String bytes, Buffer buffer) -> Array[untyped]
+
+      # Deserialize the token stream from rbs_wasm_lex (RBS::Parser._lex).
+      def self.deserialize_tokens: (String bytes, Buffer buffer) -> Array[[ Symbol, Location ]]
+
+      def initialize: (String bytes, Buffer buffer) -> void
+
+      # Reads the next node and returns the reconstructed Ruby value.
+      def read_node: () -> untyped
+
+      def read_node_list: () -> Array[untyped]
+
+      def read_tokens: () -> Array[[ Symbol, Location ]]
+
+      private
+
+      def read_struct: (Array[untyped] entry) -> untyped
+
+      def read_field: (untyped reader) -> untyped
+
+      def read_hash: () -> Hash[untyped, untyped]
+
+      def read_count: () -> Integer
+
+      def read_location: (Array[untyped]? loc_children) -> Location?
+
+      def read_location_value: () -> Location?
+
+      def read_location_value_list: () -> Array[Location?]
+
+      def read_attr_ivar_name: () -> (Symbol | false | nil)
+
+      def read_range: () -> [ Integer, Integer ]?
+
+      def read_u8: () -> Integer
+
+      def read_u32: () -> Integer
+
+      def read_i32: () -> Integer
+
+      def read_string: (Encoding encoding) -> String
+
+      def class_for: (String name) -> untyped
+    end
+  end
+end

data/sig/wasm/serialization_schema.rbs

@@ -0,0 +1,13 @@
+module RBS
+  module WASM
+    # Generated from config.yml. See `templates/lib/rbs/wasm/serialization_schema.rb.erb`.
+    module SerializationSchema
+      # The node tag used for interned symbols (`rbs_ast_symbol`).
+      SYMBOL_TAG: Integer
+
+      # Indexed by node tag. Each entry describes how to decode one node; see the
+      # generated file for the exact shape.
+      SCHEMA: Array[Array[untyped]?]
+    end
+  end
+end