rbi 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97c295f819a7f55175bf02dc1722a7a6ad29c82f92c7f9be2636a47652d0b39f
-  data.tar.gz: f0ab6cb29d0e2a1a0ef78452543258761664d081845b042c0f5f1fc2f74f9773
+  metadata.gz: 727196c54429957687b3624d4b5a895e526973b045689a7689edb9cd73c97ca9
+  data.tar.gz: 115a6efabd78950aa980d0b03e3b9910f474ad03cdf04f7a87b56ed38bdc30b7
 SHA512:
-  metadata.gz: cb97cd66fd4231f3609efede4b98f8590cf7fff1382b4dbae1997161a8b2aed5ed10e6bc388d8388a16dc71792ba5b5ec32561b37f353cc8b77cbfb778542a60
-  data.tar.gz: a44902b6c3a669c0d706952459b2ebdbe78bbfdcf75ed50b0d16274f9fafa2cba20adb7ce0b70bf2011765edcfe9ea4cf823bb973618e4babd091fdc5e3fafd8
+  metadata.gz: 7357ca0bb3e8700a95d1ea6e285e710f3545a9016e36bc0a64fe0682da80328d5c645b4d6cd3d14bba14e7ccd6b9134c225944ce27625de6a26a995f5283d173
+  data.tar.gz: 71559ec6d855d46d3ac7bb074dbfd24fa024aaa6563dd241a7c286b66d138bf18f6c6e688ee33df99bdc240cbd6f683ebc068cb5c98b7e2b37dde6d4c9debca8

data/Gemfile

@@ -8,6 +8,7 @@ gemspec
 group(:development, :test) do
   gem("byebug")
   gem("minitest")
+  gem("minitest-reporters")
   gem("rake", "~> 13.0")
   gem("rubocop", "~> 1.7", require: false)
   gem("rubocop-shopify", require: false)

data/lib/rbi/index.rb

@@ -29,9 +29,9 @@ module RBI
       @index[id] ||= []
     end
 
-    sig { params(node: T.all(Indexable, Node)).void }
-    def index(node)
-      node.index_ids.each { |id| self[id] << node }
+    sig { params(nodes: Node).void }
+    def index(*nodes)
+      nodes.each { |node| visit(node) }
     end
 
     sig { override.params(node: T.nilable(Node)).void }
@@ -40,14 +40,21 @@ module RBI
 
       case node
       when Scope
-        index(node)
+        index_node(node)
         visit_all(node.nodes)
       when Tree
         visit_all(node.nodes)
       when Indexable
-        index(node)
+        index_node(node)
       end
     end
+
+    private
+
+    sig { params(node: T.all(Indexable, Node)).void }
+    def index_node(node)
+      node.index_ids.each { |id| self[id] << node }
+    end
   end
 
   class Tree
@@ -144,6 +151,16 @@ module RBI
     end
   end
 
+  class RequiresAncestor
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      [to_s]
+    end
+  end
+
   class Helper
     extend T::Sig
     include Indexable
@@ -154,6 +171,16 @@ module RBI
     end
   end
 
+  class Send
+    extend T::Sig
+    include Indexable
+
+    sig { override.returns(T::Array[String]) }
+    def index_ids
+      ["#{parent_scope&.fully_qualified_name}.#{method}"]
+    end
+  end
+
   class TStructConst
     extend T::Sig
     include Indexable

data/lib/rbi/model.rb

@@ -914,6 +914,106 @@ module RBI
     end
   end
 
