rbs 3.9.5 → 4.0.0

data/sig/location.rbs

@@ -4,14 +4,20 @@ module RBS
   #
   # A location can have _child_ locations.
   #
-  class Location[in RequiredChildKeys, in OptionalChildKeys]
+  class Location[in RequiredChildKeys = untyped, in OptionalChildKeys = untyped]
     # The buffer this location points on.
     attr_reader buffer (): Buffer
 
-    # The index of character the range starts from.
+    # The absolute start index of character the range starts from
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
     attr_reader start_pos (): Integer
 
-    # The index of character the range ends at.
+    # The absolute end index of character the range ends at
+    #
+    # It returns the index in the `buffer.top_buffer`.
+    #
     attr_reader end_pos (): Integer
 
     def initialize: (Buffer, Integer start_pos, Integer end_pos) -> void
@@ -24,26 +30,37 @@ module RBS
     # Returns the name of the buffer.
     def name: () -> untyped
 
-    # Line of the `start_pos` (1 origin)
+    # The *raw* index of character the range starts from.
+    attr_reader _start_pos (): Integer
+
+    # The *raw* index of character the range ends at.
+    attr_reader _end_pos (): Integer
+
+    # Line of the `start_pos` (1 origin, absolute)
     attr_reader start_line (): Integer
 
-    # Column of the `start_pos` (0 origin)
+    # Column of the `start_pos` (0 origin, absolute)
     attr_reader start_column (): Integer
 
-    # Line of the `end_pos` (1 origin)
+    # Line of the `end_pos` (1 origin, absolute)
     attr_reader end_line (): Integer
 
-    # Column of the `end_pos` (0 origin)
+    # Column of the `end_pos` (0 origin, absolute)
     attr_reader end_column (): Integer
 
+    # The absolute line-column pair of the start position
+    #
     attr_reader start_loc (): Buffer::loc
 
     @start_loc: Buffer::loc?
 
+    # The absolute line-column pair of the end position
+    #
     attr_reader end_loc (): Buffer::loc
 
     @end_loc: Buffer::loc?
 
+    # The absolute range of the start and end position
     attr_reader range (): Range[Integer]
 
     @range: Range[Integer]?
@@ -97,6 +114,14 @@ module RBS
 
     def key?: (Symbol) -> bool
 
+    # Returns the location of the buffer, but the buffer is detached from the parent buffer
+    #
+    def local_location: () -> self
+
+    # Returns the source of `#local_location`
+    # 
+    def local_source: () -> String
+
     private
 
     def _add_required_child: (RequiredChildKeys name, Integer start_pos, Integer end_pos) -> void

data/sig/locator.rbs

@@ -37,8 +37,6 @@ module RBS
     #
     def find2: (line: Integer, column: Integer) -> [Symbol?, Array[component]]?
 
-    private
-
     def find_in_directive: (Integer pos, AST::Directives::t, Array[component]) -> bool
 
     def find_in_decl: (Integer pos, decl: AST::Declarations::t, array: Array[component]) -> bool

data/sig/manifest.yaml

@@ -1,6 +1,5 @@
 dependencies:
   - name: logger
-  - name: pathname
   - name: json
   - name: optparse
   - name: tsort

data/sig/method_builder.rbs

@@ -16,16 +16,19 @@ module RBS
         #
         class Definition
           type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
+                        | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
+
+          type overloading_definition = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
 
           type accessibility = RBS::Definition::accessibility
 
           attr_reader name: Symbol
           attr_reader type: instance_type
           attr_reader originals: Array[original]
-          attr_reader overloads: Array[AST::Members::MethodDefinition]
+          attr_reader overloads: Array[overloading_definition]
           attr_reader accessibilities: Array[accessibility]
 
-          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[AST::Members::MethodDefinition], accessibilities: Array[accessibility]) -> void
+          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[overloading_definition], accessibilities: Array[accessibility]) -> void
 
           def original: () -> original?
 
@@ -74,9 +77,11 @@ module RBS
 
       def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Definition::accessibility) -> void
 
-      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Definition::accessibility) -> void
+      def build_ruby_attribute: (Methods, Methods::instance_type, member: AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember, accessibility: Definition::accessibility) -> void
+
+      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition | AST::Ruby::Members::DefMember, accessibility: Definition::accessibility) -> void
 
