rbs 3.9.5 → 3.10.0.pre.1

data/lib/rbs/environment.rb

@@ -223,21 +223,17 @@ module RBS
       end
     end
 
-    def class_entry(type_name)
-      case
-      when (class_entry = class_decls[type_name]).is_a?(ClassEntry)
-        class_entry
-      when (class_alias = class_alias_decls[type_name]).is_a?(ClassAliasEntry)
-        class_alias
+    def class_entry(type_name, normalized: false)
+      case entry = constant_entry(type_name, normalized: normalized || false)
+      when ClassEntry, ClassAliasEntry
+        entry
       end
     end
 
-    def module_entry(type_name)
-      case
-      when (module_entry = class_decls[type_name]).is_a?(ModuleEntry)
-        module_entry
-      when (module_alias = class_alias_decls[type_name]).is_a?(ModuleAliasEntry)
-        module_alias
+    def module_entry(type_name, normalized: false)
+      case entry = constant_entry(type_name, normalized: normalized || false)
+      when ModuleEntry, ModuleAliasEntry
+        entry
       end
     end
 
@@ -253,26 +249,40 @@ module RBS
     end
 
     def normalized_module_entry(type_name)
-      if name = normalize_module_name?(type_name)
-        case entry = module_entry(name)
-        when ModuleEntry, nil
-          entry
-        when ModuleAliasEntry
-          raise
-        end
-      end
+      module_entry(type_name, normalized: true)
     end
 
-    def module_class_entry(type_name)
-      class_entry(type_name) || module_entry(type_name)
+    def module_class_entry(type_name, normalized: false)
+      entry = constant_entry(type_name, normalized: normalized || false)
+      if entry.is_a?(ConstantEntry)
+        nil
+      else
+        entry
+      end
     end
 
     def normalized_module_class_entry(type_name)
-      normalized_class_entry(type_name) || normalized_module_entry(type_name)
+      module_class_entry(type_name, normalized: true)
     end
 
-    def constant_entry(type_name)
-      class_entry(type_name) || module_entry(type_name) || constant_decls[type_name]
+    def constant_entry(type_name, normalized: false)
+      if normalized
+        if normalized_name = normalize_module_name?(type_name)
+          class_decls.fetch(normalized_name, nil)
+        else
+          # The type_name may be declared with constant declaration
+          unless type_name.namespace.empty?
+            parent = type_name.namespace.to_type_name
+            normalized_parent = normalize_module_name?(parent) or return
+            constant_name = TypeName.new(name: type_name.name, namespace: normalized_parent.to_namespace)
+            constant_decls.fetch(constant_name, nil)
+          end
+        end
+      else
+        class_decls.fetch(type_name, nil) ||
+          class_alias_decls.fetch(type_name, nil) ||
+          constant_decls.fetch(type_name, nil)
+      end
     end
 
     def normalize_type_name?(name)
@@ -307,6 +317,10 @@ module RBS
       end
     end
 
+    def normalize_type_name(name)
+      normalize_type_name?(name) || name
+    end
+
     def normalized_type_name?(type_name)
       case
       when type_name.interface?
@@ -321,53 +335,44 @@ module RBS
     end
 
     def normalized_type_name!(name)
-      normalized_type_name?(name) or raise "Normalized type name is expected but given `#{name}`, which is normalized to `#{normalize_type_name?(name)}`"
+      normalized_type_name?(name) or raise "Normalized type name is expected but given `#{name}`"
       name
     end
 
-    def normalize_type_name(name)
-      normalize_type_name?(name) || name
-    end
-
-    def normalize_module_name(name)
-      normalize_module_name?(name) or name
-    end
-
     def normalize_module_name?(name)
       raise "Class/module name is expected: #{name}" unless name.class?
       name = name.absolute! unless name.absolute?
 
-      if @normalize_module_name_cache.key?(name)
-        return @normalize_module_name_cache[name]
+      original_name = name
+
+      if @normalize_module_name_cache.key?(original_name)
+        return @normalize_module_name_cache[original_name]
       end
 
-      unless name.namespace.empty?
-        parent = name.namespace.to_type_name
-        if normalized_parent = normalize_module_name?(parent)
-          type_name = TypeName.new(namespace: normalized_parent.to_namespace, name: name.name)
-        else
-          @normalize_module_name_cache[name] = nil
-          return
+      if alias_entry = class_alias_decls.fetch(name, nil)
+        unless alias_entry.decl.old_name.absolute?
+          # Having relative old_name means the type name resolution was failed.
+          # Run TypeNameResolver for failure reason
+          resolver = Resolver::TypeNameResolver.build(self)
+          name = resolver.resolve_namespace(name, context: nil)
+          @normalize_module_name_cache[original_name] = name
+          return name
         end
