rbs 3.1.0 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae81eb182ddb9f708925c47a5c98adcf0535ec1ddd7ff06127ba2602f076daf9
-  data.tar.gz: f791c1e0d14b1407ec6ae8ecb0deec2f9c5069852b67d716243a9262b4d49831
+  metadata.gz: 7b7971d4b64c169d220fe2c0895630a36ebc6505b68689fba0660be24bcd24c0
+  data.tar.gz: 2f6b8a68c5817d25c3ba179eb3965751f0b406c7dcf2d0812fe41d96bbac6e7c
 SHA512:
-  metadata.gz: 11b754b36d8a1c903538638774e1b51fa6abb08370ae1009d0c0c389a12b72cd222b2706e543dc89bf66f889b0eb60598a32473ee7cf52517410161259c098c8
-  data.tar.gz: 4f3694a3bec4492b4b885cf22d1ecf2c8e3408fc55609db45081de6865d2925ec31c7bccfb05258198b390c34f3348fe0ffc33f8f47b82cfba44f1fb3d393b43
+  metadata.gz: 4647a2dce17379807dae65a355d0fb2174d18062dbeb98d51c0c06f125d19d665ff32e3528c7326925ba11abed838b0ffff35e3708a25931fa1c4ea8c25d5eae
+  data.tar.gz: 68e20554c2941971aa99015343ef59768a653ed23fc0d6b59eeb64223dff56e8c0aa61846402f28d5f8f9e5ce33763e116cdf08cb8ca9dcfb07177d1eeab9d68

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## master
 