-      def each_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
+      def each_rbs_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
 
       def update: (env: Environment, except: _Each[TypeName]) -> MethodBuilder
     end

data/sig/namespace.rbs

@@ -139,8 +139,3 @@ module RBS
               | () -> Enumerator[Namespace, void]
   end
 end
-
-module Kernel
-  # Deprecated: Use `RBS::Namespace.parse` instead
-  %a{deprecated} def Namespace: (String) -> RBS::Namespace
-end

data/sig/parser.rbs

@@ -20,13 +20,13 @@ module RBS
 
     # Parse a method type and return it
     #
-    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
+    # When `byte_range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
     #
     # ```ruby
-    # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
-    # RBS::Parser.parse_method_type("() -> void", range: 0...)                   # => `() -> void`
-    # RBS::Parser.parse_method_type("() -> void () -> String", range: 11...)     # => `() -> String`
-    # RBS::Parser.parse_method_type("() -> void () -> String", range: 23...)     # => nil
+    # RBS::Parser.parse_method_type("() -> void")                                     # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void", byte_range: 0...)                   # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void () -> String", byte_range: 11...)     # => `() -> String`
+    # RBS::Parser.parse_method_type("() -> void () -> String", byte_range: 23...)     # => nil
     # ```
     #
     # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
@@ -39,17 +39,18 @@ module RBS
     # RBS::Parser.parse_method_type("", require_eof: true)                            # => nil
     # ```
     #