+  # Sends
+
+  class Send < NodeWithComments
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :method
+
+    sig { returns(T::Array[Arg]) }
+    attr_reader :args
+
+    sig do
+      params(
+        method: String,
+        args: T::Array[Arg],
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        block: T.nilable(T.proc.params(node: Send).void)
+      ).void
+    end
+    def initialize(method, args = [], loc: nil, comments: [], &block)
+      super(loc: loc, comments: comments)
+      @method = method
+      @args = args
+      block&.call(self)
+    end
+
+    sig { params(arg: Arg).void }
+    def <<(arg)
+      @args << arg
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      Send === other && method == other.method && args == other.args
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.#{method}(#{args.join(", ")})"
+    end
+  end
+
+  class Arg < Node
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :value
+
+    sig do
+      params(
+        value: String,
+        loc: T.nilable(Loc)
+      ).void
+    end
+    def initialize(value, loc: nil)
+      super(loc: loc)
+      @value = value
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      Arg === other && value == other.value
+    end
+
+    sig { returns(String) }
+    def to_s
+      value
+    end
+  end
+
+  class KwArg < Arg
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :keyword
+
+    sig do
+      params(
+        keyword: String,
+        value: String,
+        loc: T.nilable(Loc)
+      ).void
+    end
+    def initialize(keyword, value, loc: nil)
+      super(value, loc: loc)
+      @keyword = keyword
+    end
+
+    sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+    def ==(other)
+      KwArg === other && value == other.value && keyword == other.keyword
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{keyword}: #{value}"
+    end
+  end
+
   # Sorbet's sigs
 
   class Sig < Node
@@ -1261,4 +1361,28 @@ module RBI
       "#{parent_scope&.fully_qualified_name}.mixes_in_class_methods(#{names.join(", ")})"
     end
   end
+
+  class RequiresAncestor < NodeWithComments
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig do
+      params(
+        name: String,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment]
+      ).void
+    end
+    def initialize(name, loc: nil, comments: [])
+      super(loc: loc, comments: comments)
+      @name = name
+    end
+
+    sig { override.returns(String) }
+    def to_s
+      "#{parent_scope&.fully_qualified_name}.requires_ancestor(#{name})"
+    end
+  end
 end

data/lib/rbi/parser.rb

@@ -43,11 +43,23 @@ module RBI
       Parser.new.parse_file(path)
     end
 
+    sig { params(paths: T::Array[String]).returns(T::Array[Tree]) }
+    def self.parse_files(paths)
+      parser = Parser.new
+      paths.map { |path| parser.parse_file(path) }
+    end
+
     sig { params(string: String).returns(Tree) }
     def parse_string(string)
       parse(string, file: "-")
     end
 
+    sig { params(strings: T::Array[String]).returns(T::Array[Tree]) }
+    def self.parse_strings(strings)
+      parser = Parser.new
+      strings.map { |string| parser.parse_string(string) }
+    end
+
     sig { params(path: String).returns(Tree) }
     def parse_file(path)
       parse(::File.read(path), file: path)
@@ -59,10 +71,9 @@ module RBI
     def parse(content, file:)
       node, comments = Unparser.parse_with_comments(content)
       assoc = ::Parser::Source::Comment.associate_locations(node, comments)
-      builder = TreeBuilder.new(file: file, comments: assoc)
-      builder.separate_header_comments
+      builder = TreeBuilder.new(file: file, comments: comments, nodes_comments_assoc: assoc)
       builder.visit(node)
-      builder.assoc_dangling_comments(comments)
+      builder.post_process
       builder.tree
     rescue ::Parser::SyntaxError => e
       raise ParseError.new(e.message, Loc.from_ast_loc(file, e.diagnostic.location))
@@ -105,16 +116,26 @@ module RBI
     sig do
       params(
         file: String,
-        comments: T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]]
+        comments: T::Array[::Parser::Source::Comment],
+        nodes_comments_assoc: T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]]
       ).void
     end
-    def initialize(file:, comments: {})
+    def initialize(file:, comments: [], nodes_comments_assoc: {})
       super()
       @file = file
       @comments = comments
+      @nodes_comments_assoc = nodes_comments_assoc
       @tree = T.let(Tree.new, Tree)
       @scopes_stack = T.let([@tree], T::Array[Tree])
       @last_sigs = T.let([], T::Array[RBI::Sig])
+
+      separate_header_comments
+    end
+
+    sig { void }
+    def post_process
+      assoc_dangling_comments
+      set_root_tree_loc
     end
 
     sig { override.params(node: T.nilable(Object)).void }
