rbi 0.3.8 → 0.3.10

data/lib/rbi/rewriters/group_nodes.rb

@@ -13,19 +13,21 @@ module RBI
 
         case node
         when Tree
-          kinds = node.nodes.map { |child| group_kind(child) }
-          kinds.uniq!
-
-          groups = {}
-          kinds.each { |kind| groups[kind] = Group.new(kind) }
-
-          node.nodes.dup.each do |child|
+          # Single-pass: visit each child, compute its group_kind once, and classify.
+          # We avoid calling `child.detach` in a loop (which is O(n) per call due to
+          # Array#delete), and instead clear the parent's nodes array in O(1) after
+          # all children have been classified.
+          groups = {} #: Hash[Group::Kind, Group]
+          node.nodes.each do |child|
             visit(child)
-            child.detach
-            groups[group_kind(child)] << child
+            kind = group_kind(child)
+            group = groups[kind] ||= Group.new(kind)
+            child.parent_tree = nil
+            group << child
           end
+          node.nodes.clear
 
-          groups.each { |_, group| node << group }
+          groups.each_value { |group| node << group }
         end
       end
 

data/lib/rbi/rewriters/merge_trees.rb

@@ -136,6 +136,17 @@ module RBI
                 make_conflict_scope(prev, node)
               end
               @scope_stack << prev
+            elsif prev
+              # prev exists but is not a Scope (e.g., a Const)
+              # This is a conflict between different node types
+              if @keep == Keep::LEFT
+                # do nothing, keep the existing non-scope
+              elsif @keep == Keep::RIGHT
+                prev.replace(node.dup)
+              else
+                make_conflict_tree(prev, node)
+              end
+              return # Don't visit children, the whole scope is in conflict
             else
               copy = node.dup_empty
               current_scope << copy
@@ -265,6 +276,8 @@ module RBI
               else
                 last_conflict_tree = node
               end
+            else
+              last_conflict_tree = nil
             end
 
             visit(node)
@@ -451,11 +464,11 @@ module RBI
     # @override
     #: (Node other) -> bool
     def compatible_with?(other)
-      return false unless other.is_a?(Method)
-      return false unless name == other.name
-      return false unless params == other.params
-
-      sigs.empty? || other.sigs.empty? || sigs == other.sigs
+      other.is_a?(Method) &&
+        name == other.name &&
+        params == other.params &&
+        at_most_one_side_anonymous?(other) &&
+        (sigs.empty? || other.sigs.empty? || sigs == other.sigs)
     end
 
     # @override
@@ -464,10 +477,27 @@ module RBI
       return unless other.is_a?(Method)
 
       super
+
+      # If self is the all-anonymous side (since compatible_with? ensures
+      # at most one side is), adopt other's non-anonymous param names and sigs.
+      if params.all?(&:anonymous?)
+        @params = other.params.dup
+        @sigs = other.sigs.dup unless other.sigs.empty?
+      end
+
       other.sigs.each do |sig|
         sigs << sig unless sigs.include?(sig)
       end
     end
+
+    private
+
+    #: (Method other) -> bool
+    def at_most_one_side_anonymous?(other)
+      (params.all?(&:anonymous?) && other.params.none?(&:anonymous?)) ||
+        (params.none?(&:anonymous?) && other.params.all?(&:anonymous?)) ||
+        (params.none?(&:anonymous?) && other.params.none?(&:anonymous?))
+    end
   end
 
   class Mixin

data/lib/rbi/rewriters/nest_non_public_members.rb

@@ -15,24 +15,33 @@ module RBI
           protected_group = VisibilityGroup.new(Protected.new)
           private_group = VisibilityGroup.new(Private.new)
 
-          node.nodes.dup.each do |child|
+          # Classify children in a single pass, avoiding O(n) Array#delete
+          # calls from `detach` in a loop.
+          remaining = []
+          node.nodes.each do |child|
             visit(child)
-            next unless child.is_a?(Attr) || child.is_a?(Method)
-
-            child.detach
-            case child.visibility
-            when Protected
-              protected_group << child
-            when Private
-              private_group << child
+            if child.is_a?(Attr) || child.is_a?(Method)
+              child.parent_tree = nil
+              case child.visibility
+              when Protected
+                protected_group << child
+              when Private
+                private_group << child
+              else
+                public_group << child
+              end
             else
-              public_group << child
+              remaining << child
             end
           end
 
-          node << public_group unless public_group.empty?
-          node << protected_group unless protected_group.empty?
-          node << private_group unless private_group.empty?
+          has_groups = !public_group.empty? || !protected_group.empty? || !private_group.empty?
+          if has_groups
+            node.nodes.replace(remaining)
+            node << public_group unless public_group.empty?
+            node << protected_group unless protected_group.empty?
+            node << private_group unless private_group.empty?
+          end
         end
       end
     end

