Merge pull request #1394 from ruby/backport-type-name-normalization

Backport type name normalization

Author: soutaro

lib/rbs/definition_builder.rb

@@ -753,12 +753,14 @@ def expand_alias(type_name)
     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 @@ def validate_type_presence(type)
     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

lib/rbs/environment.rb

@@ -275,53 +275,96 @@ def constant_entry(type_name)
       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:)

lib/rbs/errors.rb

@@ -185,7 +185,8 @@ def location
     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 @@ def initialize(type_name:, location:)
     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
 

lib/rbs/resolver/type_name_resolver.rb

@@ -5,10 +5,12 @@ module Resolver
     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 @@ def resolve(type_name, context:)
         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
 

lib/rbs/type_alias_dependency.rb

@@ -20,7 +20,7 @@ def circular_definition?(alias_name)
       # 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 @@ def transitive_closure
       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 @@ def direct_dependency(type, result = Set[])
         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

lib/rbs/type_alias_regularity.rb

@@ -37,10 +37,12 @@ def validate
     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 @@ def validate_alias_type(alias_type, names, types)
           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 @@ def compatible_args?(args1, args2)
     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