rbi 0.0.6 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1232511f52f703972d6946a815937759221dcae1b15f762dad7e214760c5551b
-  data.tar.gz: 66df06e9f8f8975b6260eca5b3a8756a5126fa6f76e3ffcdd2a9d58cf4f179a2
+  metadata.gz: b81ff4cdb9cb4776c5592c2838906188b7db79620511303a209d6d7ae395c491
+  data.tar.gz: 9da4440f160522287e3e9aca18b4d535759b11ebe59fae994d6f51be473e1e2f
 SHA512:
-  metadata.gz: ec7d1e8a75d67d1ff57f13d29e60e25c71f650ef0b948e0b617ab9bed4a4fc7ccbf0cb44d4746532077378dfc848a8eef9a4e244e082e7aef3e6971036a8f7c5
-  data.tar.gz: ac6d329c267dd116df762972b7baa4f3d43277b4a26e3c05e42290a55aca33182149d9361ca4622d50bc63587661f4d99af284626ee72f7f809f8d7f3c78c251
+  metadata.gz: c7b23d94ec81f396057fe0aeb60f75d46799241ec61e097096f6b65cd9d1730fe6ab3bab0442e2f44c62c82e31481d5c26d127b84715ec8fd74fcee939d96857
+  data.tar.gz: 1fee917b50d5931574db3159349765d5a0d3b50ed12628afdf458eb011fd37bd140025588fdceb2124afc3ff7c5e8073b45bdd2ecfc3eb601ee2be6788f0fd29

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", ">= 0.5.9204", require: false)
-  gem("tapioca", require: false, github: "Shopify/tapioca", branch: "master")
+  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
@@ -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

@@ -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
@@ -1248,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 << 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) }
@@ -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