data/lib/rbi/rewriters/nest_singleton_methods.rb

@@ -13,16 +13,24 @@ module RBI
         when Tree
           singleton_class = SingletonClass.new
 
-          node.nodes.dup.each do |child|
+          # Collect singleton methods and remaining nodes in a single pass,
+          # avoiding O(n) Array#delete calls from `detach` in a loop.
+          remaining = []
+          node.nodes.each do |child|
             visit(child)
-            next unless child.is_a?(Method) && child.is_singleton
-
-            child.detach
-            child.is_singleton = false
-            singleton_class << child
+            if child.is_a?(Method) && child.is_singleton
+              child.parent_tree = nil
+              child.is_singleton = false
+              singleton_class << child
+            else
+              remaining << child
+            end
           end
 
-          node << singleton_class unless singleton_class.empty?
+          unless singleton_class.empty?
+            node.nodes.replace(remaining)
+            node << singleton_class
+          end
         end
       end
     end

data/lib/rbi/rewriters/sort_nodes.rb

@@ -12,32 +12,29 @@ module RBI
         return unless node.is_a?(Tree)
 
         visit_all(node.nodes)
-        original_order = node.nodes.map.with_index.to_h
 
-        # The child nodes could contain private/protected markers. If so, they should not be moved in the file.
-        # Otherwise, some methods could see their privacy change. To avoid that problem, divide the array of child
-        # nodes into chunks based on whether any Visibility nodes appear, and sort the chunks independently. This
-        # applies the ordering rules from the node_rank method as much as possible, while preserving visibility.
-        sorted_nodes = node.nodes.chunk do |n|
-          n.is_a?(Visibility)
-        end.flat_map do |_, nodes|
-          nodes.sort! do |a, b|
-            # First we try to compare the nodes by their node rank (based on the node type)
-            res = node_rank(a) <=> node_rank(b)
-            next res if res != 0 # we can sort the nodes by their rank, let's stop here
+        nodes = node.nodes
+        return if nodes.size <= 1
 
-            # Then, if the nodes ranks are the same (res == 0), we try to compare the nodes by their name
-            res = node_name(a) <=> node_name(b)
-            next res if res && res != 0 # we can sort the nodes by their name, let's stop here
+        # Fast path: if no Visibility nodes are present (common after group_nodes!/nest_non_public_members!),
+        # skip the chunk and sort directly.
+        has_visibility = nodes.any? { |n| n.is_a?(Visibility) }
 
-            # Finally, if the two nodes have the same rank and the same name or at least one node is anonymous then,
-            original_order_a = original_order[a] #: as !nil
-            original_order_b = original_order[b] #: as !nil
-            original_order_a <=> original_order_b # we keep the original order
+        if has_visibility
+          # The child nodes contain private/protected markers. Divide into chunks
+          # and sort each chunk independently to preserve visibility semantics.
+          sorted_nodes = nodes.chunk { |n| n.is_a?(Visibility) }.flat_map do |_, chunk_nodes|
+            chunk_nodes.sort_by!.with_index do |n, i|
+              [node_rank(n), node_name(n) || "", i]
+            end
+          end
+          nodes.replace(sorted_nodes)
+        else
+          # No visibility nodes — sort in place with Schwartzian transform.
+          nodes.sort_by!.with_index do |n, i|
+            [node_rank(n), node_name(n) || "", i]
           end
         end
-
-        node.nodes.replace(sorted_nodes)
       end
 
       private

data/lib/rbi/rewriters/translate_rbs_sigs.rb

@@ -51,7 +51,7 @@ module RBI
 
       #: (Method, RBSComment) -> Sig
       def translate_rbs_method_type(node, comment)
-        method_type = ::RBS::Parser.parse_method_type(comment.text)
+        method_type = ::RBS::Parser.parse_method_type(comment.text, require_eof: true)
         translator = RBS::MethodTypeTranslator.new(node)
         translator.visit(method_type)
         translator.result
@@ -59,7 +59,7 @@ module RBI
 
       #: (Attr, RBSComment) -> Sig
       def translate_rbs_attr_type(node, comment)
-        attr_type = ::RBS::Parser.parse_type(comment.text)
+        attr_type = ::RBS::Parser.parse_type(comment.text, require_eof: true)
         sig = Sig.new
 
         if node.is_a?(AttrWriter)

data/lib/rbi/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module RBI
-  VERSION = "0.3.8"
+  VERSION = "0.3.10"
 end