rbs 4.0.0.dev.4 → 4.1.0.pre.2

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,15 @@ module RBS
           return
         end
 
-        class_decl = AST::Ruby::Declarations::ClassDecl.new(buffer, class_name, node)
-        insert_declaration(class_decl)
-        push_module_nesting(class_decl) do
-          visit_child_nodes(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
 
-        comments.each_enclosed_block(node) do |block|
-          report_unused_block(block)
-        end
+        class_decl = AST::Ruby::Declarations::ClassDecl.new(buffer, class_name, node, super_class)
+        insert_declaration(class_decl)
+        visit_class_or_module_body(class_decl, node)
       end
 
       def visit_module_node(node)
@@ -119,27 +134,84 @@ module RBS
         end
 
         module_decl = AST::Ruby::Declarations::ModuleDecl.new(buffer, module_name, node)
+
+        if leading_ref = comments.leading_block(node)
+          unused_annotations = [] #: Array[AST::Ruby::CommentBlock::AnnotationSyntaxError | AST::Ruby::Annotations::leading_annotation]
+
+          leading_ref.block.each_paragraph([]) do |paragraph|
+            case paragraph
+            when AST::Ruby::Annotations::ModuleSelfAnnotation
+              module_decl.members << AST::Ruby::Members::ModuleSelfMember.new(buffer, paragraph)
+            when Location
+              # Skip
+            when AST::Ruby::CommentBlock::AnnotationSyntaxError
+              unused_annotations << paragraph
+            when AST::Ruby::Annotations::SkipAnnotation
+              # Already handled by skip_node?
+            else
+              unused_annotations << paragraph
+            end
+          end
+
+          unless unused_annotations.empty?
+            report_unused_annotation(*unused_annotations)
+          end
+
+          leading_ref.associate!
+        end
+
         insert_declaration(module_decl)
-        push_module_nesting(module_decl) do
+        visit_class_or_module_body(module_decl, node)
+      end
+
+      def visit_class_or_module_body(decl, node)
+        push_module_nesting(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
+              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
+
+        decl.members.sort_by! { _1.location.start_line }
       end
 
       def visit_def_node(node)
         return if skip_node?(node)
 
-        if node.receiver
+        if node.receiver && !node.receiver.is_a?(Prism::SelfNode)
           diagnostics << Diagnostic::NotImplementedYet.new(
             rbs_location(node.receiver.location),
-            "Singleton method definition is not supported yet"
+            "Method definition with non-self receiver is not supported"
           )
           return
         end
 
+        kind = node.receiver ? :singleton : :instance #: :singleton | :instance
+
         case current = current_module
         when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
           leading_block = comments.leading_block!(node)
@@ -150,15 +222,15 @@ module RBS
             trailing_block = comments.trailing_block!(end_loc)
           end
 
-          method_type, leading_unuseds, trailing_unused = AST::Ruby::Members::MethodTypeAnnotation.build(leading_block, trailing_block, [])
+          method_type, leading_unuseds, trailing_unused = AST::Ruby::Members::MethodTypeAnnotation.build(leading_block, trailing_block, [], node)
           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, kind: kind)
           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 +240,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 +519,8 @@ module RBS
       end
 
       def report_unused_block(block)
+        return unless block.leading?
+
         block.each_paragraph([]) do |paragraph|
           case paragraph
           when Location
@@ -201,6 +530,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/namespace.rb

@@ -9,30 +9,65 @@ module RBS
       @absolute = absolute ? true : false
     end
 
+    # Process-wide flyweight cache. Two tries (one per `absolute` flag)
+    # keyed on path Symbols, with the cached Namespace stored under the
+    # `INTERN_LEAF` sentinel at each path's terminal node.
+    @intern_mutex = Mutex.new
+    @intern_trie_absolute = {}
+    @intern_trie_relative = {}
+    INTERN_LEAF = Module.new
+
+    # Returns a canonical `Namespace` instance for the given `path` /
+    # `absolute` pair. Repeated calls with structurally equal arguments
+    # return the same object, so callers can rely on `equal?` for fast
+    # equality. The path Array is duplicated and frozen on insert.
+    def self.[](path, absolute)
+      absolute = absolute ? true : false
+
+      # Lock-free fast path.
+      node = absolute ? @intern_trie_absolute : @intern_trie_relative
+      path.each do |sym|
+        node = node[sym]
+        break unless node
+      end
+      if node && (cached = node[INTERN_LEAF])
+        return cached
+      end
+
+      @intern_mutex.synchronize do
+        node = absolute ? @intern_trie_absolute : @intern_trie_relative
+        path.each { |sym| node = (node[sym] ||= {}) }
+        node[INTERN_LEAF] ||= begin
+          frozen_path = path.frozen? ? path : path.dup.freeze
+          new(path: frozen_path, absolute: absolute)
+        end
+      end
+    end
+
     def self.empty
-      @empty ||= new(path: [], absolute: false)
+      @empty ||= self[[], false]
     end
 
     def self.root
-      @root ||= new(path: [], absolute: true)
+      @root ||= self[[], true]
     end
 
     def +(other)
       if other.absolute?
         other
       else
-        self.class.new(path: path + other.path, absolute: absolute?)
+        Namespace[path + other.path, absolute?]
       end
     end
 
     def append(component)
-      self.class.new(path: path + [component], absolute: absolute?)
+      Namespace[path + [component], absolute?]
     end
 
     def parent
       @parent ||= begin
         raise "Parent with empty namespace" if empty?
-        self.class.new(path: path.take(path.size - 1), absolute: absolute?)
+        Namespace[path.take(path.size - 1), absolute?]
       end
     end
 
@@ -45,11 +80,11 @@ module RBS
     end
 
     def absolute!
-      self.class.new(path: path, absolute: true)
+      Namespace[path, true]
     end
 
     def relative!
-      self.class.new(path: path, absolute: false)
+      Namespace[path, false]
     end
 
     def empty?
@@ -57,13 +92,14 @@ module RBS
     end
 
     def ==(other)
+      return true if equal?(other)
       other.is_a?(Namespace) && other.path == path && other.absolute? == absolute?
     end
 
     alias eql? ==
 
     def hash
-      path.hash ^ absolute?.hash
+      @hash ||= path.hash ^ absolute?.hash
     end
 
     def split
@@ -87,14 +123,14 @@ module RBS
       raise unless name
       raise unless parent
 
-      TypeName.new(name: name, namespace: parent)
+      TypeName[parent, name]
     end
 
     def self.parse(string)
       if string.start_with?("::")
-        new(path: string.split("::").drop(1).map(&:to_sym), absolute: true)
+        self[string.split("::").drop(1).map(&:to_sym), true]
       else
-        new(path: string.split("::").map(&:to_sym), absolute: false)
+        self[string.split("::").map(&:to_sym), false]
       end
     end