@@ -146,46 +167,6 @@ module RBI
       end
     end
 
-    sig { void }
-    def separate_header_comments
-      return if @comments.empty?
-
-      keep = []
-      node = T.must(@comments.keys.first)
-      comments = T.must(@comments.values.first)
-
-      last_line = T.let(nil, T.nilable(Integer))
-      comments.reverse.each do |comment|
-        comment_line = comment.location.last_line
-
-        break if last_line && comment_line < last_line - 1 ||
-          !last_line && comment_line < node.first_line - 1
-
-        keep << comment
-        last_line = comment_line
-      end
-
-      @comments[node] = keep.reverse
-    end
-
-    sig { params(comments: T::Array[::Parser::Source::Comment]).void }
-    def assoc_dangling_comments(comments)
-      last_line = T.let(nil, T.nilable(Integer))
-      (comments - @comments.values.flatten).each do |comment|
-        comment_line = comment.location.last_line
-        text = comment.text[1..-1].strip
-        loc = Loc.from_ast_loc(@file, comment.location)
-
-        if last_line && comment_line > last_line + 1
-          # Preserve empty lines in file headers
-          tree.comments << BlankLine.new(loc: loc)
-        end
-
-        tree.comments << Comment.new(text, loc: loc)
-        last_line = comment_line
-      end
-    end
-
     private
 
     sig { params(node: AST::Node).returns(Scope) }
@@ -297,10 +278,10 @@ module RBI
         symbols = node.children[2..-1].map { |child| child.children[0] }
         AttrAccessor.new(*symbols, sigs: current_sigs, loc: loc, comments: comments)
       when :include
-        names = node.children[2..-1].map { |child| parse_name(child) }
+        names = node.children[2..-1].map { |child| parse_expr(child) }
         Include.new(*names, loc: loc, comments: comments)
       when :extend
-        names = node.children[2..-1].map { |child| parse_name(child) }
+        names = node.children[2..-1].map { |child| parse_expr(child) }
         Extend.new(*names, loc: loc, comments: comments)
       when :abstract!, :sealed!, :interface!
         Helper.new(method_name.to_s.delete_suffix("!"), loc: loc, comments: comments)
@@ -332,10 +313,28 @@ module RBI
         name, type, default_value = parse_tstruct_prop(node)
         TStructConst.new(name, type, default: default_value, loc: loc, comments: comments)
       else
-        raise ParseError.new("Unsupported send node with name `#{method_name}`", loc)
+        args = parse_send_args(node)
+        Send.new(method_name.to_s, args, loc: loc, comments: comments)
       end
     end
 
+    sig { params(node: AST::Node).returns(T::Array[Arg]) }
+    def parse_send_args(node)
+      args = T.let([], T::Array[Arg])
+      node.children[2..-1].each do |child|
+        if child.type == :kwargs
+          child.children.each do |pair|
+            keyword = pair.children.first.children.last.to_s
+            value = parse_expr(pair.children.last)
+            args << KwArg.new(keyword, value)
+          end
+        else
+          args << Arg.new(parse_expr(child))
+        end
+      end
+      args
+    end
+
     sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) }
     def parse_block(node)
       name = node.children[0].children[1]
@@ -345,6 +344,8 @@ module RBI
         parse_sig(node)
       when :enums
         parse_enum(node)
+      when :requires_ancestor
+        parse_requires_ancestor(node)
       else
         raise ParseError.new("Unsupported block node type `#{name}`", node_loc(node))
       end
@@ -428,6 +429,14 @@ module RBI
       enum
     end
 
+    sig { params(node: AST::Node).returns(RequiresAncestor) }
+    def parse_requires_ancestor(node)
+      name = parse_name(node.children[2])
+      ra = RequiresAncestor.new(name)
+      ra.loc = node_loc(node)
+      ra
+    end
+
     sig { params(node: AST::Node).returns(Loc) }
     def node_loc(node)
       Loc.from_ast_loc(@file, node.location)
