Update Environment

Author: soutaro

lib/rbs/environment.rb

@@ -424,6 +424,24 @@ def insert_ruby_decl(decl, context:, namespace:)
 
         constant_decls[name] = ConstantEntry.new(name: name, decl: decl, context: context)
 
+      when AST::Ruby::Declarations::ClassModuleAliasDecl
+        name = decl.new_name.with_prefix(namespace)
+
+        if entry = constant_entry(name)
+          case entry
+          when ClassAliasEntry, ModuleAliasEntry, ConstantEntry
+            raise DuplicatedDeclarationError.new(name, decl, entry.decl)
+          when ClassEntry, ModuleEntry
+            raise DuplicatedDeclarationError.new(name, decl, *entry.each_decl.to_a)
+          end
+        end
+
+        case decl.annotation
+        when AST::Ruby::Annotations::ClassAliasAnnotation
+          class_alias_decls[name] = ClassAliasEntry.new(name: name, decl: decl, context: context)
+        when AST::Ruby::Annotations::ModuleAliasAnnotation
+          class_alias_decls[name] = ModuleAliasEntry.new(name: name, decl: decl, context: context)
+        end
       else
         raise "Unknown Ruby declaration type: #{decl.class}"
       end
@@ -745,6 +763,20 @@ def resolve_ruby_decl(resolver, decl, context:, prefix:)
           decl.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
         )
 
+      when AST::Ruby::Declarations::ClassModuleAliasDecl
+        full_name = decl.new_name.with_prefix(prefix)
+        resolved_annotation = decl.annotation.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        resolved_infered_name = decl.infered_old_name&.yield_self {|name| absolute_type_name(resolver, nil, name, context: context) }
+
+        AST::Ruby::Declarations::ClassModuleAliasDecl.new(
+          decl.buffer,
+          decl.node,
+          full_name,
+          resolved_infered_name,
+          decl.leading_comment,
+          resolved_annotation
+        )
+
       else
         raise "Unknown declaration type: #{decl.class}"
       end

sig/environment.rbs

@@ -12,10 +12,10 @@ module RBS
       def initialize: (name: N, decl: D, context: Resolver::context) -> void
     end
 
-    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias]
+    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias | AST::Ruby::Declarations::ClassModuleAliasDecl]
     end
 
-    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias]
+    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias | AST::Ruby::Declarations::ClassModuleAliasDecl]
     end
 
     class InterfaceEntry < SingleEntry[TypeName, AST::Declarations::Interface]

test/rbs/environment_test.rb

@@ -793,4 +793,135 @@ class Object
     # Verify that Object class is created
     assert_operator resolved_env.class_decls, :key?, type_name("::Object")
   end
+
+  def test__ruby__class_alias_declarations
+    result = parse_inline(<<~RUBY)
+      class String
+      end
+      class Object
+      end
+      class Array
+      end
+      
+      # Basic class alias without explicit type name
+      MyString = String #: class-alias
+
+      # Class alias with explicit type name
+      MyObject = some_object_factory #: class-alias Object
+
+      # Class alias with namespace
+      MyArray = Array #: class-alias
+
+      # Nested class alias
+      module Container
+        InnerString = String #: class-alias
+      end
+    RUBY
+
+    env = Environment.new
+    env.add_source(RBS::Source::Ruby.new(result.buffer, result.prism_result, result.declarations, result.diagnostics))
+    resolved_env = env.resolve_type_names
+
+    # Check basic class alias without explicit type name
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::MyString")
+    resolved_env.class_alias_decls[type_name("::MyString")].tap do |entry|
+      assert_instance_of Environment::ClassAliasEntry, entry
+      assert_equal type_name("::MyString"), entry.name
+      assert_equal type_name("::String"), entry.decl.old_name
+    end
+
+    # Check class alias with explicit type name
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::MyObject")
+    resolved_env.class_alias_decls[type_name("::MyObject")].tap do |entry|
+      assert_instance_of Environment::ClassAliasEntry, entry
+      assert_equal type_name("::MyObject"), entry.name
+      assert_equal type_name("::Object"), entry.decl.old_name
+    end
+
+    # Check class alias with Array
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::MyArray")
+    resolved_env.class_alias_decls[type_name("::MyArray")].tap do |entry|
+      assert_instance_of Environment::ClassAliasEntry, entry
+      assert_equal type_name("::MyArray"), entry.name
+      assert_equal type_name("::Array"), entry.decl.old_name
+    end
+
+    # Check nested class alias
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::Container::InnerString")
+    resolved_env.class_alias_decls[type_name("::Container::InnerString")].tap do |entry|
+      assert_instance_of Environment::ClassAliasEntry, entry
+      assert_equal type_name("::Container::InnerString"), entry.name
+      assert_equal type_name("::String"), entry.decl.old_name
+    end
+
+    # Verify Container module is created
+    assert_operator resolved_env.class_decls, :key?, type_name("::Container")
+  end
+
+  def test__ruby__module_alias_declarations
+    result = parse_inline(<<~RUBY)
+      module Kernel
+      end
+
+      module Enumerable
+      end
+
+      # Basic module alias without explicit type name
+      MyKernel = Kernel #: module-alias
+
+      # Module alias with explicit type name
+      MyEnum = some_enumerable_factory #: module-alias Enumerable
+    RUBY
+
+    env = Environment.new
+    env.add_source(RBS::Source::Ruby.new(result.buffer, result.prism_result, result.declarations, result.diagnostics))
+    resolved_env = env.resolve_type_names
+
+    # Check basic module alias without explicit type name
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::MyKernel")
+    resolved_env.class_alias_decls[type_name("::MyKernel")].tap do |entry|
+      assert_instance_of Environment::ModuleAliasEntry, entry
+      assert_equal type_name("::MyKernel"), entry.name
+      assert_equal type_name("::Kernel"), entry.decl.old_name
+    end
+
+    # Check module alias with explicit type name
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::MyEnum")
+    resolved_env.class_alias_decls[type_name("::MyEnum")].tap do |entry|
+      assert_instance_of Environment::ModuleAliasEntry, entry
+      assert_equal type_name("::MyEnum"), entry.name
+      assert_equal type_name("::Enumerable"), entry.decl.old_name
+    end
+  end
+
+  def test__ruby__class_module_alias_with_skip_annotation
+    result = parse_inline(<<~RUBY)
+      # @rbs skip
+      SkippedString = String #: class-alias
+
+      # This should be processed
+      ProcessedString = String #: class-alias
+
+      # @rbs skip
+      SkippedKernel = Kernel #: module-alias
+
+      # This should be processed
+      ProcessedKernel = Kernel #: module-alias
+    RUBY
+
+    env = Environment.new
+    env.add_source(RBS::Source::Ruby.new(result.buffer, result.prism_result, result.declarations, result.diagnostics))
+    resolved_env = env.resolve_type_names
+
+    # Check that skipped aliases are not present
+    refute_operator resolved_env.class_alias_decls, :key?, type_name("::SkippedString")
+    refute_operator resolved_env.class_alias_decls, :key?, type_name("::SkippedKernel")
+
+    # Check that non-skipped aliases are present
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::ProcessedString")
+    assert_instance_of Environment::ClassAliasEntry, resolved_env.class_alias_decls[type_name("::ProcessedString")]
+
+    assert_operator resolved_env.class_alias_decls, :key?, type_name("::ProcessedKernel")
+    assert_instance_of Environment::ModuleAliasEntry, resolved_env.class_alias_decls[type_name("::ProcessedKernel")]
+  end
 end