[prototype runtime] Use the original Module#name to avoid generating incorrect module name

lib/rbs/prototype/runtime.rb

@@ -302,7 +302,7 @@ def generate_constants(mod)
                  end
 
           @decls << AST::Declarations::Constant.new(
-            name: "#{mod.to_s}::#{name}",
+            name: "#{const_name(mod)}::#{name}",
             type: type,
             location: nil,
             comment: nil
@@ -311,14 +311,14 @@ def generate_constants(mod)
       end
 
       def generate_class(mod)
-        type_name = to_type_name(mod.name)
+        type_name = to_type_name(const_name(mod))
         super_class = if mod.superclass == ::Object
                         nil
-                      elsif mod.superclass.name.nil?
+                      elsif const_name(mod.superclass).nil?
                         RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
                         nil
                       else
-                        AST::Declarations::Class::Super.new(name: to_type_name(mod.superclass.name), args: [], location: nil)
+                        AST::Declarations::Class::Super.new(name: to_type_name(const_name(mod.superclass)), args: [], location: nil)
                       end
 
         decl = AST::Declarations::Class.new(
@@ -332,12 +332,12 @@ def generate_class(mod)
         )
 
         each_mixin(mod.included_modules, *mod.superclass.included_modules, *mod.included_modules.flat_map(&:included_modules)) do |included_module|
-          unless included_module.name
+          unless const_name(included_module)
             RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
             next
           end
 
-          module_name = to_type_name(included_module.name)
+          module_name = to_type_name(const_name(included_module))
           if module_name.namespace == type_name.namespace
             module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
           end

test/rbs/runtime_prototype_test.rb

@@ -219,4 +219,47 @@ def foo: (*untyped) { (*untyped) -> untyped } -> untyped
       end
     end
   end
+
+  module TestForOverrideModuleName
+    module M
+      def self.name() 'FakeNameM' end
+      def self.to_s() 'FakeToS' end
+      X = 1
+    end
+
+    class C
+      def self.name() 'FakeNameC' end
+      include M
+    end
+
+    class C2 < C
+    end
+  end
+
+  def test_for_overwritten_module_name
+    SignatureManager.new do |manager|
+      manager.build do |env|
+        p = Runtime.new(patterns: ["RBS::RuntimePrototypeTest::TestForOverrideModuleName::*"], env: env, merge: true)
+
+        assert_write p.decls, <<~RBS
+          class RBS::RuntimePrototypeTest::TestForOverrideModuleName::C
+            include M
+
+            def self.name: () -> untyped
+          end
+
+          class RBS::RuntimePrototypeTest::TestForOverrideModuleName::C2 < RBS::RuntimePrototypeTest::TestForOverrideModuleName::C
+          end
+
+          module RBS::RuntimePrototypeTest::TestForOverrideModuleName::M
+            def self.name: () -> untyped
+
+            def self.to_s: () -> untyped
+          end
+
+          RBS::RuntimePrototypeTest::TestForOverrideModuleName::M::X: Integer
+        RBS
+      end
+    end
+  end
 end