-    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
+    def self.parse_method_type: (Buffer | String, ?byte_range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
+                              | %a{deprecated: Use `byte_range:` keyword instead of `range:`} (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
 
     # Parse a type and return it
     #
-    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
+    # When `byte_range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
     #
     # ```ruby
-    # RBS::Parser.parse_type("String")                          # => `String`
-    # RBS::Parser.parse_type("String", range: 0...)             # => `String`
-    # RBS::Parser.parse_type("String Integer", pos: 7...)       # => `Integer`
-    # RBS::Parser.parse_type("String Integer", pos: 14...)      # => nil
+    # RBS::Parser.parse_type("String")                               # => `String`
+    # RBS::Parser.parse_type("String", byte_range: 0...)             # => `String`
+    # RBS::Parser.parse_type("String Integer", byte_range: 7...)     # => `Integer`
+    # RBS::Parser.parse_type("String Integer", byte_range: 14...)    # => nil
     # ```
     #
     # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
@@ -62,12 +63,45 @@ module RBS
     # RBS::Parser.parse_type("", require_eof: true)                   # => nil
     # ```
     #
-    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> Types::t?
+    # The `void_allowed` keyword controls whether `void` is allowed as a type.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("void", void_allowed: true)          # => `void`
+    # RBS::Parser.parse_type("void", void_allowed: false)         # => Raises an syntax error
+    # ```
+    #
+    # The `self_allowed` keyword controls whether `self` is allowed as a type.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("self", self_allowed: true)          # => `self`
+    # RBS::Parser.parse_type("self", self_allowed: false)         # => Raises an syntax error
+    # ```
+    #
+    def self.parse_type: (Buffer | String, ?byte_range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool, ?void_allowed: bool, ?self_allowed: bool, ?classish_allowed: bool) -> Types::t?
+                       | %a{deprecated: Use `byte_range:` keyword instead of `range:`} (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool, ?void_allowed: bool, ?self_allowed: bool, ?classish_allowed: bool) -> Types::t?
 
     # Parse whole RBS file and return an array of declarations
     #
     def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
 
+    # Parse a list of type parameters and return it
+    #
+    # ```ruby
+    # RBS::Parser.parse_type_params("")                          # => nil
+    # RBS::Parser.parse_type_params("[U, V]")                    # => `[:U, :V]`
+    # RBS::Parser.parse_type_params("[in U, V < Integer]")       # => `[:U, :V]`
+    # ```
+    #
+    # When `module_type_params` is `false`, an error is raised if `unchecked`, `in` or `out` are used.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type_params("[unchecked U]", module_type_params: false)   # => Raises an error
+    # RBS::Parser.parse_type_params("[out U]", module_type_params: false)         # => Raises an error
+    # RBS::Parser.parse_type_params("[in U]", module_type_params: false)          # => Raises an error
+    # ```
+    #
+    def self.parse_type_params: (Buffer | String, ?module_type_params: bool) -> Array[AST::TypeParam]
+
     # Returns the magic comment from the buffer
     #
     def self.magic_comment: (Buffer) -> AST::Directives::ResolveTypeNames?
@@ -82,18 +116,38 @@ module RBS
 
     KEYWORDS: Hash[String, bot]
 
+    # Parse a leading annotation and return it
+    #
+    # Raises an exception if the source text contains a syntax error.
+    #
+    def self.parse_inline_leading_annotation: (Buffer | String, Range[Integer?], ?variables: Array[Symbol]) -> AST::Ruby::Annotations::leading_annotation
+
+    # Parse a leading annotation and return it
+    #
+    # Raises an exception if the source text contains a syntax error.
+    #
+    def self.parse_inline_trailing_annotation: (Buffer | String, Range[Integer?], ?variables: Array[Symbol]) -> AST::Ruby::Annotations::trailing_annotation
+
     private
 
     def self.buffer: (String | Buffer source) -> Buffer
 
-    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> Types::t?
+    def self.byte_range: (Range[Integer?] char_range, String content) -> Range[Integer?]
+
+    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> Types::t?
 
     def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
 
     def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
+    def self._parse_type_params: (Buffer, Integer start_pos, Integer end_pos, bool module_type_params) -> Array[AST::TypeParam]
+
     def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
 
+    def self._parse_inline_leading_annotation: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> AST::Ruby::Annotations::leading_annotation
+
+    def self._parse_inline_trailing_annotation: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> AST::Ruby::Annotations::trailing_annotation
+
     class LocatedValue
     end
   end

data/sig/prototype/helpers.rbs

@@ -3,6 +3,8 @@ module RBS
     module Helpers
       type node = RubyVM::AbstractSyntaxTree::Node
 
+      def parse_comments: (String, include_trailing: bool) -> Hash[Integer, AST::Comment]
+
       def block_from_body: (node) -> Types::Block?
 
       def each_node: (Array[untyped] nodes) { (node) -> void } -> void

data/sig/resolver/type_name_resolver.rbs

@@ -8,28 +8,56 @@ module RBS
     class TypeNameResolver
       type query = [TypeName, context]
 
-      def initialize: (Environment) -> void
+      def initialize: (Set[TypeName] all_names, Hash[TypeName, [TypeName, context]] aliases) -> void
 
-      # Translates given type name to absolute type name.
+      def self.build: (Environment) -> instance
+
+      # Translates given type name to absolute type name
+      #
       # Returns `nil` if cannot find associated type name.
+      # Module names in the type name are normalized.
       #
       def resolve: (TypeName, context: context) -> TypeName?
 
-      private
+      # Translates given type name to absolute type name
+      #
+      # Returns `false` if a cycle is detected while resolving aliases.
+      # Returns `nil` if the type name cannot be resolved.
+      #
+      def resolve_namespace: (TypeName, context: context) -> (TypeName | false | nil)
 
-      attr_reader env: Environment
+      private
 
       attr_reader all_names: Set[TypeName]
 
+      attr_reader aliases: Hash[TypeName, [TypeName, context]]
+
       attr_reader cache: Hash[query, TypeName?]
 
-      def has_name?: (TypeName) -> TypeName?
+      # Returns the type name if it exists in `all_names` (normalized)
+      #
+      def has_type_name?: (TypeName) -> TypeName?
+
+      # Returns the type name if it is an alias (not normalized)
+      #
+      def aliased_name?: (TypeName) -> TypeName?
 
       def try_cache: (query) { () -> TypeName? } -> TypeName?
 
-      def resolve_in: (Symbol, context) -> TypeName?
+      # Translates the head module name in the context and returns an absolute type name
+      #
+      # Returns `nil` if cannot find associated type name.
+      # The returned namespace may be an alias
+      #
+      def resolve_head_namespace: (Symbol, context) -> TypeName?
+
+      # Resolves the type name in the given context
+      #
+      def resolve_type_name: (Symbol, context) -> TypeName?
+
+      def resolve_namespace0: (TypeName, context, Set[TypeName]) -> (TypeName | false | nil)
 
-      def partition: (TypeName) -> [Symbol, TypeName?]
+      def normalize_namespace: (TypeName, TypeName rhs, context, Set[TypeName]) -> (TypeName | false | nil)
     end
   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

@@ -72,8 +72,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