Merge pull request #2630 from ruby/inline--super-class

Support inheritance in Inline RBS declaration

Author: soutaro

docs/inline.md

@@ -56,9 +56,26 @@ end
 
 This creates the types `::Client` and `::Client::Error`.
 
+### Inheritance
+
+Class declarations can have a super class.
+
+```ruby
+class UsersController < ApplicationController
+end
+```
+
+The super class specification must be a constant.
+
+The super class specification allows type applications.
+
+```ruby
+class StringArray < Array #[String]
+end
+```
+
 ### Current Limitations
 
-- Inheritance is not supported
 - Generic class definitions are not supported
 
 ## Modules

lib/rbs/ast/ruby/declarations.rb

@@ -16,17 +16,60 @@ def initialize(buffer)
         end
 
         class ClassDecl < Base
+          class SuperClass
+            attr_reader :type_name_location
+
+            attr_reader :operator_location
+
+            attr_reader :type_name
+
+            attr_reader :type_annotation
+
+            def initialize(type_name_location, operator_location, type_name, type_annotation)
+              @type_name_location = type_name_location
+              @operator_location = operator_location
+              @type_name = type_name
+              @type_annotation = type_annotation
+            end
+
+            def type_args
+              if type_annotation
+                type_annotation.type_args
+              else
+                []
+              end
+            end
+
+            def location
+              if type_annotation
+                Location.new(
+                  type_name_location.buffer,
+                  type_name_location.start_pos,
+                  type_annotation.location.end_pos
+                )
+              else
+                type_name_location
+              end
+            end
+
+            alias name type_name
+            alias args type_args
+          end
+
           attr_reader :class_name
 
           attr_reader :members
 
           attr_reader :node
 
-          def initialize(buffer, name, node)
+          attr_reader :super_class
+
+          def initialize(buffer, name, node, super_class)
             super(buffer)
             @class_name = name
             @node = node
             @members = []
+            @super_class = super_class
           end
 
           def each_decl(&block)
@@ -39,8 +82,6 @@ def each_decl(&block)
             end
           end
 
-          def super_class = nil
-
           def type_params = []
 
           def location

lib/rbs/environment.rb

@@ -679,7 +679,16 @@ def resolve_ruby_decl(resolver, decl, context:, prefix:)
         inner_context = [context, full_name] #: Resolver::context
         inner_prefix = full_name.to_namespace
 
-        AST::Ruby::Declarations::ClassDecl.new(decl.buffer, full_name, decl.node).tap do |resolved|
+        super_class = decl.super_class&.yield_self do |super_class|
+          AST::Ruby::Declarations::ClassDecl::SuperClass.new(
+            super_class.type_name_location,
+            super_class.operator_location,
+            absolute_type_name(resolver, nil, super_class.name, context: context),
+            super_class.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+          )
+        end
+
+        AST::Ruby::Declarations::ClassDecl.new(decl.buffer, full_name, decl.node, super_class).tap do |resolved|
           decl.members.each do |member|
             case member
             when AST::Ruby::Declarations::Base

lib/rbs/inline_parser.rb

@@ -26,6 +26,7 @@ def initialize(location, message)
       NotImplementedYet = _ = Class.new(Base)
       NonConstantClassName = _ = Class.new(Base)
       NonConstantModuleName = _ = Class.new(Base)
+      NonConstantSuperClassName = _ = Class.new(Base)
       TopLevelMethodDefinition = _ = Class.new(Base)
       TopLevelAttributeDefinition = _ = Class.new(Base)
       UnusedInlineAnnotation = _ = Class.new(Base)
@@ -100,7 +101,13 @@ def visit_class_node(node)
           return
         end
 
