rbs 4.0.0.dev.4 → 4.0.0.dev.5

data/lib/rbs/errors.rb

@@ -93,7 +93,7 @@ module RBS
       params =
         case
         when type_name.class?
-          decl = env.normalized_module_class_entry(type_name) or raise
+          decl = env.module_class_entry(type_name, normalized: true) or raise
           decl.type_params
         when type_name.interface?
           env.interface_decls.fetch(type_name).decl.type_params
@@ -475,7 +475,7 @@ module RBS
       @type_name = type_name
       @member = member
 
-      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member.name}` in the definition of `#{type_name}`"
+      super "#{Location.to_string member.location}: Cannot #{mixin_name} a class `#{member_name(member)}` in the definition of `#{type_name}`"
     end
 
     def location
@@ -483,23 +483,43 @@ module RBS
     end
 
     def self.check!(type_name:, env:, member:)
-      if env.class_decl?(member.name)
+      name = case member
+             when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+               member.name
+             when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+               member.module_name
+             else
+               raise "Unknown member type: #{member.class}"
+             end
+
+      if env.class_decl?(name)
         raise new(type_name: type_name, member: member)
       end
     end
 
     private
 
+    def member_name(member)
+      case member
+      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
+        member.name
+      when AST::Ruby::Members::IncludeMember, AST::Ruby::Members::ExtendMember, AST::Ruby::Members::PrependMember
+        member.module_name
+      else
+        raise "Unknown member type: #{member.class}"
+      end
+    end
+
     def mixin_name
       case member
-      when AST::Members::Prepend
+      when AST::Members::Prepend, AST::Ruby::Members::PrependMember
         "prepend"
-      when AST::Members::Include
+      when AST::Members::Include, AST::Ruby::Members::IncludeMember
         "include"
-      when AST::Members::Extend
+      when AST::Members::Extend, AST::Ruby::Members::ExtendMember
         "extend"
       else
-        raise
+        raise "Unknown member type: #{member.class}"
       end
     end
   end

data/lib/rbs/inline_parser.rb

@@ -11,6 +11,10 @@ module RBS
         @declarations = []
         @diagnostics = []
       end
+
+      def type_fingerprint
+        declarations.map(&:type_fingerprint)
+      end
     end
 
     module Diagnostic
@@ -26,15 +30,26 @@ module RBS
       NotImplementedYet = _ = Class.new(Base)
       NonConstantClassName = _ = Class.new(Base)
       NonConstantModuleName = _ = Class.new(Base)
+      NonConstantSuperClassName = _ = Class.new(Base)
       TopLevelMethodDefinition = _ = Class.new(Base)
+      TopLevelAttributeDefinition = _ = Class.new(Base)
+      NonConstantConstantDeclaration = _ = Class.new(Base)
       UnusedInlineAnnotation = _ = Class.new(Base)
       AnnotationSyntaxError = _ = Class.new(Base)
+      MixinMultipleArguments = _ = Class.new(Base)
+      MixinNonConstantModule = _ = Class.new(Base)
+      AttributeNonSymbolName = _ = Class.new(Base)
+      ClassModuleAliasDeclarationMissingTypeName = _ = Class.new(Base)
     end
 
     def self.parse(buffer, prism)
       result = Result.new(buffer, prism)
 
-      Parser.new(result).visit(prism.value)
+      parser = Parser.new(result)
+      parser.visit(prism.value)
+      parser.comments.each_unassociated_block do |block|
+        parser.report_unused_block(block)
+      end
 
       result
     end
@@ -96,15 +111,46 @@ module RBS
           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)
+
+          node.child_nodes.each do |child_node|
+            if child_node
+              comments.each_enclosed_block(child_node) do |block|
+                report_unused_block(block)
+              end
+            end
+          end
         end
 
         comments.each_enclosed_block(node) do |block|
