Implement parser

Author: soutaro

lib/rbs/inline_parser.rb

@@ -35,6 +35,7 @@ def initialize(location, message)
       MixinMultipleArguments = _ = Class.new(Base)
       MixinNonConstantModule = _ = Class.new(Base)
       AttributeNonSymbolName = _ = Class.new(Base)
+      ClassModuleAliasDeclarationMissingTypeName = _ = Class.new(Base)
     end
 
     def self.parse(buffer, prism)
@@ -392,32 +393,75 @@ def parse_constant_declaration(node)
         # Look for trailing type annotation (#: Type)
         trailing_block = comments.trailing_block!(node.location)
         type_annotation = nil
+        alias_annotation = nil
 
         if trailing_block
           case annotation = trailing_block.trailing_annotation([])
           when AST::Ruby::Annotations::NodeTypeAssertion
             type_annotation = annotation
+          when AST::Ruby::Annotations::ClassAliasAnnotation, AST::Ruby::Annotations::ModuleAliasAnnotation
+            alias_annotation = annotation
           when AST::Ruby::CommentBlock::AnnotationSyntaxError
             diagnostics << Diagnostic::AnnotationSyntaxError.new(
               annotation.location, "Syntax error: " + annotation.error.error_message
             )
           end
         end
 
-        # Create the constant declaration
-        constant_decl = AST::Ruby::Declarations::ConstantDecl.new(
-          buffer,
-          constant_name,
-          node,
-          leading_block,
-          type_annotation
-        )
+        # Handle class/module alias declarations
+        if alias_annotation
+          # Try to infer the old name from the right-hand side
+          infered_old_name = constant_as_type_name(node.value)
+
+          # Check if we have either an explicit type name or can infer one
+          if alias_annotation.type_name.nil? && infered_old_name.nil?
+            message =
+              if alias_annotation.is_a?(AST::Ruby::Annotations::ClassAliasAnnotation)
+                "Class name is missing in class alias declaration"
+              else
+                "Module name is missing in module alias declaration"
+              end
 
-        # Insert the constant declaration appropriately
-        if current_module
-          current_module.members << constant_decl
+            diagnostics << Diagnostic::ClassModuleAliasDeclarationMissingTypeName.new(
+              alias_annotation.location,
+              message
+            )
+            return
+          end
+
+          # Create class/module alias declaration
+          alias_decl = AST::Ruby::Declarations::ClassModuleAliasDecl.new(
+            buffer,
+            node,
+            constant_name,
+            infered_old_name,
+            leading_block,
+            alias_annotation
+          )
+
+          # Insert the alias declaration appropriately
+
+          if current_module
+            current_module.members << alias_decl
+          else
+            result.declarations << alias_decl
+          end
         else
-          result.declarations << constant_decl
+          # Create regular constant declaration
+          constant_decl = AST::Ruby::Declarations::ConstantDecl.new(
+            buffer,
+            constant_name,
+            node,
+            leading_block,
+            type_annotation
+          )
+
+          # Insert the constant declaration appropriately
+          if current_module
+            current_module.members << constant_decl
+          else
+            result.declarations << constant_decl
+          end
         end
       end
 

sig/inline_parser.rbs

@@ -56,13 +56,17 @@ module RBS
       class NonConstantConstantDeclaration < Base
       end
 
+      class ClassModuleAliasDeclarationMissingTypeName < Base
+      end
+
       type t = NotImplementedYet
              | NonConstantClassName | NonConstantModuleName | NonConstantSuperClassName
              | TopLevelMethodDefinition | TopLevelAttributeDefinition
              | UnusedInlineAnnotation | AnnotationSyntaxError
              | MixinMultipleArguments | MixinNonConstantModule
              | AttributeNonSymbolName
              | NonConstantConstantDeclaration
+             | ClassModuleAliasDeclarationMissingTypeName
     end
 
     def self.parse: (Buffer, Prism::ParseResult) -> Result

test/rbs/inline_parser_test.rb

@@ -1571,4 +1571,119 @@ module Outer
       end
     end
   end
