rbs 3.9.4 → 4.1.1

data/sig/inline_parser/comment_association.rbs

@@ -0,0 +1,71 @@
+use RBS::AST::Ruby::CommentBlock
+
+module RBS
+  class InlineParser
+    # CommentAssociation manages the association between `Prism::Node` and `CommentBlock`
+    #
+    class CommentAssociation
+      attr_reader blocks: Array[CommentBlock]
+
+      attr_reader start_line_map: Hash[Integer, CommentBlock]
+
+      attr_reader end_line_map: Hash[Integer, CommentBlock]
+
+      # CommentBlocks that are already associated to a node, which cannot be associated to another node again
+      #
+      attr_reader associated_blocks: Set[CommentBlock]
+
+      def self.build: (Buffer, Prism::Result) -> instance
+
+      def initialize: (Array[CommentBlock]) -> void
+
+      class Reference
+        attr_reader block: CommentBlock
+
+        @associated_blocks: Set[CommentBlock]
+
+        def initialize: (CommentBlock, Set[CommentBlock]) -> void
+
+        def associate!: () -> self
+
+        def associated?: () -> bool
+      end
+
+      # Returns an unassociated CommentBlock that can be associated to given node
+      #
+      # Automatically updates association status.
+      #
+      def leading_block!: (Prism::Node) -> CommentBlock?
+
+      # Returns a Reference that is associated to given node
+      #
+      # Updates association explicitly through the reference.
+      #
+      def leading_block: (Prism::Node) -> Reference?
+
+      # Returns a CommentBlock that is associated to given node, or by its location
+      #
+      # Update association status.
+      #
+      def trailing_block!: (Prism::Node | Prism::Location) -> CommentBlock?
+
+      # Returns a Reference that is associated to given node, or by its location
+      #
+      # Updates association explicitly through the reference.
+      #
+      def trailing_block: (Prism::Node | Prism::Location) -> Reference?
+
+      # Yields leading CommentBlocks that is enclosed in the given node
+      #
+      # Note that `enclosed_blocks` works only after all of the *leading* blocks inside the node is associated.
+      #
+      # Update association status.
+      #
+      def each_enclosed_block: (Prism::Node) { (CommentBlock) -> void } -> void
+                             | (Prism::Node) -> Enumerator[CommentBlock]
+
+      def each_unassociated_block: () { (CommentBlock) -> void } -> void
+                                 | () -> Enumerator[CommentBlock]
+    end
+  end
+end

data/sig/inline_parser.rbs