-        class_decl = AST::Ruby::Declarations::ClassDecl.new(buffer, class_name, node)
+        # Parse super class if present
+        super_class = if node.superclass
+          node.inheritance_operator_loc or raise
+          parse_super_class(node.superclass, node.inheritance_operator_loc)
+        end
+
+        class_decl = AST::Ruby::Declarations::ClassDecl.new(buffer, class_name, node, super_class)
         insert_declaration(class_decl)
         push_module_nesting(class_decl) do
           visit_child_nodes(node)
@@ -352,6 +359,39 @@ def report_unused_block(block)
           end
         end
       end
+
+      def parse_super_class(super_class_expr, inheritance_operator_loc)
+        # Check if the superclass is a constant
+        unless super_class_name = constant_as_type_name(super_class_expr)
+          diagnostics << Diagnostic::NonConstantSuperClassName.new(
+            rbs_location(super_class_expr.location),
+            "Super class name must be a constant"
+          )
+          return nil
+        end
+
+        # Look for type application annotation in trailing comments
+        # For example: class StringArray < Array #[String]
+        trailing_block = comments.trailing_block!(super_class_expr.location)
+        type_annotation = nil
+
+        if trailing_block
+          case annotation = trailing_block.trailing_annotation([])
+          when AST::Ruby::Annotations::TypeApplicationAnnotation
+            type_annotation = annotation
+          else
+            report_unused_annotation(annotation)
+          end
+        end
+
+        # Create SuperClass object
+        AST::Ruby::Declarations::ClassDecl::SuperClass.new(
+          rbs_location(super_class_expr.location),
+          rbs_location(inheritance_operator_loc),
+          super_class_name,
+          type_annotation
+        )
+      end
     end
   end
 end

sig/ast/ruby/declarations.rbs

@@ -14,21 +14,41 @@ module RBS
         end
 
         class ClassDecl < Base
+          class SuperClass
+            attr_reader operator_location: Location
+
+            attr_reader type_name_location: Location
+
+            attr_reader type_name: TypeName
+
+            attr_reader type_annotation: Annotations::TypeApplicationAnnotation?
+
+            def type_args: () -> Array[Types::t]
+
+            alias name type_name
+
+            alias args type_args
+
+            def initialize: (Location type_name_location, Location operator_location, TypeName, RBS::AST::Ruby::Annotations::TypeApplicationAnnotation?) -> void
+
+            def location: () -> Location
+          end
+
           type member = t | Members::t
 
           attr_reader class_name: TypeName
 
           attr_reader node: Prism::ClassNode
 
+          attr_reader super_class: SuperClass?
+
           attr_reader members: Array[member]
 
-          def initialize: (Buffer, TypeName, Prism::ClassNode) -> void
+          def initialize: (Buffer, TypeName, Prism::ClassNode, SuperClass?) -> void
 
           def each_decl: () { (t) -> void } -> void
                         | () -> Enumerator[t]
 
-          def super_class: () -> nil
-
           def type_params: () -> Array[AST::TypeParam]
 
           def location: () -> Location

sig/errors.rbs

@@ -308,19 +308,21 @@ module RBS
   # InheritModuleError is raised if a class definition inherits a module (not a class)
   #
   class InheritModuleError < DefinitionError
+    type super_class = AST::Declarations::Class::Super | AST::Ruby::Declarations::ClassDecl::SuperClass
+
     include DetailedMessageable
 
-    attr_reader super_decl: AST::Declarations::Class::Super
+    attr_reader super_decl: super_class
 
-    def initialize: (AST::Declarations::Class::Super) -> void
+    def initialize: (super_class) -> void
 
     def location: () -> Location[untyped, untyped]?
 
     # Confirms if `super` inherits specifies a class
     #
     # Automatically normalize the name of super.
     #
-    def self.check!: (AST::Declarations::Class::Super, env: Environment) -> void
+    def self.check!: (super_class, env: Environment) -> void
   end
 
   class RecursiveTypeAliasError < BaseError

sig/inline_parser.rbs

@@ -29,6 +29,9 @@ module RBS
       class NonConstantModuleName < Base
       end
 