+
+  def test_parse__class_alias_without_type_name
+    result = parse(<<~RUBY)
+      MyString = String #: class-alias
+    RUBY
+
+    assert_empty result.diagnostics
+
+    result.declarations[0].tap do |decl|
+      assert_instance_of RBS::AST::Ruby::Declarations::ClassModuleAliasDecl, decl
+      assert_equal RBS::TypeName.parse("MyString"), decl.new_name
+      assert_equal RBS::TypeName.parse("String"), decl.infered_old_name
+      assert_instance_of RBS::AST::Ruby::Annotations::ClassAliasAnnotation, decl.annotation
+      assert_nil decl.annotation.type_name
+      assert_equal RBS::TypeName.parse("String"), decl.old_name
+      assert_nil decl.leading_comment
+    end
+  end
+
+  def test_parse__class_alias_with_type_name
+    result = parse(<<~RUBY)
+      # Alias for the standard Object class
+      MyObject = some_object #: class-alias Object
+    RUBY
+
+    assert_empty result.diagnostics
+
+    result.declarations[0].tap do |decl|
+      assert_instance_of RBS::AST::Ruby::Declarations::ClassModuleAliasDecl, decl
+      assert_equal RBS::TypeName.parse("MyObject"), decl.new_name
+      assert_nil decl.infered_old_name
+      assert_instance_of RBS::AST::Ruby::Annotations::ClassAliasAnnotation, decl.annotation
+      assert_equal RBS::TypeName.parse("Object"), decl.annotation.type_name
+      assert_equal RBS::TypeName.parse("Object"), decl.old_name
+      assert_equal "Alias for the standard Object class", decl.leading_comment.as_comment.string
+    end
+  end
+
+  def test_parse__module_alias_without_type_name
+    result = parse(<<~RUBY)
+      MyKernel = Kernel #: module-alias
+    RUBY
+
+    assert_empty result.diagnostics
+
+    result.declarations[0].tap do |decl|
+      assert_instance_of RBS::AST::Ruby::Declarations::ClassModuleAliasDecl, decl
+      assert_equal RBS::TypeName.parse("MyKernel"), decl.new_name
+      assert_equal RBS::TypeName.parse("Kernel"), decl.infered_old_name
+      assert_instance_of RBS::AST::Ruby::Annotations::ModuleAliasAnnotation, decl.annotation
+      assert_nil decl.annotation.type_name
+      assert_equal RBS::TypeName.parse("Kernel"), decl.old_name
+      assert_nil decl.leading_comment
+    end
+  end
+
+  def test_parse__module_alias_with_type_name
+    result = parse(<<~RUBY)
+      # Alias for Enumerable module
+      MyEnum = some_enumerable #: module-alias Enumerable
+    RUBY
+
+    assert_empty result.diagnostics
+
+    result.declarations[0].tap do |decl|
+      assert_instance_of RBS::AST::Ruby::Declarations::ClassModuleAliasDecl, decl
+      assert_equal RBS::TypeName.parse("MyEnum"), decl.new_name
+      assert_nil decl.infered_old_name
+      assert_instance_of RBS::AST::Ruby::Annotations::ModuleAliasAnnotation, decl.annotation
+      assert_equal RBS::TypeName.parse("Enumerable"), decl.annotation.type_name
+      assert_equal RBS::TypeName.parse("Enumerable"), decl.old_name
+      assert_equal "Alias for Enumerable module", decl.leading_comment.as_comment.string
+    end
+  end
+
+  def test_parse__class_alias_with_skip_annotation
+    result = parse(<<~RUBY)
+      # @rbs skip
+      MyString = String #: class-alias
+    RUBY
+
+    assert_empty result.diagnostics
+
+    assert_equal 0, result.declarations.size
+  end
+
+  def test_error__class_alias_non_constant_without_type_name
+    result = parse(<<~RUBY)
+      MyString = some_function() #: class-alias
+    RUBY
+
+    assert_equal 1, result.diagnostics.size
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::ClassModuleAliasDeclarationMissingTypeName, diagnostic
+      assert_equal ": class-alias", diagnostic.location.source
+      assert_equal "Class name is missing in class alias declaration", diagnostic.message
+    end
+
+    assert_empty result.declarations
+  end
+
+  def test_error__module_alias_non_constant_without_type_name
+    result = parse(<<~RUBY)
+      MyModule = some_function() #: module-alias
+    RUBY
+
+    assert_equal 1, result.diagnostics.size
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::ClassModuleAliasDeclarationMissingTypeName, diagnostic
+      assert_equal ": module-alias", diagnostic.location.source
+      assert_equal "Module name is missing in module alias declaration", diagnostic.message
+    end
+
+    assert_empty result.declarations
+  end
 end