@@ -435,7 +444,7 @@ module RBI
 
     sig { params(node: AST::Node).returns(T::Array[Comment]) }
     def node_comments(node)
-      comments = @comments[node.location]
+      comments = @nodes_comments_assoc[node.location]
       return [] unless comments
       comments.map do |comment|
         text = comment.text[1..-1].strip
@@ -455,6 +464,60 @@ module RBI
       @last_sigs.clear
       sigs
     end
+
+    sig { void }
+    def assoc_dangling_comments
+      last_line = T.let(nil, T.nilable(Integer))
+      (@comments - @nodes_comments_assoc.values.flatten).each do |comment|
+        comment_line = comment.location.last_line
+        text = comment.text[1..-1].strip
+        loc = Loc.from_ast_loc(@file, comment.location)
+
+        if last_line && comment_line > last_line + 1
+          # Preserve empty lines in file headers
+          tree.comments << BlankLine.new(loc: loc)
+        end
+
+        tree.comments << Comment.new(text, loc: loc)
+        last_line = comment_line
+      end
+    end
+
+    sig { void }
+    def separate_header_comments
+      return if @nodes_comments_assoc.empty?
+
+      keep = []
+      node = T.must(@nodes_comments_assoc.keys.first)
+      comments = T.must(@nodes_comments_assoc.values.first)
+
+      last_line = T.let(nil, T.nilable(Integer))
+      comments.reverse.each do |comment|
+        comment_line = comment.location.last_line
+
+        break if last_line && comment_line < last_line - 1 ||
+          !last_line && comment_line < node.first_line - 1
+
+        keep << comment
+        last_line = comment_line
+      end
+
+      @nodes_comments_assoc[node] = keep.reverse
+    end
+
+    sig { void }
+    def set_root_tree_loc
+      first_loc = tree.nodes.first&.loc
+      last_loc = tree.nodes.last&.loc
+
+      @tree.loc = Loc.new(
+        file: @file,
+        begin_line: first_loc&.begin_line || 0,
+        begin_column: first_loc&.begin_column || 0,
+        end_line: last_loc&.end_line || 0,
+        end_column: last_loc&.end_column || 0
+      )
+    end
   end
 
   class ConstBuilder < ASTVisitor

data/lib/rbi/printer.rb

@@ -11,14 +11,28 @@ module RBI
     sig { returns(T.nilable(Node)) }
     attr_reader :previous_node
 
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def initialize(out: $stdout, indent: 0, print_locs: false)
+    sig { returns(Integer) }
+    attr_reader :current_indent
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :max_line_length
+
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer)
+      ).void
+    end
+    def initialize(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
       super()
       @out = out
       @current_indent = indent
       @print_locs = print_locs
       @in_visibility_group = T.let(false, T::Boolean)
       @previous_node = T.let(nil, T.nilable(Node))
+      @max_line_length = max_line_length
     end
 
     # Printing
@@ -103,16 +117,23 @@ module RBI
       end
     end
 
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def print(out: $stdout, indent: 0, print_locs: false)
-      p = Printer.new(out: out, indent: indent, print_locs: print_locs)
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer)
+      ).void
+    end
+    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       p.visit_file(self)
     end
 
-    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
-    def string(indent: 0, print_locs: false)
+    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
+    def string(indent: 0, print_locs: false, max_line_length: nil)
       out = StringIO.new
-      print(out: out, indent: indent, print_locs: print_locs)
+      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       out.string
     end
   end