-      else
-        type_name = name
-      end
 
-      @normalize_module_name_cache[name] = false
+        name = alias_entry.decl.old_name
+      end
 
-      entry = constant_entry(type_name)
+      if class_decls.key?(name)
+        @normalize_module_name_cache[original_name] = name
+      end
+    end
 
-      normalized_type_name =
-        case entry
-        when ClassEntry, ModuleEntry
-          type_name
-        when ClassAliasEntry, ModuleAliasEntry
-          normalize_module_name?(entry.decl.old_name)
-        else
-          nil
-        end
+    def normalize_module_name(name)
+      normalize_module_name?(name) || name
+    end
 
-      @normalize_module_name_cache[name] = normalized_type_name
+    def normalize_module_name!(name)
+      normalize_module_name?(name) or raise "Module name `#{name}` cannot be normalized"
     end
 
     def insert_decl(decl, outer:, namespace:)
@@ -509,7 +514,7 @@ module RBS
     end
 
     def resolve_type_names(only: nil)
-      resolver = Resolver::TypeNameResolver.new(self)
+      resolver = Resolver::TypeNameResolver.build(self)
       env = Environment.new
 
       table = UseMap::Table.new()

data/lib/rbs/environment_loader.rb

@@ -51,7 +51,7 @@ module RBS
         dirs << path
       when library
         case library
-        when 'rubygems', 'set'
+        when 'pathname'
           RBS.logger.warn "`#{library}` has been moved to core library, so it is always loaded. Remove explicit loading `#{library}`"
           return
         end

data/lib/rbs/errors.rb

@@ -93,7 +93,7 @@ module RBS
       params =
         case
         when type_name.class?
-          decl = env.normalized_module_class_entry(type_name) or raise
+          decl = env.module_class_entry(type_name, normalized: true) or raise
           decl.type_params
         when type_name.interface?
           env.interface_decls.fetch(type_name).decl.type_params

data/lib/rbs/parser_aux.rb

@@ -35,6 +35,11 @@ module RBS
       [buf, dirs, decls]
     end
 
+    def self.parse_type_params(source, module_type_params: true)
+      buf = buffer(source)
+      _parse_type_params(buf, 0, buf.last_position, module_type_params)
+    end
+
     def self.magic_comment(buf)
       start_pos = 0
 

data/lib/rbs/resolver/constant_resolver.rb

@@ -32,7 +32,7 @@ module RBS
           end
 
           environment.class_alias_decls.each do |name, entry|
-            normalized_entry = environment.normalized_module_class_entry(name) or next
+            normalized_entry = environment.module_class_entry(name, normalized: true) or next
             constant = constant_of_module(name, normalized_entry)
 
             # Insert class/module aliases into `children_table` and `toplevel` table
@@ -176,7 +176,7 @@ module RBS
       end
 
       def constants_from_ancestors(module_name, constants:)
-        entry = builder.env.normalized_module_class_entry(module_name) or raise
+        entry = builder.env.module_class_entry(module_name, normalized: true) or raise
 
         if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
           constants.merge!(table.children(BuiltinNames::Object.name) || raise)

data/lib/rbs/resolver/type_name_resolver.rb

@@ -5,17 +5,36 @@ module RBS
     class TypeNameResolver
       attr_reader :all_names
       attr_reader :cache
-      attr_reader :env
+      attr_reader :aliases
 
-      def initialize(env)
-        @all_names = Set[]
+      def initialize(all_names, aliases)
+        @all_names = all_names
+        @aliases = aliases
         @cache = {}
-        @env = env
+      end
+
+      def self.new(*args)
+        if args.size == 1 && args[0].is_a?(Environment)
+          build(args[0])
+        else
+          super
+        end
+      end
+
+      def self.build(env)
+        all_names = Set.new #: Set[TypeName]
 
         all_names.merge(env.class_decls.keys)
         all_names.merge(env.interface_decls.keys)
         all_names.merge(env.type_alias_decls.keys)
