rbi 0.0.5 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb13c49bd19a95d439f7249770add05929979892daa3ba9c55de8241a596a8d2
-  data.tar.gz: bc772396cd7997b9443782775854993cb9e4b0d1241415020c258aa8f49186b2
+  metadata.gz: e263b24187c9a9f490f5c29a249d22d2ee564a2a59aaea3f79eb62cbff8ac24f
+  data.tar.gz: c5bd9aed9462d42b8dddef6b6c8bfe001224747b49ee1ad187721daf9ac946d3
 SHA512:
-  metadata.gz: 9990c9fd5fa2bc0925f06ce07f02079165f431e9535874d0204b0e2afbc6ad1919578e3ecd13a33b69ef575ec84911fadb34d3a71df917437fd46182bb07aa6e
-  data.tar.gz: 2818b3db38a03e58eb8bd6dd160ca50fac237242192620a6910dd73c451a3ee90e5dd483502e721870329724f0b4237899225d3c4e5f429b37abd667e0183c87
+  metadata.gz: 1174676242d2ed3cfdebc28bc6eb70789d249cf10c4e5d8fceab47c58024b8db4a3f4bad9609c7543e510e6d85b6f321fc0ee65ce8d4204fee417bafb1e44510
+  data.tar.gz: 29f7a0b48aa474e3f970bba94e85fc6621ed9449f99c7249c2056a79ae5418b0c9b0e5e6ee97b37c5244e83c1514851a59a998a932e3c4ef36ef308b61036662

data/Gemfile

@@ -8,10 +8,11 @@ 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)
   gem("rubocop-sorbet", require: false)
-  gem("sorbet", require: false)
-  gem("tapioca", require: false, github: "Shopify/tapioca", branch: "master")
+  gem("sorbet", ">= 0.5.9204", require: false)
+  gem("tapioca", "0.5.2", require: false)
 end

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
@@ -154,6 +161,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

@@ -66,7 +66,8 @@ module RBI
     end
   end
 
-  class EmptyComment < Comment
+  # An arbitrary blank line that can be added both in trees and comments
+  class BlankLine < Comment
     extend T::Sig
 
     sig { params(loc: T.nilable(Loc)).void }
@@ -89,6 +90,13 @@ module RBI
       super(loc: loc)
       @comments = comments
     end
+
+    sig { returns(T::Array[String]) }
+    def annotations
+      comments
+        .select { |comment| comment.text.start_with?("@") }
+        .map { |comment| T.must(comment.text[1..]) }
+    end
   end
 
   class Tree < NodeWithComments
@@ -126,10 +134,10 @@ module RBI
     extend T::Sig
 
     sig { returns(Tree) }
-    attr_reader :root
+    attr_accessor :root
 
     sig { returns(T.nilable(String)) }
-    attr_reader :strictness
+    attr_accessor :strictness
 
     sig { returns(T::Array[Comment]) }
     attr_accessor :comments
@@ -152,6 +160,11 @@ module RBI
     def <<(node)
       @root << node
     end
+
+    sig { returns(T::Boolean) }
+    def empty?
+      @root.empty?
+    end
   end
 
   # Scopes
@@ -901,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

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 << EmptyComment.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) }
@@ -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]
@@ -435,7 +434,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 +454,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

@@ -136,6 +136,15 @@ module RBI
       out.string
     end
 
+    sig { params(v: Printer).void }
+    def print_blank_line_before(v)
+      previous_node = v.previous_node
+      return unless previous_node
+      return if previous_node.is_a?(BlankLine)
+      return if previous_node.oneline? && oneline?
+      v.printn
+    end
+
     sig { returns(T::Boolean) }
     def oneline?
       true
@@ -171,7 +180,7 @@ module RBI
     end
   end
 
-  class EmptyComment
+  class BlankLine
     extend T::Sig
 
     sig { override.params(v: Printer).void }
@@ -201,8 +210,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -295,8 +303,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -309,8 +316,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.visit_all(comments)
       sigs.each { |sig| v.visit(sig) }
@@ -346,8 +352,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.visit_all(comments)
       v.visit_all(sigs)
@@ -521,8 +526,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -543,8 +547,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -552,6 +555,47 @@ module RBI
     end
   end
 