-          report_unused_block(block)
+          unused_annotations = [] #: Array[AST::Ruby::CommentBlock::AnnotationSyntaxError | AST::Ruby::Annotations::leading_annotation]
+
+          block.each_paragraph([]) do |paragraph|
+            case paragraph
+            when AST::Ruby::Annotations::InstanceVariableAnnotation
+              class_decl.members << AST::Ruby::Members::InstanceVariableMember.new(buffer, paragraph)
+            when Location
+              # Skip
+            when AST::Ruby::CommentBlock::AnnotationSyntaxError
+              unused_annotations << paragraph
+            else
+              unused_annotations << paragraph
+            end
+          end
+
+          report_unused_annotation(*unused_annotations)
         end
+
+        class_decl.members.sort_by! { _1.location.start_line }
       end
 
       def visit_module_node(node)
@@ -153,12 +199,12 @@ module RBS
           method_type, leading_unuseds, trailing_unused = AST::Ruby::Members::MethodTypeAnnotation.build(leading_block, trailing_block, [])
           report_unused_annotation(trailing_unused, *leading_unuseds)
 
-          defn = AST::Ruby::Members::DefMember.new(buffer, node.name, node, method_type)
+          defn = AST::Ruby::Members::DefMember.new(buffer, node.name, node, method_type, leading_block)
           current.members << defn
 
           # Skip other comments in `def` node
           comments.each_enclosed_block(node) do |block|