@@ -123,16 +144,23 @@ module RBI
     sig { abstract.params(v: Printer).void }
     def accept_printer(v); end
 
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def print(out: $stdout, indent: 0, print_locs: false)
-      p = Printer.new(out: out, indent: indent, print_locs: print_locs)
+    sig do
+      params(
+        out: T.any(IO, StringIO),
+        indent: Integer,
+        print_locs: T::Boolean,
+        max_line_length: T.nilable(Integer)
+      ).void
+    end
+    def print(out: $stdout, indent: 0, print_locs: false, max_line_length: nil)
+      p = Printer.new(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       p.visit(self)
     end
 
-    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
-    def string(indent: 0, print_locs: false)
+    sig { params(indent: Integer, print_locs: T::Boolean, max_line_length: T.nilable(Integer)).returns(String) }
+    def string(indent: 0, print_locs: false, max_line_length: nil)
       out = StringIO.new
-      print(out: out, indent: indent, print_locs: print_locs)
+      print(out: out, indent: indent, print_locs: print_locs, max_line_length: max_line_length)
       out.string
     end
 
@@ -555,72 +583,65 @@ module RBI
     end
   end
 
-  class Sig
+  class Send
     extend T::Sig
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
+      print_blank_line_before(v)
+
       v.printl("# #{loc}") if loc && v.print_locs
-      if oneline?
-        v.printt("sig { ")
-      else
-        v.printl("sig do")
-        v.indent
-      end
-      v.print("abstract.") if is_abstract
-      v.print("override.") if is_override
-      v.print("overridable.") if is_overridable
-      unless type_params.empty?
-        v.print("type_parameters(")
-        type_params.each_with_index do |param, index|
-          v.print(":#{param}")
-          v.print(", ") if index < type_params.length - 1
+      v.visit_all(comments)
+      v.printt(method)
+      unless args.empty?
+        v.print(" ")
+        args.each_with_index do |arg, index|
+          v.visit(arg)
+          v.print(", ") if index < args.size - 1
         end
-        v.print(").")
       end
-      unless params.empty?
-        if inline_params?
-          v.print("params(")
-          params.each_with_index do |param, index|
-            v.print(", ") if index > 0
-            v.visit(param)
-          end
-          v.print(").")
+      v.printn
+    end
+  end
+
+  class Arg
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print(value)
+    end
+  end
+
+  class KwArg
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.print(keyword)
+      v.print(": ")
+      v.print(value)
+    end
+  end
+
+  class Sig
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      v.printl("# #{loc}") if loc && v.print_locs
+      max_line_length = v.max_line_length
+      if oneline? && max_line_length.nil?
+        print_as_line(v)
+      elsif max_line_length
+        line = string(indent: v.current_indent)
+        if line.length <= max_line_length
+          v.print(line)
         else
-          v.printl("params(")
-          v.indent
-          params.each_with_index do |param, pindex|
-            v.printt
-            v.visit(param)
-            v.print(",") if pindex < params.size - 1
-            param.comments_lines.each_with_index do |comment, cindex|
-              if cindex == 0
-                v.print(" ")
-              else
-                param.print_comment_leading_space(v, last: pindex == params.size - 1)
-              end
-              v.print("# #{comment}")
-            end
-            v.printn
-          end
-          v.dedent
-          v.printt(").")
+          print_as_block(v)
         end
-      end
-      if return_type && return_type != "void"
-        v.print("returns(#{return_type})")
-      else
-        v.print("void")
-      end
-      if checked
-        v.print(".checked(:#{checked})")
-      end
-      if oneline?
-        v.printn(" }")
       else
-        v.printn
-        v.dedent
-        v.printl("end")
+        print_as_block(v)
       end
     end
 
@@ -633,6 +654,90 @@ module RBI
     def inline_params?
       params.all? { |p| p.comments.empty? }
     end
+
+    private
+
+    sig { returns(T::Array[String]) }
+    def sig_modifiers
+      modifiers = T.let([], T::Array[String])
+      modifiers << "abstract" if is_abstract
+      modifiers << "override" if is_override
+      modifiers << "overridable" if is_overridable
+      modifiers << "type_parameters(#{type_params.map { |type| ":#{type}" }.join(", ")})" if type_params.any?
+      modifiers << "checked(:#{checked})" if checked
+      modifiers
+    end
+
+    sig { params(v: Printer).void }
+    def print_as_line(v)
+      v.printt("sig { ")
+      sig_modifiers.each do |modifier|
+        v.print("#{modifier}.")
+      end
+      unless params.empty?
+        v.print("params(")
+        params.each_with_index do |param, index|
+          v.print(", ") if index > 0
+          v.visit(param)
+        end
+        v.print(").")
+      end
+      if return_type && return_type != "void"
+        v.print("returns(#{return_type})")
+      else
+        v.print("void")
+      end
+      v.printn(" }")
+    end
+
+    sig { params(v: Printer).void }
+    def print_as_block(v)
+      modifiers = sig_modifiers
+
+      v.printl("sig do")
+      v.indent
+      if modifiers.any?
+        v.printl(T.must(modifiers.first))
+        v.indent
+        modifiers[1..]&.each do |modifier|
+          v.printl(".#{modifier}")
+        end
+      end
+
+      if params.any?
+        v.printt
+        v.print(".") if modifiers.any?
+        v.printn("params(")
+        v.indent
+        params.each_with_index do |param, pindex|
+          v.printt
+          v.visit(param)
+          v.print(",") if pindex < params.size - 1
+          param.comments_lines.each_with_index do |comment, cindex|
+            if cindex == 0
+              v.print(" ")
+            else
+              param.print_comment_leading_space(v, last: pindex == params.size - 1)
+            end
+            v.print("# #{comment}")
+          end
+          v.printn
+        end
+        v.dedent
+        v.printt(")")
+      end
+      v.printt if params.empty?
+      v.print(".") if modifiers.any? || params.any?
+      if return_type && return_type != "void"
+        v.print("returns(#{return_type})")
+      else
+        v.print("void")
+      end
+      v.printn
+      v.dedent
+      v.dedent if modifiers.any?
+      v.printl("end")
+    end
   end
 
   class SigParam
@@ -753,4 +858,17 @@ module RBI
       false
     end
   end
+
+  class RequiresAncestor
+    extend T::Sig
+
+    sig { override.params(v: Printer).void }
+    def accept_printer(v)
+      print_blank_line_before(v)
+
+      v.printl("# #{loc}") if loc && v.print_locs
+      v.visit_all(comments)
+      v.printl("requires_ancestor { #{name} }")
+    end
+  end
 end

data/lib/rbi/rewriters/group_nodes.rb

@@ -49,12 +49,18 @@ module RBI
       case self
       when Include, Extend
         Group::Kind::Mixins
+      when RequiresAncestor
+        Group::Kind::RequiredAncestors
       when Helper
         Group::Kind::Helpers
       when TypeMember
         Group::Kind::TypeMembers
       when MixesInClassMethods
         Group::Kind::MixesInClassMethods
+      when Send
+        Group::Kind::Sends
+      when Attr
+        Group::Kind::Attrs
       when TStructField
         Group::Kind::TStructFields
       when TEnumBlock
@@ -67,6 +73,8 @@ module RBI
         else
           Group::Kind::Methods
         end
+      when SingletonClass
+        Group::Kind::SingletonClasses
       when Scope, Const
         Group::Kind::Consts
       else
@@ -90,13 +98,17 @@ module RBI
     class Kind < T::Enum
       enums do
         Mixins              = new
+        RequiredAncestors   = new
         Helpers             = new
         TypeMembers         = new
         MixesInClassMethods = new
+        Sends               = new
+        Attrs               = new
         TStructFields       = new
         TEnums              = new
         Inits               = new
         Methods             = new
+        SingletonClasses    = new
         Consts              = new
       end
     end

data/lib/rbi/rewriters/merge_trees.rb

@@ -512,6 +512,15 @@ module RBI
     end
   end
 
+  class Send
+    extend T::Sig
+
+    sig { override.params(other: Node).returns(T::Boolean) }
+    def compatible_with?(other)
+      other.is_a?(Send) && method == other.method && args == other.args
+    end
+  end
+
   class TStructField
     extend T::Sig
 

data/lib/rbi/rewriters/remove_known_definitions.rb

@@ -0,0 +1,143 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    # Remove all definitions existing in the index from the current tree
+    #
+    # Let's create an `Index` from two different `Tree`s:
+    # ~~~rb
+    # tree1 = Parse.parse_string(<<~RBI)
+    #   class Foo
+    #     def foo; end
+    #   end
+    # RBI
+    #
+    # tree2 = Parse.parse_string(<<~RBI)
+    #   FOO = 10
+    # RBI
+    #
+    # index = Index.index(tree1, tree2)
+    # ~~~
+    #
+    # We can use `RemoveKnownDefinitions` to remove the definitions found in the `index` from the `Tree` to clean:
+    # ~~~rb
+    # tree_to_clean = Parser.parse_string(<<~RBI)
+    #   class Foo
+    #     def foo; end
+    #     def bar; end
+    #   end
+    #   FOO = 10
+    #   BAR = 42
+    # RBI
+    #
+    # cleaned_tree, operations = RemoveKnownDefinitions.remove(tree_to_clean, index)
+    #
+    # assert_equal(<<~RBI, cleaned_tree)
+    #   class Foo
+    #     def bar; end
+    #   end
+    #   BAR = 42
+    # RBI
+    #
+    # assert_equal(<<~OPERATIONS, operations.join("\n"))
+    #   Deleted ::Foo#foo at -:2:2-2-16 (duplicate from -:2:2-2:16)
+    #   Deleted ::FOO at -:5:0-5:8 (duplicate from -:1:0-1:8)
+    # OPERATIONS
+    # ~~~
+    class RemoveKnownDefinitions < Visitor
+      extend T::Sig
+
+      sig do
+        params(
+          tree: Tree,
+          index: Index
+        ).returns([Tree, T::Array[Operation]])
+      end
+      def self.remove(tree, index)
+        v = RemoveKnownDefinitions.new(index)
+        v.visit(tree)
+        [tree, v.operations]
+      end
+
+      sig { returns(T::Array[Operation]) }
+      attr_reader :operations
+
+      sig { params(index: Index).void }
+      def initialize(index)
+        super()
+        @index = index
+        @operations = T.let([], T::Array[Operation])
+      end
+
+      sig { params(nodes: T::Array[Node]).void }
+      def visit_all(nodes)
+        nodes.dup.each { |node| visit(node) }
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when Scope
+          visit_all(node.nodes)
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
+        when Tree
+          visit_all(node.nodes)
+        when Indexable
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
+        end
+      end
+
+      private
+
+      sig { params(node: Indexable).returns(T.nilable(Node)) }
+      def previous_definition_for(node)
+        node.index_ids.each do |id|
+          previous = @index[id].first
+          return previous if previous
+        end
+        nil
+      end
+
+      sig { params(node: Node, previous: Node).returns(T::Boolean) }
+      def can_delete_node?(node, previous)
+        return false unless node.class == previous.class
+
+        case node
+        when Scope
+          node.empty?
+        when Attr
+          previous = T.cast(previous, Attr)
+          node.names == previous.names && node.sigs == previous.sigs
+        when Method
+          previous = T.cast(previous, Method)
+          node.params == previous.params && node.sigs == previous.sigs
+        else
+          true
+        end
+      end
+
+      sig { params(node: Node, previous: Node).void }
+      def delete_node(node, previous)
+        node.detach
+        @operations << Operation.new(deleted_node: node, duplicate_of: previous)
+      end
+
+      class Operation < T::Struct
+        extend T::Sig
+
+        const :deleted_node, Node
+        const :duplicate_of, Node
+
+        sig { returns(String) }
+        def to_s
+          "Deleted #{duplicate_of} at #{deleted_node.loc} (duplicate from #{duplicate_of.loc})"
+        end
+      end
+    end
+  end
+end

data/lib/rbi/rewriters/sort_nodes.rb

@@ -8,14 +8,22 @@ module RBI
 
       sig { override.params(node: T.nilable(Node)).void }
       def visit(node)
+        sort_node_names!(node) if node
+
         return unless node.is_a?(Tree)
         visit_all(node.nodes)
         original_order = node.nodes.map.with_index.to_h
         node.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)
