rbi 0.3.9 → 0.3.11

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

@@ -464,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
@@ -477,10 +477,29 @@ 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), or if self has no sigs but other does, adopt
+      # other's non-anonymous param names and sigs.
+      if params.all?(&:anonymous?) || (sigs.empty? && !other.sigs.empty?)
+        @params = other.params.dup
+        @sigs = other.sigs.dup unless other.sigs.empty?
+        return
+      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?(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/type.rb

@@ -112,7 +112,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T::Boolean"
+        "::T::Boolean"
       end
 
       # @override
@@ -258,7 +258,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T::Class[#{@type}]"
+        "::T::Class[#{@type}]"
       end
 
       # @override
@@ -294,7 +294,7 @@ module RBI
       # @override
       #: -> String
       def to_rbi
-        "T::Module[#{@type}]"
+        "::T::Module[#{@type}]"
       end
 
       # @override
@@ -498,7 +498,7 @@ module RBI
         return type.simplify unless type.is_a?(Any)
 
         types = type.types.map(&:simplify)
-        return Untyped.new if types.any? { |type| type.is_a?(Untyped) }
+        return Untyped.new if types.any?(Untyped)
 
         has_true_class = types.any? { |type| type.is_a?(Simple) && type.name == "TrueClass" }
         has_false_class = types.any? { |type| type.is_a?(Simple) && type.name == "FalseClass" }

data/lib/rbi/version.rb

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