-        all_names.merge(env.class_alias_decls.keys)
+
+        aliases = {} #: Hash[TypeName, [TypeName, context]]
+
+        env.class_alias_decls.each do |name, entry|
+          aliases[name] = [entry.decl.old_name, entry.context]
+        end
+
+        new(all_names, aliases)
       end
 
       def try_cache(query)
@@ -26,64 +45,131 @@ module RBS
       end
 
       def resolve(type_name, context:)
-        if type_name.absolute?
+        if type_name.absolute? && has_type_name?(type_name)
           return type_name
         end
 
         try_cache([type_name, context]) do
-          head, tail = partition(type_name)
+          if type_name.class?
+            resolve_namespace0(type_name, context, Set.new) || nil
+          else
+            namespace = type_name.namespace
 
-          head = resolve_in(head, context)
-
-          if head
-            if tail
-              absolute_name = tail.with_prefix(head.to_namespace)
-              if env.normalize_type_name?(absolute_name)
-                absolute_name
-              end
+            if namespace.empty?
+              resolve_type_name(type_name.name, context)
             else
-              head
+              if namespace = resolve_namespace0(namespace.to_type_name, context, Set.new)
+                type_name = TypeName.new(name: type_name.name, namespace: namespace.to_namespace)
+                has_type_name?(type_name)
+              end
             end
           end
         end
       end
 
-      def partition(type_name)
-        if type_name.namespace.empty?
-          head = type_name.name
-          tail = nil
-        else
-          head, *tail = type_name.namespace.path
+      def resolve_namespace(type_name, context:)
+        if type_name.absolute? && has_type_name?(type_name)
+          return type_name
+        end
 
-          head or raise
+        unless type_name.class?
+          raise "Type name must be a class name: #{type_name}"
+        end
+
+        try_cache([type_name, context]) do
+          ns = resolve_namespace0(type_name, context, Set.new) or return ns
+        end
+      end
 
-          tail = TypeName.new(
-            name: type_name.name,
-            namespace: Namespace.new(absolute: false, path: tail)
-          )
+      def has_type_name?(full_name)
+        if all_names.include?(full_name)
+          full_name
         end
+      end
 
-        [head, tail]
+      def aliased_name?(type_name)
+        if aliases.key?(type_name)
+          type_name
+        end
       end
 
-      def resolve_in(head, context)
+      def resolve_type_name(type_name, context)
         if context
-          parent, child = context
-          case child
+          outer, inner = context
+          case inner
           when false
-            resolve_in(head, parent)
+            resolve_type_name(type_name, outer)
+          else
+            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
+            has_type_name?(TypeName.new(name: type_name, namespace: inner.to_namespace)) || resolve_type_name(type_name, outer)
+          end
+        else
+          type_name = TypeName.new(name: type_name, namespace: Namespace.root)
+          has_type_name?(type_name)
+        end
+      end
+
+      def resolve_head_namespace(head, context)
+        if context
+          outer, inner = context
+          case inner
+          when false
+            resolve_head_namespace(head, outer)
           when TypeName
-            name = TypeName.new(name: head, namespace: child.to_namespace)
-            has_name?(name) || resolve_in(head, parent)
+            has_type_name?(inner) or raise "Context must be normalized: #{inner.inspect}"
+            type_name = TypeName.new(name: head, namespace: inner.to_namespace)
+            has_type_name?(type_name) || aliased_name?(type_name) || resolve_head_namespace(head, outer)
           end
         else
-          has_name?(TypeName.new(name: head, namespace: Namespace.root))
+          type_name = TypeName.new(name: head, namespace: Namespace.root)
+          has_type_name?(type_name) || aliased_name?(type_name)
         end
       end
 
-      def has_name?(full_name)
-        if all_names.include?(full_name)
-          full_name
+      def normalize_namespace(type_name, rhs, context, visited)
+        if visited.include?(type_name)
+          # Cycle detected
+          return false
+        end
+
+        visited << type_name
+
+        begin
+          resolve_namespace0(rhs, context, visited)
+        ensure
+          visited.delete(type_name)
+        end
+      end
+
+      def resolve_namespace0(type_name, context, visited)
+        head, *tail = [*type_name.namespace.path, type_name.name]
+
+        head = head #: Symbol
+
+        head =
+          if type_name.absolute?
+            root_name = TypeName.new(name: head, namespace: Namespace.root)
+            has_type_name?(root_name) || aliased_name?(root_name)
+          else
+            resolve_head_namespace(head, context)
+          end
+
+        if head
+          if (rhs, context = aliases.fetch(head, nil))
+            head = normalize_namespace(head, rhs, context, visited) or return head
+          end
+
+          tail.inject(head) do |namespace, name|
+            type_name = TypeName.new(name: name, namespace: namespace.to_namespace)
+            case
+            when has_type_name?(type_name)
+              type_name
+            when (rhs, context = aliases.fetch(type_name, nil))
+              m = normalize_namespace(type_name, rhs, context, visited) or return m
+            else
+              return nil
+            end
+          end
         end
       end
     end