-            comments.associated_blocks << block
+            report_unused_block(block)
           end
         else
           diagnostics << Diagnostic::TopLevelMethodDefinition.new(
@@ -168,6 +214,261 @@ module RBS
         end
       end
 
+      def visit_call_node(node)
+        return unless node.receiver.nil? # Only handle top-level calls like include, extend, prepend, attr_*
+
+        case node.name
+        when :include, :extend, :prepend
+          return if skip_node?(node)
+
+          case current = current_module
+          when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
+            parse_mixin_call(node)
+          end
+        when :attr_reader, :attr_writer, :attr_accessor
+          return if skip_node?(node)
+
+          case current = current_module
+          when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
+            parse_attribute_call(node)
+          when nil
+            # Top-level attribute definition
+            diagnostics << Diagnostic::TopLevelAttributeDefinition.new(
+              rbs_location(node.message_loc || node.location),
+              "Top-level attribute definition is not supported"
+            )
+          end
+        else
+          visit_child_nodes(node)
+        end
+      end
+
+      def visit_constant_write_node(node)
+        return if skip_node?(node)
+
+        # Parse constant declaration (both top-level and in classes/modules)
+        parse_constant_declaration(node)
+      end
+
+      def visit_constant_path_write_node(node)
+        return if skip_node?(node)
+
+        parse_constant_declaration(node)
+      end
+
+      def parse_mixin_call(node)
+        # Check for multiple arguments
+        if node.arguments && node.arguments.arguments.length > 1
+          diagnostics << Diagnostic::MixinMultipleArguments.new(
+            rbs_location(node.location),
+            "Mixing multiple modules with one call is not supported"
+          )
+          return
+        end
+
+        # Check for missing arguments
+        unless node.arguments && node.arguments.arguments.length == 1
+          # This shouldn't happen in valid Ruby code, but handle it gracefully
+          return
+        end
+
+        first_arg = node.arguments.arguments.first
+
+        # Check if the argument is a constant
+        unless module_name = constant_as_type_name(first_arg)
+          diagnostics << Diagnostic::MixinNonConstantModule.new(
+            rbs_location(first_arg.location),
+            "Module name must be a constant"
+          )
+          return
+        end
+
+        # Look for type application annotation in trailing comments
+        # For single-line calls like "include Bar #[String]", the annotation is trailing
+        trailing_block = comments.trailing_block!(node.location)
+        annotation = nil
+
+        if trailing_block
+          case trailing_annotation = trailing_block.trailing_annotation([])
+          when AST::Ruby::Annotations::TypeApplicationAnnotation
+            annotation = trailing_annotation
+          else
+            report_unused_annotation(trailing_annotation)
+          end
+        end
+
+        # Create the appropriate member based on the method name
+        member = case node.name
+        when :include
+          AST::Ruby::Members::IncludeMember.new(buffer, node, module_name, annotation)
+        when :extend
+          AST::Ruby::Members::ExtendMember.new(buffer, node, module_name, annotation)
+        when :prepend
+          AST::Ruby::Members::PrependMember.new(buffer, node, module_name, annotation)
+        else
+          raise "Unexpected mixin method: #{node.name}"
+        end
+
+        current_module!.members << member
+      end
+
+      def parse_attribute_call(node)
+        # Get the name nodes (arguments to attr_*)
+        unless node.arguments && !node.arguments.arguments.empty?
+          return # No arguments, nothing to do
+        end
+
+        name_nodes = [] #: Array[Prism::SymbolNode]
+        node.arguments.arguments.each do |arg|
+          case arg
+          when Prism::SymbolNode
+            name_nodes << arg
+          else
+            # Non-symbol argument, report error
+            diagnostics << Diagnostic::AttributeNonSymbolName.new(
+              rbs_location(arg.location),
+              "Attribute name must be a symbol"
+            )
+          end
+        end
+
+        return if name_nodes.empty?
+
+        # Look for leading comment block
+        leading_block = comments.leading_block!(node)
+
+        # Look for trailing type annotation (#: Type)
+        trailing_block = comments.trailing_block!(node.location)
+        type_annotation = nil
+
+        if trailing_block
+          case annotation = trailing_block.trailing_annotation([])
+          when AST::Ruby::Annotations::NodeTypeAssertion
+            type_annotation = annotation
+          when AST::Ruby::CommentBlock::AnnotationSyntaxError
+            diagnostics << Diagnostic::AnnotationSyntaxError.new(
+              annotation.location, "Syntax error: " + annotation.error.error_message
+            )
+          end
+        end
+
+        # Report unused leading annotations since @rbs annotations are not used for attributes
+        if leading_block
+          report_unused_block(leading_block)
+        end
+
+        # Create the appropriate member type
+        member = case node.name
+        when :attr_reader
+          AST::Ruby::Members::AttrReaderMember.new(buffer, node, name_nodes, leading_block, type_annotation)
+        when :attr_writer
+          AST::Ruby::Members::AttrWriterMember.new(buffer, node, name_nodes, leading_block, type_annotation)
+        when :attr_accessor
+          AST::Ruby::Members::AttrAccessorMember.new(buffer, node, name_nodes, leading_block, type_annotation)
+        else
+          raise "Unexpected attribute method: #{node.name}"
+        end
+
+        current_module!.members << member
+      end
+
+      def parse_constant_declaration(node)
+        # Create TypeName for the constant
+        unless constant_name = constant_as_type_name(node)
+          location =
+            case node
+            when Prism::ConstantWriteNode
+              node.name_loc
+            when Prism::ConstantPathWriteNode
+              node.target.location
+            end
+
+          diagnostics << Diagnostic::NonConstantConstantDeclaration.new(
+            rbs_location(location),
+            "Constant name must be a constant"
+          )
+          return
+        end
+
+        # Look for leading comment block
+        leading_block = comments.leading_block!(node)
+        report_unused_block(leading_block) if leading_block
+
+        # 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
+
+        # 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
+
+            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
+          # 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
+
       def insert_declaration(decl)
         if current_module
           current_module.members << decl
@@ -192,6 +493,8 @@ module RBS
       end
 
       def report_unused_block(block)
+        return unless block.leading?
+
         block.each_paragraph([]) do |paragraph|
           case paragraph
           when Location
@@ -201,6 +504,39 @@ module RBS
           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

data/lib/rbs/location_aux.rb

@@ -83,7 +83,7 @@ module RBS
         other.end_pos == end_pos
     end
 
-    def to_json(state = _ = nil)
+    def to_json(state = nil)
       {
         start: {
           line: start_line,

data/lib/rbs/locator.rb

@@ -177,6 +177,10 @@ module RBS
           find_in_type(pos, type: upper_bound, array: array) and return true
         end
 
+        if lower_bound = type_param.lower_bound_type
+          find_in_type(pos, type: lower_bound, array: array) and return true
+        end
+
         if default_type = type_param.default_type
           find_in_type(pos, type: default_type, array: array) and return true
         end
@@ -234,7 +238,7 @@ module RBS
 
     def test_loc(pos, location:)
       if location
-        location.range === pos
+        location.start_pos <= pos && pos <= location.end_pos
       else
         false
       end

data/lib/rbs/method_type.rb

@@ -21,7 +21,7 @@ module RBS
         other.block == block
     end
 
-    def to_json(state = _ = nil)
+    def to_json(state = nil)
       {
         type_params: type_params,
         type: type,
@@ -129,11 +129,13 @@ module RBS
     end
 
     def with_nonreturn_void?
-      if type.with_nonreturn_void?
+      if type.with_nonreturn_void? # steep:ignore DeprecatedReference
         true
       else
         if block = block()
-          block.type.with_nonreturn_void? || block.self_type&.with_nonreturn_void? || false
+          block.type.with_nonreturn_void? || # steep:ignore DeprecatedReference
+            block.self_type&.with_nonreturn_void? || # steep:ignore DeprecatedReference
+            false
         else
           false
         end

data/lib/rbs/parser_aux.rb

@@ -5,9 +5,9 @@ require_relative "parser/token"
 
 module RBS
   class Parser
-    def self.parse_type(source, range: 0..., variables: [], require_eof: false)
+    def self.parse_type(source, range: 0..., variables: [], require_eof: false, void_allowed: true, self_allowed: true)
       buf = buffer(source)
-      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof)
+      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables, require_eof, void_allowed, self_allowed)
     end
 
     def self.parse_method_type(source, range: 0..., variables: [], require_eof: false)

data/lib/rbs/prototype/rb.rb

@@ -372,8 +372,8 @@ module RBS
                        end
 
           value_node = node.children.last
-          type = if value_node.nil?
-                  # Give up type prediction when node is MASGN.
+          type = if value_node.nil? || value_node.type == :SELF
+                  # Give up type prediction when node is MASGN or SELF.
                   Types::Bases::Any.new(location: nil)
                 else
                   literal_to_type(value_node)

data/lib/rbs/prototype/rbi.rb

@@ -235,6 +235,7 @@ module RBS
                 variance: variance || :invariant,
                 location: nil,
                 upper_bound: nil,
+                lower_bound: nil,
                 default_type: nil
               )
             end
@@ -332,6 +333,7 @@ module RBS
                   name: name,
                   variance: :invariant,
                   upper_bound: nil,
+                  lower_bound: nil,
                   location: nil,
                   default_type: nil
                 )