+      class NonConstantSuperClassName < Base
+      end
+
       class TopLevelMethodDefinition < Base
       end
 
@@ -51,7 +54,7 @@ module RBS
       end
 
       type t = NotImplementedYet
-             | NonConstantClassName | NonConstantModuleName
+             | NonConstantClassName | NonConstantModuleName | NonConstantSuperClassName
              | TopLevelMethodDefinition | TopLevelAttributeDefinition
              | UnusedInlineAnnotation | AnnotationSyntaxError
              | MixinMultipleArguments | MixinNonConstantModule
@@ -102,6 +105,8 @@ module RBS
       def parse_mixin_call: (Prism::CallNode) -> void
 
       def parse_attribute_call: (Prism::CallNode) -> void
+
+      def parse_super_class: (Prism::node, Prism::Location) -> Declarations::ClassDecl::SuperClass?
     end
   end
 end

test/rbs/definition_builder_test.rb

@@ -3254,6 +3254,88 @@ def hello(x) = 123
     end
   end
 
+  def test_inline_decl__class_with_super
+    SignatureManager.new do |manager|
+      manager.add_ruby_file(Pathname("a.rb"), <<~RUBY)
+        class Parent
+          # @rbs () -> String
+          def parent_method = ""
+        end
+
+        class Child < Parent
+          def child_method
+            "child"
+          end
+        end
+      RUBY
+
+      manager.build do |env|
+        builder = DefinitionBuilder.new(env: env)
+
+        builder.build_instance(type_name("::Child")).tap do |definition|
+          # Should have methods from both Child and Parent
+          assert_equal Set[:child_method, :parent_method], Set.new(definition.methods.keys) & Set[:child_method, :parent_method]
+
+          definition.methods[:parent_method].tap do |method|
+            assert_equal type_name("::Parent"), method.defined_in
+            assert_equal type_name("::Parent"), method.implemented_in
+            assert_equal [parse_method_type("() -> ::String")], method.method_types
+          end
+
+          definition.methods[:child_method].tap do |method|
+            assert_equal type_name("::Child"), method.defined_in
+            assert_equal type_name("::Child"), method.implemented_in
+            assert_equal [parse_method_type("(?) -> untyped")], method.method_types
+          end
+        end
+
+        # Check ancestors
+        ancestors = builder.ancestor_builder.instance_ancestors(type_name("::Child"))
+        assert_equal type_name("::Parent"), ancestors.ancestors[1].name
+      end
+    end
+  end
+
+  def test_inline_decl__class_with_super_type_args
+    SignatureManager.new do |manager|
+      manager.files[Pathname("generics.rbs")] = <<~RBS
+        class MyArray[T]
+          def first: () -> T
+        end
+      RBS
+
+      manager.add_ruby_file("string_array.rb", <<~RUBY)
+        class StringArray < MyArray #[String]
+          def last
+            "last"
+          end
+        end
+      RUBY
+
+      manager.build do |env|
+        builder = DefinitionBuilder.new(env: env)
+
+        builder.build_instance(type_name("::StringArray")).tap do |definition|
+          # Should have methods from both StringArray and MyArray
+          assert_equal Set[:last, :first], Set.new(definition.methods.keys) & Set[:last, :first]
+
+          definition.methods[:first].tap do |method|
+            assert_equal type_name("::MyArray"), method.defined_in
+            assert_equal type_name("::MyArray"), method.implemented_in
+            # Type should be substituted with String
+            assert_equal [parse_method_type("() -> ::String")], method.method_types
+          end
+
+          definition.methods[:last].tap do |method|
+            assert_equal type_name("::StringArray"), method.defined_in
+            assert_equal type_name("::StringArray"), method.implemented_in
+            assert_equal [parse_method_type("(?) -> untyped")], method.method_types
+          end
+        end
+      end
+    end
+  end
+
   def test_ruby_mixin_members
     SignatureManager.new do |manager|
       manager.files[Pathname("modules.rbs")] = <<EOF