@@ -0,0 +1,126 @@
+use RBS::AST::Ruby::Declarations
+
+module RBS
+  class InlineParser
+    class Result
+      attr_reader buffer: Buffer
+      attr_reader prism_result: Prism::ParseResult
+      attr_reader declarations: Array[AST::Ruby::Declarations::t]
+      attr_reader diagnostics: Array[Diagnostic::t]
+
+      def initialize: (Buffer, Prism::ParseResult) -> void
+
+      def type_fingerprint: () -> untyped
+    end
+
+    module Diagnostic
+      class Base
+        attr_reader message: String
+
+        attr_reader location: Location
+
+        def initialize: (Location, String) -> void
+      end
+
+      class NotImplementedYet < Base
+      end
+
+      class NonConstantClassName < Base
+      end
+
+      class NonConstantModuleName < Base
+      end
+
+      class NonConstantSuperClassName < Base
+      end
+
+      class TopLevelMethodDefinition < Base
+      end
+
+      class TopLevelAttributeDefinition < Base
+      end
+
+      class UnusedInlineAnnotation < Base
+      end
+
+      class AnnotationSyntaxError < Base
+      end
+
+      class MixinMultipleArguments < Base
+      end
+
+      class MixinNonConstantModule < Base
+      end
+
+      class AttributeNonSymbolName < Base
+      end
+
+      class NonConstantConstantDeclaration < Base
+      end
+
+      class ClassModuleAliasDeclarationMissingTypeName < Base
+      end
+
+      type t = NotImplementedYet
+             | NonConstantClassName | NonConstantModuleName | NonConstantSuperClassName
+             | TopLevelMethodDefinition | TopLevelAttributeDefinition
+             | UnusedInlineAnnotation | AnnotationSyntaxError
+             | MixinMultipleArguments | MixinNonConstantModule
+             | AttributeNonSymbolName
+             | NonConstantConstantDeclaration
+             | ClassModuleAliasDeclarationMissingTypeName
+    end
+
+    def self.parse: (Buffer, Prism::ParseResult) -> Result
+
+    class Parser < Prism::Visitor
+      type module_context = Declarations::ClassDecl | Declarations::ModuleDecl
+
+      include AST::Ruby::Helpers::ConstantHelper
+
+      include AST::Ruby::Helpers::LocationHelper
+
+      attr_reader comments: CommentAssociation
+
+      attr_reader result: Result
+
+      attr_reader module_nesting: Array[module_context]
+
+      def initialize: (Result) -> void
+
+      def buffer: () -> Buffer
+
+      %a{pure} def current_module: () -> module_context?
+
+      %a{pure} def current_module!: () -> module_context
+
+      def diagnostics: () -> Array[Diagnostic::t]
+
+      def push_module_nesting: [T] (module_context) { () -> T } -> T
+
+      # Returns `true` if the node is a comment block including `@rbs skip` annotation
+      #
+      # Doesn't update the `association` flag if returning `false`.
+      #
+      def skip_node?: (Prism::Node) -> bool
+
+      def insert_declaration: (module_context) -> void
+
+      def report_unused_annotation: (*AST::Ruby::Annotations::t | nil | AST::Ruby::CommentBlock::AnnotationSyntaxError) -> void
+
+      def report_unused_block: (AST::Ruby::CommentBlock) -> void
+
+      def visit_class_or_module_body: (module_context, Prism::ClassNode | Prism::ModuleNode) -> void
+
+      private
+
+      def parse_mixin_call: (Prism::CallNode) -> void
+
+      def parse_attribute_call: (Prism::CallNode) -> void
+
+      def parse_constant_declaration: (Prism::ConstantWriteNode | Prism::ConstantPathWriteNode) -> void
+
+      def parse_super_class: (Prism::node, Prism::Location) -> Declarations::ClassDecl::SuperClass?
+    end
+  end
+end

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

@@ -40,10 +40,30 @@ module RBS
 
     @parent: Namespace?
 
+    @hash: Integer?
+
     self.@root: Namespace?
 
     self.@empty: Namespace?
 
+    self.@intern_mutex: Mutex
+
+    # Per-`absolute` flag tries of nested Hashes keyed on path Symbols,
+    # with the cached Namespace stored under the `INTERN_LEAF` sentinel
+    # at each path's terminal node.
+    self.@intern_trie_absolute: Hash[Symbol | Module, untyped]
+
+    self.@intern_trie_relative: Hash[Symbol | Module, untyped]
+
+    INTERN_LEAF: Module
+
+    # Returns an interned `Namespace` instance.
+    #
+    # Subsequent calls with structurally equal `path` and `absolute` arguments
+    # return the same object. The internal `path` array is duplicated and
+    # frozen before being cached.
+    def self.[]: (Array[Symbol] path, boolish absolute) -> Namespace
+
     # Returns new _empty_ namespace.
     def self.empty: () -> Namespace
 
@@ -139,8 +159,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,48 @@ 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]]
 
+    # Parse and serialize the result to the binary format consumed by
+    # RBS::WASM::Deserializer (see ext/rbs_extension/main.c and
+    # docs/wasm_serialization.md). The `_to_bytes` variants exist so the
+    # round-trip can be exercised on CRuby.
+    def self._parse_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> String?
+
+    def self._parse_method_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> String?
+
+    def self._parse_signature_to_bytes: (Buffer, Integer start_pos, Integer end_pos) -> String
+
+    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/prototype/rbi.rbs

@@ -2,7 +2,17 @@ module RBS
   module Prototype
     class RBI
       include Helpers