-          res = node_name(a) <=> node_name(b) if res == 0
-          res = (original_order[a] || 0) <=> (original_order[b] || 0) if res == 0
-          res || 0
+          next res if res != 0 # we can sort the nodes by their rank, let's stop here
+
+          # 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
+
+          # Finally, if the two nodes have the same rank and the same name or at least one node is anonymous then,
+          T.must(original_order[a]) <=> T.must(original_order[b]) # we keep the original order
         end
       end
 
@@ -26,22 +34,26 @@ module RBI
         case node
         when Group                then group_rank(node.kind)
         when Include, Extend      then 10
+        when RequiresAncestor     then 15
         when Helper               then 20
         when TypeMember           then 30
         when MixesInClassMethods  then 40
-        when TStructField         then 50
-        when TEnumBlock           then 60
+        when Send                 then 50
+        when TStructField         then 60
+        when TEnumBlock           then 70
+        when Attr                 then 75
         when Method
           if node.name == "initialize"
-            71
+            81
           elsif !node.is_singleton
-            72
+            82
           else
-            73
+            83
           end
-        when Scope, Const then 80
+        when SingletonClass       then 90
+        when Scope, Const         then 100
         else
-          100
+          110
         end
       end
 
@@ -49,14 +61,18 @@ module RBI
       def group_rank(kind)
         case kind
         when Group::Kind::Mixins              then 0