data/lib/rbs/test/type_check.rb

@@ -288,6 +288,19 @@ module RBS
                   values << args
                   nil
                 end
+              when nil
+                values = []
+                count = 10_000
+
+                ret = val.each do |*args|
+                  count -= 1
+                  values << args
+                  break if count <= 0
+                end
+
+                if count == 0
+                  ret = self
+                end
               else
                 values = []
                 ret = val.each do |*args|

data/lib/rbs/types.rb

@@ -1339,8 +1339,10 @@ module RBS
       attr_reader :type
       attr_reader :required
       attr_reader :self_type
+      attr_reader :location
 
-      def initialize(type:, required:, self_type: nil)
+      def initialize(location: nil, type:, required:, self_type: nil)
+        @location = location
         @type = type
         @required = required ? true : false
         @self_type = self_type

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.9.5"
+  VERSION = "3.10.0.pre.1"
 end

data/lib/rbs.rb

@@ -4,7 +4,7 @@ require "rbs/version"
 
 require "set"
 require "json"
-require "pathname"
+require "pathname" unless defined?(Pathname)
 require "pp"
 require "ripper"
 require "logger"

data/lib/rdoc/discover.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 begin
-  gem 'rdoc', '~> 6.4'
+  gem 'rdoc', '~> 6.16'
   require 'rdoc_plugin/parser'
   module RDoc
     class Parser

data/lib/rdoc_plugin/parser.rb

@@ -76,7 +76,7 @@ module RBS
         method.visibility = decl.visibility
         method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
         if loc = decl.location
-          method.start_collecting_tokens
+          method.start_collecting_tokens(:ruby)
           method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })
           method.add_token({ line_no: 1, char_no: 1, text: loc.source })
           method.line = loc.start_line
@@ -86,7 +86,7 @@ module RBS
       end
 
       def parse_method_alias_decl(decl:, context:, outer_name: nil)
-        alias_def = RDoc::Alias.new(nil, decl.old_name.to_s, decl.new_name.to_s, nil, decl.kind == :singleton)
+        alias_def = RDoc::Alias.new(nil, decl.old_name.to_s, decl.new_name.to_s, nil, singleton: decl.kind == :singleton)
         alias_def.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
         context.add_alias(alias_def)
       end
@@ -100,7 +100,7 @@ module RBS
              when ::RBS::AST::Members::AttrAccessor
                'RW'
              end
-        attribute = RDoc::Attr.new(nil, decl.name.to_s, rw, nil, decl.kind == :singleton)
+        attribute = RDoc::Attr.new(nil, decl.name.to_s, rw, nil, singleton: decl.kind == :singleton)
         attribute.visibility = decl.visibility
         attribute.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
         context.add_attribute(attribute)

data/sig/annotate/formatter.rbs

@@ -17,8 +17,8 @@ module RBS
 
       def self.translate: (RDoc::Markup::Document) -> String?
 
-      def self.each_part: (RDoc::Markup::Document | RDoc::Comment | String) { (RDoc::Markup::Document) -> void } -> void
-                        | (RDoc::Markup::Document | RDoc::Comment | String) -> Enumerator[RDoc::Markup::Document, void]
+      def self.each_part: (RDoc::Markup::Document) { (RDoc::Markup::Document) -> void } -> void
+                        | (RDoc::Markup::Document) -> Enumerator[RDoc::Markup::Document, void]
     end
   end
 end

data/sig/annotate/rdoc_annotater.rbs

@@ -17,7 +17,7 @@ module RBS
       end
 
       interface _WithRDocComment
-        def comment: () -> (RDoc::Markup::Document | RDoc::Comment | String)
+        def comment: () -> (RDoc::Comment | String)
       end
 
       def each_part: (Array[Object & _WithRDocComment], tester: _PathTester) { ([RDoc::Markup::Document, Object & _WithRDocComment]) -> void } -> void

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