data/lib/rbs/prototype/runtime.rb

@@ -27,6 +27,10 @@ module RBS
           method_definition = @builder.build_singleton(module_name.absolute!).methods[method.name]
           return false unless method_definition
 
+          return false unless method_definition.defs.any? do |type_def|
+            type_def.implemented_in&.relative!.to_s == method.owner.to_s.delete_prefix("#<Class:").delete_suffix(">")
+          end
+
           method_definition.accessibility == accessibility
         end
 
@@ -36,6 +40,10 @@ module RBS
           method_definition = @builder.build_instance(module_name.absolute!).methods[method.name]
           return false unless method_definition
 
+          return false unless method_definition.defs.any? do |type_def|
+            type_def.implemented_in&.relative!.to_s == method.owner.to_s
+          end
+
           method_definition.accessibility == accessibility
         end
 

data/lib/rbs/resolver/constant_resolver.rb

@@ -32,7 +32,7 @@ module RBS
           end
 
           environment.class_alias_decls.each do |name, entry|
-            normalized_entry = environment.normalized_module_class_entry(name) or next
+            normalized_entry = environment.module_class_entry(name, normalized: true) or next
             constant = constant_of_module(name, normalized_entry)
 
             # Insert class/module aliases into `children_table` and `toplevel` table
@@ -176,7 +176,7 @@ module RBS
       end
 
       def constants_from_ancestors(module_name, constants:)
-        entry = builder.env.normalized_module_class_entry(module_name) or raise
+        entry = builder.env.module_class_entry(module_name, normalized: true) or raise
 
         if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
           constants.merge!(table.children(BuiltinNames::Object.name) || raise)