-        when Group::Kind::Helpers             then 1
-        when Group::Kind::TypeMembers         then 2
-        when Group::Kind::MixesInClassMethods then 3
-        when Group::Kind::TStructFields       then 4
-        when Group::Kind::TEnums              then 5
-        when Group::Kind::Inits               then 6
-        when Group::Kind::Methods             then 7
-        when Group::Kind::Consts              then 8
+        when Group::Kind::RequiredAncestors   then 1
+        when Group::Kind::Helpers             then 2
+        when Group::Kind::TypeMembers         then 3
+        when Group::Kind::MixesInClassMethods then 4
+        when Group::Kind::Sends               then 5
+        when Group::Kind::TStructFields       then 6
+        when Group::Kind::TEnums              then 7
+        when Group::Kind::Attrs               then 8
+        when Group::Kind::Inits               then 9
+        when Group::Kind::Methods             then 10
+        when Group::Kind::SingletonClasses    then 11
+        when Group::Kind::Consts              then 12
         else
           T.absurd(kind)
         end
@@ -65,8 +81,18 @@ module RBI
       sig { params(node: Node).returns(T.nilable(String)) }
       def node_name(node)
         case node
-        when Module, Class, Struct, Const, Method, Helper, TStructField
+        when Module, Class, Struct, Const, Method, Helper, TStructField, RequiresAncestor
           node.name
+        when Attr
+          node.names.first.to_s
+        end
+      end
+
+      sig { params(node: Node).void }
+      def sort_node_names!(node)
+        case node
+        when Attr
+          node.names.sort!
         end
       end
     end

data/lib/rbi/version.rb

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

data/lib/rbi.rb

@@ -19,6 +19,7 @@ require "rbi/rewriters/merge_trees"
 require "rbi/rewriters/nest_singleton_methods"
 require "rbi/rewriters/nest_non_public_methods"
 require "rbi/rewriters/group_nodes"
+require "rbi/rewriters/remove_known_definitions"
 require "rbi/rewriters/sort_nodes"
 require "rbi/parser"
 require "rbi/printer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.11
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-16 00:00:00.000000000 Z
+date: 2022-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -89,6 +89,7 @@ files:
 - lib/rbi/rewriters/merge_trees.rb
 - lib/rbi/rewriters/nest_non_public_methods.rb
 - lib/rbi/rewriters/nest_singleton_methods.rb
+- lib/rbi/rewriters/remove_known_definitions.rb
 - lib/rbi/rewriters/sort_nodes.rb
 - lib/rbi/version.rb
 - lib/rbi/visitor.rb