rbs 3.9.4 → 3.10.2

data/sig/environment.rbs

@@ -190,22 +190,58 @@ module RBS
     # Returns true if the type name is a class alias
     def class_alias?: (TypeName) -> bool
 
-    def class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | nil)
+    # Returns the entry for the class name
+    #
+    # Returns `nil` when:
+    #
+    # * The type name is not found
+    # * The type name is not a class
+    #
+    # It normalizes when `normalized: true` is given -- returns `ClassEntry` or `nil`.
+    #
+    def class_entry: (TypeName, normalized: true) -> ClassEntry?
+                   | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | nil)
 
     # Returns ClassEntry if the class definition is found, normalized in case of alias
     #
+    %a{deprecated: Use `class_entry(type_name, normalized: true)` instead. }
     def normalized_class_entry: (TypeName) -> ClassEntry?
 
-    def module_entry: (TypeName) -> (ModuleEntry | ModuleAliasEntry | nil)
+    # Returns the entry for the module name
+    #
+    # Returns `nil` when:
+    #
+    # * The type name is not found
+    # * The type name is not a module
+    #
+    # It normalizes when `normalized: true` is given -- returns `ModuleEntry` or `nil`.
+    #
+    def module_entry: (TypeName, normalized: true) -> ModuleEntry?
+                    | (TypeName, ?normalized: bool) -> (ModuleEntry | ModuleAliasEntry | nil)
 
     # Returns ModuleEntry if the module definition is found, normalized in case of alias
     #
+    %a{deprecated: Use `module_entry(type_name, normalized: true)` instead. }
     def normalized_module_entry: (TypeName) -> ModuleEntry?
 
-    def constant_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
+    # Returns the entry for the type name
+    #
+    # The entry is one of ClassEntry, ModuleEntry, ConstantEntry, ClassAliasEntry, or ModuleAliasEntry.
+    # When `normalized: true` is given, it returns normalized entry -- one of ClassEntry, ModuleEntry, or ConstantEntry.
+    #
+    # Returns `nil` if not found.
+    #
+    def constant_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | ConstantEntry | nil)
+                      | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
 
-    def module_class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
+    # Returns ClassEntry or ModuleEntry if the class/module definition is found
+    #
+    # Normalizes when `normalized: true` is given.
+    #
+    def module_class_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | nil)
+                          | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
 
+    %a{deprecated: Use `module_class_entry(type_name, normalized: true)` instead. }
     def normalized_module_class_entry: (TypeName) -> (ClassEntry | ModuleEntry | nil)
 
     @normalize_module_name_cache: Hash[TypeName, TypeName | false | nil]
@@ -216,26 +252,39 @@ module RBS
     # * Returns `nil` if the rhs name cannot be found
     # * Returns `false` if the name is cyclic
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_module_name?: (TypeName) -> (TypeName | nil | false)
 
-    # Returns the original module name that is defined with `module` declaration
+    # Returns the original module name that is defined with `module`/`class` declaration
     #
-    # * Raises an error if given type name is not module
+    # * Raises an error if given type name is not module/class
     # * Calls `#absolute!` for relative module names
     # * Returns the name itself if the name cannot be normalized to a class/module
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_module_name: (TypeName) -> TypeName
 
+    # Returns the original module name that is defined with `module`/`class` declaration
+    #
+    # * Raises an error if given type name is not a module/class
+    def normalize_module_name!: (TypeName) -> TypeName
+
     # Returns a normalized module/class name or a type name with a normalized namespace
     #
     # * Calls `#absolute!` for relative module names
     # * Returns `nil` if the typename cannot be found
     # * Returns `false` if the name is cyclic
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
 
     # Normalize the type name or raises an error
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_type_name!: (TypeName) -> TypeName
 
     # Returns a normalized module/class name or a type name with a normalized namespace
@@ -243,6 +292,8 @@ module RBS
     # * Calls `#absolute!` for relative module names
     # * Returns the typename itself if the name cannot be normalized
     #
+    # Note that this method assumes the declarations have resolved type names.
+    #
     def normalize_type_name: (TypeName) -> TypeName
 
     # Returns `true` if given type name is normalized

data/sig/manifest.yaml

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

data/sig/parser.rbs

@@ -68,6 +68,24 @@ module RBS
     #
     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?
@@ -92,6 +110,8 @@ module RBS
 
     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]]]
 
     class LocatedValue

data/sig/resolver/type_name_resolver.rbs

@@ -8,28 +8,59 @@ 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.new: %a{deprecated: Use `build` to build TypeNameResolver from Environment} (Environment) -> instance
+                  | (Set[TypeName] all_names, Hash[TypeName, [TypeName, context]] aliases) -> instance
+
+      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/types.rbs

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