+## 3.1.2 (2023-07-27)
+
+⚠️ Note that this patch level release may report additional validation errors that is caused by fix of type name resolution ([#1373](https://github.com/ruby/rbs/pull/1373)).
+
+### Library changes
+
+* Make `TypeNameResolver` more compatible with Ruby ([#1373](https://github.com/ruby/rbs/pull/1373))
+* Fix module alias normalizations ([#1393](https://github.com/ruby/rbs/pull/1393))
+
+## 3.1.1 (2023-07-18)
+
+### Signature updates
+
+* Removed `GC.verify_transient_heap_internal_consistency` ([#1374](https://github.com/ruby/rbs/pull/1374))
+
+### Library changes
+
+* Relax rdoc version requirement in RDoc plugin ([#1333](https://github.com/ruby/rbs/pull/1333))
+
+#### rbs collection
+
+* Spec may be missing when rbs_collection.yaml declares dependency ([#1378](https://github.com/ruby/rbs/pull/1378))
+
+### Miscellaneous
+
+* Handle connection error with Resolv_test.rb ([#1356](https://github.com/ruby/rbs/pull/1356))
+* Fix broken CI ([#1353](https://github.com/ruby/rbs/pull/1353))
+
 ## 3.1.0 (2023-04-26)
 
 ### Signature updates

data/Gemfile

@@ -18,7 +18,7 @@ gem "dbm"
 gem 'digest'
 gem 'tempfile'
 gem "prime"
-gem "rdoc", "< 6.5.0"
+gem "rdoc", "~> 6.4.0"
 
 # Test gems
 gem "rbs-amber", path: "test/assets/test-gem"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbs (3.1.0)
+    rbs (3.1.2)
 
 PATH
   remote: test/assets/test-gem
@@ -17,7 +17,7 @@ GEM
     dbm (1.1.0)
     debase (0.2.5.beta2)
       debase-ruby_core_source (>= 0.10.12)
-    debase-ruby_core_source (3.2.0)
+    debase-ruby_core_source (3.2.1)
     diff-lcs (1.5.0)
     digest (3.1.1)
     forwardable (1.3.2)
@@ -31,23 +31,25 @@ GEM
       addressable (>= 2.8)
     marcel (1.0.2)
     minitest (5.18.0)
-    parallel (1.22.1)
-    parser (3.2.2.0)
+    parallel (1.23.0)
+    parser (3.2.2.3)
       ast (~> 2.4.1)
-    power_assert (2.0.2)
+      racc
+    power_assert (2.0.3)
     prime (0.1.2)
       forwardable
       singleton
     psych (4.0.6)
       stringio
     public_suffix (5.0.1)
+    racc (1.7.1)
     rainbow (3.1.1)
     rake (13.0.6)
-    rake-compiler (1.2.1)
+    rake-compiler (1.2.2)
       rake
     rdoc (6.4.0)
       psych (>= 4.0.0)
-    regexp_parser (2.8.0)
+    regexp_parser (2.8.1)
     rexml (3.2.5)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
@@ -62,17 +64,17 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.0)
-    rubocop (1.50.2)
+    rubocop (1.52.1)
       json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.2.0.0)
+      parser (>= 3.2.2.3)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
       rubocop-ast (>= 1.28.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.28.0)
+    rubocop-ast (1.29.0)
       parser (>= 3.2.1.0)
     rubocop-rubycw (0.1.6)
       rubocop (~> 1.0)
@@ -81,10 +83,10 @@ GEM
     ruby-progressbar (1.13.0)
     singleton (0.1.1)
     stackprof (0.2.25)
-    stringio (3.0.4)
+    stringio (3.0.7)
     strong_json (2.1.2)
     tempfile (0.1.3)
-    test-unit (3.5.7)
+    test-unit (3.5.9)
       power_assert
     unicode-display_width (2.4.2)
 
@@ -105,7 +107,7 @@ DEPENDENCIES
   rake-compiler
   rbs!
   rbs-amber!
-  rdoc (< 6.5.0)
+  rdoc (~> 6.4.0)
   rspec
   rubocop
   rubocop-rubycw

data/core/file.rbs

@@ -1971,67 +1971,171 @@ File::SEPARATOR: String
 #
 File::Separator: String
 
+# <!-- rdoc-file=file.c -->
+# File::Constants provides file-related constants.  All possible file constants
+# are listed in the documentation but they may not all be present on your
+# platform.
+#
+# If the underlying platform doesn't define a constant the corresponding Ruby
+# constant is not defined.
+#
+# Your platform documentations (e.g. man open(2)) may describe more detailed
+# information.
+#
 module File::Constants
 end
 
+# <!-- rdoc-file=file.c -->
+# append on each write
+#
 File::Constants::APPEND: Integer
 
+# <!-- rdoc-file=file.c -->
+# disable line code conversion
+#
 File::Constants::BINARY: Integer
 
+# <!-- rdoc-file=file.c -->
+# create file if it does not exist
+#
 File::Constants::CREAT: Integer
 
+# <!-- rdoc-file=file.c -->
+# Try to minimize cache effects of the I/O to and from this file.
+#
 File::Constants::DIRECT: Integer
 
+# <!-- rdoc-file=file.c -->
+# any write operation perform synchronously except some meta data
+#
 File::Constants::DSYNC: Integer
 
+# <!-- rdoc-file=file.c -->
+# error if CREAT and the file exists
+#
 File::Constants::EXCL: Integer
 
+# <!-- rdoc-file=dir.c -->
+# Makes File.fnmatch patterns case insensitive (but not Dir.glob patterns).
+#
 File::Constants::FNM_CASEFOLD: Integer
 
+# <!-- rdoc-file=dir.c -->
+# The '*' wildcard matches filenames starting with "." in File.fnmatch and
+# Dir.glob patterns
+#
 File::Constants::FNM_DOTMATCH: Integer
 
+# <!-- rdoc-file=dir.c -->
+# Allows file globbing through "{a,b}" in File.fnmatch patterns.
+#
 File::Constants::FNM_EXTGLOB: Integer
 
+# <!-- rdoc-file=dir.c -->
+# Disables escapes in File.fnmatch and Dir.glob patterns
+#
 File::Constants::FNM_NOESCAPE: Integer
 
+# <!-- rdoc-file=dir.c -->
+# Wildcards in File.fnmatch and Dir.glob patterns do not match directory
+# separators
+#
 File::Constants::FNM_PATHNAME: Integer
 
+# <!-- rdoc-file=dir.c -->
+# Makes patterns to match short names if existing.  Valid only on Microsoft
+# Windows.
+#
 File::Constants::FNM_SHORTNAME: Integer
 
+# <!-- rdoc-file=dir.c -->
+# System default case insensitiveness, equals to FNM_CASEFOLD or 0.
+#
 File::Constants::FNM_SYSCASE: Integer
 
+# <!-- rdoc-file=file.c -->
+# exclusive lock. see File#flock
+#
 File::Constants::LOCK_EX: Integer
 
+# <!-- rdoc-file=file.c -->
+# non-blocking lock. used with LOCK_SH or LOCK_EX. see File#flock
+#
 File::Constants::LOCK_NB: Integer
 
+# <!-- rdoc-file=file.c -->
+# shared lock. see File#flock
+#
 File::Constants::LOCK_SH: Integer
 
+# <!-- rdoc-file=file.c -->
+# unlock. see File#flock
+#
 File::Constants::LOCK_UN: Integer
 
+# <!-- rdoc-file=file.c -->
+# do not change atime
+#
 File::Constants::NOATIME: Integer
 
+# <!-- rdoc-file=file.c -->
+# not to make opened IO the controlling terminal device
+#
 File::Constants::NOCTTY: Integer
 
+# <!-- rdoc-file=file.c -->
+# do not follow symlinks
+#
 File::Constants::NOFOLLOW: Integer
 
+# <!-- rdoc-file=file.c -->
+# do not block on open or for data to become available
+#
 File::Constants::NONBLOCK: Integer
 
+# <!-- rdoc-file=file.c -->
+# Name of the null device
+#
 File::Constants::NULL: String
 
+# <!-- rdoc-file=file.c -->
+# open for reading only
+#
 File::Constants::RDONLY: Integer
 
+# <!-- rdoc-file=file.c -->
+# open for reading and writing
+#
 File::Constants::RDWR: Integer
 
+# <!-- rdoc-file=file.c -->
+# any read operation perform synchronously. used with SYNC or DSYNC.
+#
 File::Constants::RSYNC: Integer
 
+# <!-- rdoc-file=file.c -->
+# can delete opened file
+#
 File::Constants::SHARE_DELETE: Integer
 
+# <!-- rdoc-file=file.c -->
+# any write operation perform synchronously
+#
 File::Constants::SYNC: Integer
 
+# <!-- rdoc-file=file.c -->
+# Create an unnamed temporary file
+#
 File::Constants::TMPFILE: Integer
 
+# <!-- rdoc-file=file.c -->
+# truncate size to 0
+#
 File::Constants::TRUNC: Integer
 
+# <!-- rdoc-file=file.c -->
+# open for writing only
+#
 File::Constants::WRONLY: Integer
 
 # <!-- rdoc-file=file.c -->

data/core/gc.rbs

@@ -234,13 +234,6 @@ module GC
   #
   def self.verify_internal_consistency: () -> nil
 
-  # <!--
-  #   rdoc-file=gc.c
-  #   - verify_transient_heap_internal_consistency()
-  # -->
-  #
-  def self.verify_transient_heap_internal_consistency: () -> nil
-
   # <!--
   #   rdoc-file=gc.rb
   #   - GC.latest_gc_info -> hash

data/core/process.rbs

@@ -1645,6 +1645,9 @@ module Process::UID
   def self.eid=: (Integer user) -> Integer
 end
 
+# <!-- rdoc-file=process.c -->
+# Placeholder for rusage
+#
 class Process::Tms < Struct[Float]
 end
 

data/lib/rbs/collection/config/lockfile_generator.rb

@@ -133,10 +133,14 @@ module RBS
             end
           end
 
-          gem_hash[name].dependencies.each do |dep|
-            if spec = gem_hash[dep.name]
-              assign_gem(name: dep.name, version: spec.version, src_data: nil, ignored_gems: ignored_gems)
+          if spec = gem_hash.fetch(name, nil)
+            spec.dependencies.each do |dep|
+              if dep_spec = gem_hash[dep.name]
+                assign_gem(name: dep.name, version: dep_spec.version, src_data: nil, ignored_gems: ignored_gems)
+              end
             end
+          else
+            RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
           end
         end
 

data/lib/rbs/definition_builder.rb

@@ -753,12 +753,14 @@ module RBS
     end
 
     def expand_alias1(type_name)
+      type_name = env.normalize_type_name(type_name)
       entry = env.type_alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
       as = entry.decl.type_params.each.map { Types::Bases::Any.new(location: nil) }
       expand_alias2(type_name, as)
     end
 
     def expand_alias2(type_name, args)
+      type_name = env.normalize_type_name(type_name)
       entry = env.type_alias_decls[type_name] or raise "Unknown alias name: #{type_name}"
 
       ensure_namespace!(type_name.namespace, location: entry.decl.location)
@@ -811,9 +813,8 @@ module RBS
     end
 
     def validate_type_name(name, location)
-      name = name.absolute!
-
-      return if env.type_name?(name)
+      name = name.absolute! unless name.absolute?
+      return if env.type_name?(env.normalize_type_name(name))
 
       raise NoTypeFoundError.new(type_name: name, location: location)
     end

data/lib/rbs/environment.rb

@@ -275,53 +275,96 @@ module RBS
       class_entry(type_name) || module_entry(type_name) || constant_decls[type_name]
     end
 
+    def normalize_type_name?(name)
+      if name.class?
+        normalize_module_name?(name)
+      else
+        unless name.namespace.empty?
+          parent = name.namespace.to_type_name
+          parent = normalize_module_name?(parent)
+          return parent unless parent
+
+          TypeName.new(namespace: parent.to_namespace, name: name.name)
+        else
+          name
+        end
+      end
+    end
+
+    def normalize_type_name!(name)
+      result = normalize_type_name?(name)
+
+      case result
+      when TypeName
+        result
+      when false
+        raise "Type name `#{name}` cannot be normalized because it's a cyclic definition"
+      when nil
+        raise "Type name `#{name}` cannot be normalized because of unknown type name in the path"
+      end
+    end
+
+    def normalized_type_name?(type_name)
+      case
+      when type_name.interface?
+        interface_decls.key?(type_name)
+      when type_name.class?
+        class_decls.key?(type_name)
+      when type_name.alias?
+        type_alias_decls.key?(type_name)
+      else
+        false
+      end
+    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)}`"
+      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! if name.relative!
+      name = name.absolute! unless name.absolute?
 
       if @normalize_module_name_cache.key?(name)
         return @normalize_module_name_cache[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
+        end
+      else
+        type_name = name
+      end
+
       @normalize_module_name_cache[name] = false
 
-      entry = constant_entry(name)
-      case entry
-      when ClassEntry, ModuleEntry
-        @normalize_module_name_cache[name] = entry.name
-        entry.name
+      entry = constant_entry(type_name)
 
-      when ClassAliasEntry, ModuleAliasEntry
-        old_name = entry.decl.old_name
-        if old_name.namespace.empty?
-          @normalize_module_name_cache[name] = normalize_module_name?(old_name)
+      normalized_type_name =
+        case entry
+        when ClassEntry, ModuleEntry
+          type_name
+        when ClassAliasEntry, ModuleAliasEntry
+          normalize_module_name?(entry.decl.old_name)
         else
-          parent = old_name.namespace.to_type_name
-
-          if normalized_parent = normalize_module_name?(parent)
-            @normalize_module_name_cache[name] =
-              if normalized_parent == parent
-                normalize_module_name?(old_name)
-              else
-                normalize_module_name?(
-                  TypeName.new(name: old_name.name, namespace: normalized_parent.to_namespace)
-                )
-              end
-          else
-            @normalize_module_name_cache[name] = nil
-          end
+          nil
         end
 
-      when ConstantEntry
-        raise "#{name} is a constant name"
-
-      else
-        @normalize_module_name_cache[name] = nil
-      end
+      @normalize_module_name_cache[name] = normalized_type_name
     end
 
     def insert_decl(decl, outer:, namespace:)

data/lib/rbs/errors.rb

@@ -185,7 +185,8 @@ module RBS
     end
 
     def self.check!(super_decl, env:)
-      return if env.class_decl?(super_decl.name) || env.class_alias?(super_decl.name)
+      super_name = env.normalize_type_name(super_decl.name)
+      return if env.class_decl?(super_name) || env.class_alias?(super_name)
 
       raise new(super_decl)
     end
@@ -205,9 +206,8 @@ module RBS
     end
 
     def self.check!(self_type, env:)
-      type_name = self_type.name
-
-      (env.module_name?(type_name) || env.interface_name?(type_name)) or raise new(type_name: type_name, location: self_type.location)
+      self_name = env.normalize_type_name(self_type.name)
+      (env.module_name?(self_name) || env.interface_name?(self_name)) or raise new(type_name: self_type.name, location: self_type.location)
     end
   end
 

data/lib/rbs/resolver/type_name_resolver.rb

@@ -5,10 +5,12 @@ module RBS
     class TypeNameResolver
       attr_reader :all_names
       attr_reader :cache
+      attr_reader :env
 
       def initialize(env)
         @all_names = Set[]
         @cache = {}
+        @env = env
 
         all_names.merge(env.class_decls.keys)
         all_names.merge(env.interface_decls.keys)
@@ -29,22 +31,53 @@ module RBS
         end
 
         try_cache([type_name, context]) do
-          resolve_in(type_name, context)
+          head, tail = partition(type_name)
+
+          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
+            else
+              head
+            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
+
+          head or raise
+
+          tail = TypeName.new(
+            name: type_name.name,
+            namespace: Namespace.new(absolute: false, path: tail)
+          )
         end
+
+        [head, tail]
       end
 
-      def resolve_in(type_name, context)
+      def resolve_in(head, context)
         if context
           parent, child = context
           case child
           when false
-            resolve_in(type_name, parent)
+            resolve_in(head, parent)
           when TypeName
-            name = type_name.with_prefix(child.to_namespace)
-            has_name?(name) || resolve_in(type_name, parent)
+            name = TypeName.new(name: head, namespace: child.to_namespace)
+            has_name?(name) || resolve_in(head, parent)
           end
         else
-          has_name?(type_name.absolute!)
+          has_name?(TypeName.new(name: head, namespace: Namespace.root))
         end
       end
 

data/lib/rbs/type_alias_dependency.rb

@@ -20,7 +20,7 @@ module RBS
       # Construct transitive closure, if not constructed already
       transitive_closure() unless @dependencies
 
-      # Check for recursive type alias
+      alias_name = env.normalize_type_name!(alias_name)
       @dependencies[alias_name][alias_name]
     end
 
@@ -49,6 +49,16 @@ module RBS
       end
     end
 
+    def direct_dependencies_of(name)
+      name = env.normalize_type_name!(name)
+      @direct_dependencies[name]
+    end
+
+    def dependencies_of(name)
+      name = env.normalize_type_name!(name)
+      @dependencies[name].each_key.to_set
+    end
+
     private
 
     # Constructs directed graph recursively
@@ -61,7 +71,7 @@ module RBS
         end
       when RBS::Types::Alias
         # Append type name if the type is an alias
-        result << type.name
+        result << env.normalize_type_name(type.name)
       end
 
       result

data/lib/rbs/type_alias_regularity.rb

@@ -37,10 +37,12 @@ module RBS
     end
 
     def validate_alias_type(alias_type, names, types)
-      if names.include?(alias_type.name)
-        if ex_type = types[alias_type.name]
+      alias_name = env.normalize_type_name?(alias_type.name) or return
+
+      if names.include?(alias_name)
+        if ex_type = types[alias_name]
           unless compatible_args?(ex_type.args, alias_type.args)
-            diagnostics[alias_type.name] ||=
+            diagnostics[alias_name] ||=
               Diagnostic.new(type_name: alias_type.name, nonregular_type: alias_type)
           end
 
@@ -49,7 +51,7 @@ module RBS
           types[alias_type.name] = alias_type
         end
 
-        expanded = builder.expand_alias2(alias_type.name, alias_type.args)
+        expanded = builder.expand_alias2(alias_name, alias_type.args)
         each_alias_type(expanded) do |at|
           validate_alias_type(at, names, types)
         end
@@ -75,22 +77,27 @@ module RBS
     end
 
     def nonregular?(type_name)
-      diagnostics[type_name]
+      diagnostics[env.normalize_type_name!(type_name)]
     end
 
     def each_mutual_alias_defs(&block)
-      # @type var each_node: TSort::_EachNode[TypeName]
-      each_node = __skip__ = -> (&block) do
+      # @type var each_node: ^() { (TypeName) -> void } -> void
+      each_node = -> (&block) do
         env.type_alias_decls.each_value do |decl|
-          block[decl.name]
+          if normalized = env.normalize_type_name?(decl.name)
+            block[normalized]
+          end
         end
       end
-      # @type var each_child: TSort::_EachChild[TypeName]
-      each_child = __skip__ = -> (name, &block) do
+
+      # @type var each_child: ^(TypeName) { (TypeName) -> void } -> void
+      each_child = -> (name, &block) do
         if env.type_alias_decls.key?(name)
           type = builder.expand_alias1(name)
           each_alias_type(type) do |ty|
-            block[ty.name]
+            if normalized = env.normalize_type_name?(ty.name)
+              block[normalized]
+            end
           end
         end
       end

data/lib/rbs/validator.rb

@@ -12,9 +12,9 @@ module RBS
       @definition_builder = DefinitionBuilder.new(env: env)
     end
 
-    def absolute_type(type, context:)
+    def absolute_type(type, context:, &block)
       type.map_type_name do |type_name, _, type|
-        resolver.resolve(type_name, context: context) || yield(type)
+        resolver.resolve(type_name, context: context) || (block ? yield(type) : type_name)
       end
     end
 
@@ -22,33 +22,34 @@ module RBS
     def validate_type(type, context:)
       case type
       when Types::ClassInstance, Types::Interface, Types::Alias
-        # @type var type: Types::ClassInstance | Types::Interface | Types::Alias
-        if type.name.namespace.relative?
-          type = _ = absolute_type(type, context: context) do |_|
-            NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
-          end
-        end
+        type = absolute_type(type, context: context) #: Types::ClassInstance | Types::Interface | Types::Alias
 
         definition_builder.validate_type_name(type.name, type.location)
 
-        type_params = case type
-                      when Types::ClassInstance
-                        entry = env.normalized_module_class_entry(type.name) or raise
-                        entry.type_params
-                      when Types::Interface
-                        env.interface_decls[type.name].decl.type_params
-                      when Types::Alias
-                        env.type_alias_decls[type.name].decl.type_params
-                      end
-
-        InvalidTypeApplicationError.check!(
-          type_name: type.name,
-          args: type.args,
-          params: type_params.each.map(&:name),
-          location: type.location
-        )
+        normalized_type_name = env.normalize_type_name?(type.name)
+
+        if normalized_type_name
+          type_params =
+            case type
+            when Types::ClassInstance
+              entry = env.class_decls[normalized_type_name] or raise
+              entry.type_params
+            when Types::Interface
+              env.interface_decls[normalized_type_name].decl.type_params
+            when Types::Alias
+              env.type_alias_decls[normalized_type_name].decl.type_params
+            end
+
+          InvalidTypeApplicationError.check!(
+            type_name: type.name,
+            args: type.args,
+            params: type_params.each.map(&:name),
+            location: type.location
+          )
+        end
 
       when Types::ClassSingleton
+        type = absolute_type(type, context: context) #: Types::ClassSingleton
         definition_builder.validate_type_presence(type)
       end
 
@@ -115,14 +116,14 @@ module RBS
     end
 
     def validate_type_params(params, type_name: , method_name: nil, location:)
-      # @type var each_node: TSort::_EachNode[Symbol]
-      each_node = __skip__ = -> (&block) do
+      # @type var each_node: ^() { (Symbol) -> void } -> void
+      each_node = -> (&block) do
         params.each do |param|
           block[param.name]
         end
       end
-      # @type var each_child: TSort::_EachChild[Symbol]
-      each_child = __skip__ = -> (name, &block) do
+      # @type var each_child: ^(Symbol) { (Symbol) -> void } -> void
+      each_child = -> (name, &block) do
         if param = params.find {|p| p.name == name }
           if b = param.upper_bound
             b.free_variables.each do |tv|

data/lib/rbs/variance_calculator.rb

@@ -108,8 +108,11 @@ module RBS
     end
 
     def in_type_alias(name:)
+      env.normalized_type_name!(name)
+
       decl = env.type_alias_decls[name].decl or raise
       variables = decl.type_params.each.map(&:name)
+
       Result.new(variables: variables).tap do |result|
         type(decl.type, result: result, context: :covariant)
       end
@@ -129,30 +132,30 @@ module RBS
           end
         end
       when Types::ClassInstance, Types::Interface, Types::Alias
-        NoTypeFoundError.check!(type.name,
-                                env: env,
-                                location: type.location)
-
-        type_params = case type
-                      when Types::ClassInstance
-                        env.class_decls[env.normalize_module_name(type.name)].type_params
-                      when Types::Interface
-                        env.interface_decls[type.name].decl.type_params
-                      when Types::Alias
-                        env.type_alias_decls[type.name].decl.type_params
-                      end
-
-        type.args.each.with_index do |ty, i|
-          if var = type_params[i]
-            case var.variance
-            when :invariant
-              type(ty, result: result, context: :invariant)
-            when :covariant
-              type(ty, result: result, context: context)
-            when :contravariant
-              type(ty, result: result, context: negate(context))
+        if type_name = env.normalize_type_name?(type.name)
+          type_params = case type
+                        when Types::ClassInstance
+                          env.class_decls[type_name].type_params
+                        when Types::Interface
+                          env.interface_decls[type_name].decl.type_params
+                        when Types::Alias
+                          env.type_alias_decls[type_name].decl.type_params
+                        end
+
+          type.args.each.with_index do |ty, i|
+            if var = type_params[i]
+              case var.variance
+              when :invariant
+                type(ty, result: result, context: :invariant)
+              when :covariant
+                type(ty, result: result, context: context)
+              when :contravariant
+                type(ty, result: result, context: negate(context))
+              end
             end
           end
+        else
+          raise NoTypeFoundError.new(type_name: type.name, location: type.location)
         end
       when Types::Proc
         function(type.type, result: result, context: context)

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.1.0"
+  VERSION = "3.1.2"
 end

data/lib/rdoc/discover.rb

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

data/sig/definition_builder.rbs

@@ -71,12 +71,16 @@ module RBS
     # Assumes the type names are already resolved.
     # Raises NoTypeFoundError in case of failure.
     #
+    # Normalizes type names in the given type automatically.
+    #
     def validate_type_presence: (Types::t) -> void
 
     # Validates presence of an absolute type name
     #
     # Raises NoTypeFoundError in case of error.
     #
+    # Normalizes the given type name automatically.
+    #
     def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void
 
     # Returns a new DefinitionBuilder with updated Environment, AncestorBuilder, and exceptions

data/sig/environment.rbs

@@ -224,6 +224,33 @@ module RBS
     #
     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
+    #
+    def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Normalize the type name or raises an error
+    # 
+    def normalize_type_name!: (TypeName) -> TypeName
+
+    # Returns a normalized module/class name or a type name with a normalized namespace
+    #
+    # * Calls `#absolute!` for relative module names
+    # * Returns the typename itself if the name cannot be normalized
+    #
+    def normalize_type_name: (TypeName) -> TypeName
+
+    # Returns `true` if given type name is normalized
+    #
+    def normalized_type_name?: (TypeName) -> bool
+
+    # Returns the given type name if it's normalized, or raises
+    #
+    def normalized_type_name!: (TypeName) -> TypeName
+
     # Runs generics type params validation over each class definitions
     def validate_type_params: () -> void
 

data/sig/errors.rbs

@@ -90,6 +90,8 @@ module RBS
 
     def initialize: (type_name: TypeName, location: Location[untyped, untyped]?) -> void
 
+    # The type name in `self` is automatically normalized
+    #
     def self.check!: (AST::Declarations::Module::Self, env: Environment) -> void
   end
 
@@ -244,6 +246,10 @@ module RBS
 
     def location: () -> Location[untyped, untyped]?
 
+    # Confirms if `super` inherits specifies a class
+    #
+    # Automatically normalize the name of super.
+    #
     def self.check!: (AST::Declarations::Class::Super, env: Environment) -> void
   end
 

data/sig/resolver/type_name_resolver.rbs

@@ -17,6 +17,8 @@ module RBS
 
       private
 
+      attr_reader env: Environment
+
       attr_reader all_names: Set[TypeName]
 
       attr_reader cache: Hash[query, TypeName?]
@@ -25,7 +27,9 @@ module RBS
 
       def try_cache: (query) { () -> TypeName? } -> TypeName?
 
-      def resolve_in: (TypeName, context) -> TypeName?
+      def resolve_in: (Symbol, context) -> TypeName?
+
+      def partition: (TypeName) -> [Symbol, TypeName?]
     end
   end
 end

data/sig/shims/rubygems.rbs

@@ -12,4 +12,8 @@ module Gem
   class Dependency
     def name: () -> String
   end
+
+  module ::Kernel
+    def self?.gem: (String, *String) -> void
+  end
 end

data/sig/type_alias_dependency.rbs

@@ -1,14 +1,45 @@
 module RBS
+  # TypeAliasDependency calculates the dependnecies between type aliases
+  #
+  # The dependencies are normalized automatically.
+  #
   class TypeAliasDependency
     attr_reader env: Environment
 
+    # A hash table from type alias name to it's direct dependencies
+    #
+    # The source type name and dependencies are normalized.
+    #
     attr_reader direct_dependencies: Hash[TypeName, Set[TypeName]]
+
+    # A hash table from type alias name to a hash name with keys of transitive dependnecies
+    #
+    # The source type name and dependencies are normalized.
+    #
     attr_reader dependencies: Hash[TypeName, Hash[TypeName, bool]]
 
     def initialize: (env: Environment) -> void
 
+    # Returns `true` if given type alias is circular
+    #
+    # Normalized given type name automatically.
+    #
     def circular_definition?: (TypeName alias_name) -> bool
 
+    # Returns the set of direct dependencies from the given type name
+    #
+    # Given type name will be normalized automatically.
+    # Returns normalized type names.
+    #
+    def direct_dependencies_of: (TypeName) -> Set[TypeName]
+
+    # Returns the set of dependencies from the given type name
+    #
+    # Given type name will be normalized automatically.
+    # Returns normalized type names.
+    #
+    def dependencies_of: (TypeName) -> Set[TypeName]
+
     def build_dependencies: () -> void
 
     def transitive_closure: () -> void

data/sig/type_alias_regularity.rbs

@@ -36,6 +36,9 @@ module RBS
 
     attr_reader builder: DefinitionBuilder
 
+    # Diagnostics of each type aliases.
+    # The type names are normalized.
+    #
     attr_reader diagnostics: Hash[TypeName, Diagnostic]
 
     # `Diagnostic` represents an non-regular type alias declaration error.
@@ -70,6 +73,8 @@ module RBS
     # Returns `Diagnostic` instance if the alias type is nonregular.
     # Regurns `nil` if the alias type is regular.
     #
+    # Normalizes the given type name automatically.
+    #
     def nonregular?: (TypeName) -> Diagnostic?
 
     def validate: () -> void
@@ -87,6 +92,7 @@ module RBS
 
     def each_alias_type: (Types::t) { (Types::Alias) -> void } -> void
 
+    # Yields set of normalized type names
     def each_mutual_alias_defs: () { (Set[TypeName]) -> void } -> void
   end
 end

data/sig/validator.rbs

@@ -46,7 +46,7 @@ module RBS
     #
     # - The right hand side can be normalized
     # - No mixing alias declaration between class and modules
-    # 
+    #
     def validate_class_alias: (entry: Environment::ClassAliasEntry | Environment::ModuleAliasEntry) -> void
 
     private
@@ -54,6 +54,6 @@ module RBS
     # Resolves relative type names to absolute type names in given context.
     # Yields the type when the type name resolution using `#resolver` fails.
     #
-    def absolute_type: (Types::t, context: Resolver::context) { (Types::t) -> TypeName } -> Types::t
+    def absolute_type: (Types::t, context: Resolver::context) ?{ (Types::t) -> TypeName } -> Types::t
   end
 end

data/sig/variance_calculator.rbs

@@ -72,6 +72,8 @@ module RBS
 
     def in_inherit: (name: TypeName, args: Array[Types::t], variables: Array[Symbol]) -> Result
 
+    # The type name must be normalized
+    # 
     def in_type_alias: (name: TypeName) -> Result
 
     private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.2
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-26 00:00:00.000000000 Z
+date: 2023-07-27 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
@@ -451,7 +451,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Type signature for Ruby.