-      
+
+      type visibility = :private | :protected | :public
+
+      class Context
+        attr_accessor singleton: bool
+
+        attr_accessor visibility: visibility
+
+        def initialize: (singleton: bool, visibility: visibility) -> void
+      end
+
       attr_reader decls: Array[AST::Declarations::t]
 
       type module_decl = AST::Declarations::Class | AST::Declarations::Module
@@ -13,13 +23,15 @@ module RBS
       # Last subsequent `sig` calls
       attr_reader last_sig: Array[RubyVM::AbstractSyntaxTree::Node]?
 
+      @contexts: Array[Context]
+
+      @emitted_visibility: Hash[Integer, visibility]
+
       def initialize: () -> void
 
       def parse: (String) -> void
 
-      def nested_name: (RubyVM::AbstractSyntaxTree::Node name) -> TypeName
-
-      def current_namespace: () -> Namespace
+      def append_decl: (AST::Declarations::t decl) -> void
 
       def push_class: (
         RubyVM::AbstractSyntaxTree::Node name,
@@ -35,6 +47,17 @@ module RBS
       # The inner most module/class definition, raises on toplevel
       def current_module!: () -> module_decl
 
+      def current_context: () -> Context?
+
+      def current_context!: () -> Context
+
+      # Visibility of a member, given as `private def ...` in RBS
+      #
+      # Returns `nil` for members in a visibility _section_, which `sync_visibility` emits instead.
+      def member_visibility: (Context) -> AST::Members::visibility?
+
+      def sync_visibility: (visibility) -> void
+
       # Put a `sig` call to current list.
       def push_sig: (RubyVM::AbstractSyntaxTree::Node node) -> void
 
@@ -45,6 +68,12 @@ module RBS
 
       def process: (RubyVM::AbstractSyntaxTree::Node node, comments: Hash[Integer, AST::Comment], ?outer: Array[RubyVM::AbstractSyntaxTree::Node]) -> void
 
+      def process_visibility: (RubyVM::AbstractSyntaxTree::Node node, outer: Array[RubyVM::AbstractSyntaxTree::Node], comments: Hash[Integer, AST::Comment]) -> void
+
+      def process_attribute: (RubyVM::AbstractSyntaxTree::Node node, comments: Hash[Integer, AST::Comment]) -> void
+
+      def attribute_type: (:attr_reader | :attr_writer | :attr_accessor kind, Array[RubyVM::AbstractSyntaxTree::Node]? sigs) -> Types::t
+
       def method_type: (RubyVM::AbstractSyntaxTree::Node? args_node, RubyVM::AbstractSyntaxTree::Node? type_node, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType?
 
       def parse_params: (RubyVM::AbstractSyntaxTree::Node args_node, RubyVM::AbstractSyntaxTree::Node args, MethodType method_type, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType

data/sig/resolver/type_name_resolver.rbs

@@ -6,30 +6,56 @@ module RBS
     # It just ignores included modules and super classes.
     #
     class TypeNameResolver
-      type query = [TypeName, context]
+      def initialize: (Set[TypeName] all_names, Hash[TypeName, [TypeName, context]] aliases) -> void
 
-      def initialize: (Environment) -> void
+      def self.build: (Environment) -> instance
 
-      # Translates given type name to absolute type name.
+      # 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 cache: Hash[query, TypeName?]
+      attr_reader aliases: Hash[TypeName, [TypeName, context]]
+
+      attr_reader cache: Hash[context, Hash[TypeName, TypeName?]]
 
-      def has_name?: (TypeName) -> TypeName?
+      # Returns the type name if it exists in `all_names` (normalized)
+      #
+      def has_type_name?: (TypeName) -> TypeName?
 
-      def try_cache: (query) { () -> TypeName? } -> TypeName?
+      # Returns the type name if it is an alias (not normalized)
+      #
+      def aliased_name?: (TypeName) -> TypeName?
+
+      def try_cache: (TypeName, context) { () -> TypeName? } -> 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_in: (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