rbs 3.9.4 → 4.1.1

data/sig/rewriter.rbs

@@ -0,0 +1,45 @@
+module RBS
+  # Rewriter performs targeted character-range replacements on Buffer content.
+  #
+  # Unlike Writer which regenerates entire source from AST, Rewriter preserves
+  # everything outside the rewritten ranges, including non-documentation comments.
+  #
+  # Rewrite requests are buffered and applied all at once when `#string` is called.
+  #
+  class Rewriter
+    attr_reader buffer: Buffer
+
+    # Initialize with a toplevel buffer.
+    # Raises if the buffer has a parent (non-toplevel).
+    #
+    def initialize: (Buffer buffer) -> void
+
+    # Register a rewrite request for the given location.
+    #
+    def rewrite: (Location[untyped, untyped] location, String string) -> self
+
+    # Add a new comment before the earliest of the given locations.
+    #
+    def add_comment: (*Location[untyped, untyped] locations, content: String) -> self
+
+    # Replace an existing comment's content.
+    #
+    def replace_comment: (AST::Comment comment, content: String) -> self
+
+    # Delete an existing comment.
+    #
+    def delete_comment: (AST::Comment comment) -> self
+
+    # Apply all buffered rewrites and return the resulting string.
+    #
+    # Raises if any rewrite ranges overlap.
+    #
+    def string: () -> String
+
+    private
+
+    def format_comment: (String content, String indent) -> String
+
+    @rewrites: Array[[Location[untyped, untyped], String]]
+  end
+end

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
@@ -518,7 +517,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

@@ -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