+  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
+      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
+      end
+      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
 
@@ -659,8 +703,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -699,8 +742,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)
@@ -713,8 +755,7 @@ module RBI
 
     sig { override.params(v: Printer).void }
     def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
+      print_blank_line_before(v)
 
       v.printl("# #{loc}") if loc && v.print_locs
       v.visit_all(comments)

data/lib/rbi/rewriters/annotate.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    class Annotate < Visitor
+      extend T::Sig
+
+      sig { params(annotation: String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+      def initialize(annotation, annotate_scopes: false, annotate_properties: false)
+        super()
+        @annotation = annotation
+        @annotate_scopes = annotate_scopes
+        @annotate_properties = annotate_properties
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Scope
+          annotate_node(node) if @annotate_scopes || root?(node)
+        when Const, Attr, Method, TStructField, TypeMember
+          annotate_node(node) if @annotate_properties
+        end
+        visit_all(node.nodes) if node.is_a?(Tree)
+      end
+
+      private
+
+      sig { params(node: NodeWithComments).void }
+      def annotate_node(node)
+        return if node.annotations.one?(@annotation)
+        node.comments << Comment.new("@#{@annotation}")
+      end
+
+      sig { params(node: Node).returns(T::Boolean) }
+      def root?(node)
+        parent = node.parent_tree
+        parent.is_a?(Tree) && parent.parent_tree.nil?
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { params(annotation: String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+    def annotate!(annotation, annotate_scopes: false, annotate_properties: false)
+      visitor = Rewriters::Annotate.new(
+        annotation,
+        annotate_scopes: annotate_scopes,
+        annotate_properties: annotate_properties
+      )
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/deannotate.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    class Deannotate < Visitor
+      extend T::Sig
+
+      sig { params(annotation: String).void }
+      def initialize(annotation)
+        super()
+        @annotation = annotation
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Scope, Const, Attr, Method, TStructField, TypeMember
+          deannotate_node(node)
+        end
+        visit_all(node.nodes) if node.is_a?(Tree)
+      end
+
+      private
+
+      sig { params(node: NodeWithComments).void }
+      def deannotate_node(node)
+        return unless node.annotations.one?(@annotation)
+        node.comments.reject! do |comment|
+          comment.text == "@#{@annotation}"
+        end
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { params(annotation: String).void }
+    def deannotate!(annotation)
+      visitor = Rewriters::Deannotate.new(annotation)
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/group_nodes.rb

@@ -55,6 +55,8 @@ module RBI
         Group::Kind::TypeMembers
       when MixesInClassMethods
         Group::Kind::MixesInClassMethods
+      when Send
+        Group::Kind::Sends
       when TStructField
         Group::Kind::TStructFields
       when TEnumBlock
@@ -67,6 +69,8 @@ module RBI
         else
           Group::Kind::Methods
         end
+      when SingletonClass
+        Group::Kind::SingletonClasses
       when Scope, Const
         Group::Kind::Consts
       else
@@ -93,10 +97,12 @@ module RBI
         Helpers             = new
         TypeMembers         = new
         MixesInClassMethods = new
+        Sends               = new
         TStructFields       = new
         TEnums              = new
         Inits               = new
         Methods             = new
+        SingletonClasses    = new
         Consts              = new
       end
     end

data/lib/rbi/rewriters/merge_trees.rb

@@ -47,7 +47,7 @@ module RBI
         end
       end
 
-      sig { params(left: Tree, right: Tree, left_name: String, right_name: String, keep: Keep).returns(Tree) }
+      sig { params(left: Tree, right: Tree, left_name: String, right_name: String, keep: Keep).returns(MergeTree) }
       def self.merge_trees(left, right, left_name: "left", right_name: "right", keep: Keep::NONE)
         left.nest_singleton_methods!
         right.nest_singleton_methods!
@@ -59,7 +59,7 @@ module RBI
         tree
       end
 
-      sig { returns(Tree) }
+      sig { returns(MergeTree) }
       attr_reader :tree
 
       sig { params(left_name: String, right_name: String, keep: Keep).void }
@@ -67,15 +67,15 @@ module RBI
         @left_name = left_name
         @right_name = right_name
         @keep = keep
-        @tree = T.let(Tree.new, Tree)
+        @tree = T.let(MergeTree.new, MergeTree)
         @scope_stack = T.let([@tree], T::Array[Tree])
       end
 
-      sig { params(tree: Tree).returns(T::Array[Conflict]) }
+      sig { params(tree: Tree).void }
       def merge(tree)
         v = TreeMerger.new(@tree, left_name: @left_name, right_name: @right_name, keep: @keep)
         v.visit(tree)
-        v.conflicts
+        @tree.conflicts.concat(v.conflicts)
       end
 
       # Used for logging / error displaying purpose
@@ -314,9 +314,31 @@ module RBI
   class Tree
     extend T::Sig
 
-    sig { params(other: Tree).returns(Tree) }
-    def merge(other)
-      Rewriters::Merge.merge_trees(self, other)
+    sig { params(other: Tree, left_name: String, right_name: String, keep: Rewriters::Merge::Keep).returns(MergeTree) }
+    def merge(other, left_name: "left", right_name: "right", keep: Rewriters::Merge::Keep::NONE)
+      Rewriters::Merge.merge_trees(self, other, left_name: left_name, right_name: right_name, keep: keep)
+    end
+  end
+
+  # A tree that _might_ contain conflicts
+  class MergeTree < Tree
+    extend T::Sig
+
+    sig { returns(T::Array[Rewriters::Merge::Conflict]) }
+    attr_reader :conflicts
+
+    sig do
+      params(
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+        conflicts: T::Array[Rewriters::Merge::Conflict],
+        block: T.nilable(T.proc.params(node: Tree).void)
+      ).void
+    end
+    def initialize(loc: nil, comments: [], conflicts: [], &block)
+      super(loc: loc, comments: comments)
+      @conflicts = conflicts
+      block&.call(self)
     end
   end
 
@@ -490,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: RBI::Tree,
+          index: RBI::Index
+        ).returns([RBI::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: RBI::Index).void }
+      def initialize(index)
+        super()
+        @index = index
+        @operations = T.let([], T::Array[Operation])
+      end
+
+      sig { params(nodes: T::Array[RBI::Node]).void }
+      def visit_all(nodes)
+        nodes.dup.each { |node| visit(node) }
+      end
+
+      sig { override.params(node: T.nilable(RBI::Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when RBI::Scope
+          visit_all(node.nodes)
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
+        when RBI::Tree
+          visit_all(node.nodes)
+        when RBI::Indexable
+          previous = previous_definition_for(node)
+          delete_node(node, previous) if previous && can_delete_node?(node, previous)
+        end
+      end
+
+      private
+
+      sig { params(node: RBI::Indexable).returns(T.nilable(RBI::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: RBI::Node, previous: RBI::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, RBI::Node
+        const :duplicate_of, RBI::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

@@ -12,10 +12,16 @@ module RBI
         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
 
@@ -29,19 +35,21 @@ module RBI
         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 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
 
@@ -52,11 +60,13 @@ module RBI
         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::Sends               then 5
+        when Group::Kind::TStructFields       then 6
+        when Group::Kind::TEnums              then 7
+        when Group::Kind::Inits               then 8
+        when Group::Kind::Methods             then 9
+        when Group::Kind::SingletonClasses    then 10
+        when Group::Kind::Consts              then 11
         else
           T.absurd(kind)
         end

data/lib/rbi/version.rb

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

data/lib/rbi.rb

@@ -13,10 +13,13 @@ require "rbi/model"
 require "rbi/visitor"
 require "rbi/index"
 require "rbi/rewriters/add_sig_templates"
+require "rbi/rewriters/annotate"
+require "rbi/rewriters/deannotate"
 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.5
+  version: 0.0.9
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-05 00:00:00.000000000 Z
+date: 2021-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.9204
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.9204
 - !ruby/object:Gem::Dependency
   name: unparser
   requirement: !ruby/object:Gem::Requirement
@@ -83,10 +83,13 @@ files:
 - lib/rbi/parser.rb
 - lib/rbi/printer.rb
 - lib/rbi/rewriters/add_sig_templates.rb
+- lib/rbi/rewriters/annotate.rb
+- lib/rbi/rewriters/deannotate.rb
 - lib/rbi/rewriters/group_nodes.rb
 - 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