lib/rbs/environment.rb in rbs-3.1.1 vs lib/rbs/environment.rb in rbs-3.1.2

@@ -273,56 +273,99 @@
 
     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:)
       case decl
       when AST::Declarations::Class, AST::Declarations::Module