rbi 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a187f51ebadb01bef099fcb043616e2006c6de1ca6c11ee1ad542c5289ae2a79
-  data.tar.gz: 50ab0f1cdee28c524c4519aee5d67dd67adac2cb6377137f2de84d114ebd4a3f
+  metadata.gz: 7abed145bf2c620d24e9b6cd69c6b58e4a1a88230f1fa304018621098f13c89b
+  data.tar.gz: 24c00005fa963db2dcec897a7412cb8e953c3f03007e8ab7f986e66a4927ffad
 SHA512:
-  metadata.gz: ba665a75493caea2312e6dea8ae3267b2a20a693e51b026b71d5914858cfdc6ce2eb98f665eeb6e307ce51da9446fee82f269984e1872c615414179528c00745
-  data.tar.gz: a6da77cf6a8ec3a3bc1f9a89378b05d416213aef48bbcffaf699b5e6c43198d9f30a030cd590a0f9deb75dc058f7670743fabbd629e37ac012670ea2a1bd44b2
+  metadata.gz: f314b0af5386993a597e17f5276ff960cd200b85fa03263ee3d957026db549ca0282dbc0c351e0719e0f472d37feb0ff976f521dc6266c0e9b5f57730948bafb
+  data.tar.gz: bcb533b21bb1850002f6c7bba3bf661586f95e192e5f31b656fdab4992f5c0cd4851b160b37e1cd3ba2296cae630c00bf017d23c613e0c82aad5bc854ebd88d1

data/Gemfile

@@ -10,7 +10,7 @@ group(:development, :test) do
   gem("minitest")
   gem("minitest-reporters")
   gem("rake", "~> 13.4")
-  gem("rubocop", "~> 1.88", require: false)
+  gem("rubocop", "~> 1.92", require: false)
   gem("rubocop-shopify", require: false)
   gem("rubocop-sorbet", require: false)
   gem("sorbet", ">= 0.5.9204", require: false)

data/lib/rbi/model.rb

@@ -552,6 +552,11 @@ module RBI
       params << BlockParam.new(name)
     end
 
+    #: -> void
+    def add_forwarding_param
+      params << ForwardingParam.new
+    end
+
     #: (
     #|   ?params: Array[SigParam]?,
     #|   ?return_type: (String | Type),
@@ -615,7 +620,7 @@ module RBI
     #: -> String?
     def name
       case self
-      when ReqParam, OptParam, KwParam, KwOptParam, RestParam, KwRestParam, BlockParam
+      when ReqParam, OptParam, KwParam, KwOptParam, RestParam, KwRestParam, BlockParam, ForwardingParam
         name
       end
     end
@@ -870,6 +875,38 @@ module RBI
     end
   end
 
+  # The `...` in `def m(...)`
+  class ForwardingParam < Param
+    # @override
+    #: -> nil
+    def name
+      nil
+    end
+
+    #: (?loc: Loc?, ?comments: Array[Comment]?) ?{ (ForwardingParam node) -> void } -> void
+    def initialize(loc: nil, comments: nil, &block)
+      super(loc: loc, comments: comments)
+      block&.call(self)
+    end
+
+    # @override
+    #: -> String
+    def to_s
+      "..."
+    end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      false
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      ForwardingParam === other
+    end
+  end
+
   # Mixins
 
   # @abstract

data/lib/rbi/parser.rb

@@ -552,15 +552,14 @@ module RBI
       # Collect all the remaining comments within a node
       #: (Prism::Node node) -> void
       def collect_dangling_comments(node)
-        first_line = node.location.start_line
         last_line = node.location.end_line
 
         last_node_last_line = node.child_nodes.last&.location&.end_line
+        first_line = last_node_last_line ? last_node_last_line + 1 : node.location.start_line
 
         first_line.upto(last_line) do |line|
           comment = @comments_by_line[line]
           next unless comment
-          break if last_node_last_line && line <= last_node_last_line
 
           current_scope << parse_comment(comment)
           @comments_by_line.delete(line)
@@ -775,6 +774,11 @@ module RBI
               loc: node_loc(param),
               comments: node_comments(param),
             )
+          when Prism::ForwardingParameterNode
+            ForwardingParam.new(
+              loc: node_loc(param),
+              comments: node_comments(param),
+            )
           else
             raise ParseError.new("Unexpected parameter node `#{param.class}`", node_loc(param))
           end

data/lib/rbi/printer.rb

@@ -6,7 +6,7 @@ module RBI
 
   class Printer < Visitor
     # Pre-computed indentation strings to avoid allocating " " * indent on every line.
-    MAX_CACHED_INDENT = 50 #: Integer
+    MAX_CACHED_INDENT = 50
     INDENT_CACHE = Array.new(MAX_CACHED_INDENT + 1) { |i| (" " * i).freeze }.freeze #: Array[String]
 
     #: bool
@@ -408,6 +408,12 @@ module RBI
       self.print(node.to_s)
     end
 
+    # @override
+    #: (ForwardingParam node) -> void
+    def visit_forwarding_param(node)
+      self.print(node.to_s)
+    end
+
     # @override
     #: (Include node) -> void
     def visit_include(node)

data/lib/rbi/rbs/type_translator.rb

@@ -206,7 +206,7 @@ module RBI
         "Module",
         "Set",
         "Range",
-      ].freeze #: Array[String]
+      ].freeze
 
       GENERIC_TYPE_TO_SORBET_GENERIC_TYPE = RUNTIME_GENERIC_TYPES.flat_map do |type|
         [[type, "::T::#{type}"], ["::#{type}", "::T::#{type}"]]

data/lib/rbi/rbs_printer.rb

@@ -595,6 +595,12 @@ module RBI
       print("{ (*untyped) -> untyped } ")
     end
 
+    # @override
+    #: (ForwardingParam node) -> void
+    def visit_forwarding_param(node)
+      print("...")
+    end
+
     # @override
     #: (Include node) -> void
     def visit_include(node)

data/lib/rbi/rewriters/add_sig_templates.rb

@@ -44,6 +44,9 @@ module RBI
       def add_method_sig(method)
         return unless method.sigs.empty?
 
+        # Sorbet doesn't support signatures on methods using argument forwarding.
+        return if method.params.any?(RBI::ForwardingParam)
+
         method.sigs << Sig.new(
           params: method.params.filter_map do |param|
             case param

data/lib/rbi/rewriters/merge_trees.rb

@@ -324,11 +324,26 @@ module RBI
     #: (Node other) -> void
     def merge_with(other)
       return unless other.is_a?(NodeWithComments)
+      return unless other.comments?
+
+      comments_by_text = {} #: Hash[String, Array[Comment]]
+      comments.each { |comment| index_comment(comments_by_text, comment) }
 
       other.comments.each do |comment|
-        comments << comment unless comments.include?(comment)
+        comments << comment if index_comment(comments_by_text, comment)
       end
     end
+
+    private
+
+    #: (Hash[String, Array[Comment]] index, Comment comment) -> bool
+    def index_comment(index, comment)
+      same_text = index[comment.text] ||= []
+      return false if same_text.any? { |indexed| indexed == comment }
+
+      same_text << comment
+      true
+    end
   end
 
   class Tree
@@ -467,6 +482,9 @@ module RBI
       return false unless other.is_a?(Method)
       return false unless name == other.name
       return false unless params.size == other.params.size
+      if (params_have_forwarding?(params) || params_have_forwarding?(other.params)) && params != other.params
+        return false
+      end
 
       if sigs.empty? && other.sigs.empty?
         compatible_params?(other)
@@ -485,8 +503,9 @@ module RBI
       super
 
       if sigs.empty? && !other.sigs.empty?
-        @params = other.params.dup
+        @params = other.params.map(&:dup)
         @sigs = other.sigs.dup
+        rename_sigs_params(@sigs, @params)
         return
       end
 
@@ -503,8 +522,10 @@ module RBI
     #: (Method other) -> bool
     def compatible_params?(other)
       return true if params == other.params
+      return false unless params.size == other.params.size
 
       params.zip(other.params).all? do |p1, p2|
+        p2 = p2 #: as !nil
         p1.compatible_with?(p2)
       end
     end
@@ -512,20 +533,26 @@ module RBI
     #: (Array[Param] preferred, Array[Param] fallback) -> Array[Param]
     def merge_params(preferred, fallback)
       preferred.zip(fallback).map do |p1, p2|
+        p2 = p2 #: as !nil
         if p1.anonymous?
-          p2.dup #: as !nil
+          p2.dup
         else
           p1.dup
         end
       end
     end
 
+    #: (Array[Param] params) -> bool
+    def params_have_forwarding?(params)
+      params.any?(ForwardingParam)
+    end
+
     #: (Array[Sig] sigs, Array[Param] params) -> void
     def rename_sigs_params(sigs, params)
       sigs.each do |sig|
-        sig_params = sig.params.zip(params).map do |sig_param, param|
-          param = param #: as !nil
-          name = if sig_param.anonymous? && !param.anonymous?
+        sig_params = sig.params.each_with_index.map do |sig_param, index|
+          param = params[index]
+          name = if param && sig_param.anonymous? && !param.anonymous?
             param.name #: as !nil
           else
             sig_param.name

data/lib/rbi/version.rb

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

data/lib/rbi/visitor.rb

@@ -67,6 +67,8 @@ module RBI
         visit_no_kw_param(node)
       when BlockParam
         visit_block_param(node)
+      when ForwardingParam
+        visit_forwarding_param(node)
       when Include
         visit_include(node)
       when Extend
@@ -181,6 +183,9 @@ module RBI
     #: (BlockParam node) -> void
     def visit_block_param(node); end
 
+    #: (ForwardingParam node) -> void
+    def visit_forwarding_param(node); end
+
     #: (Include node) -> void
     def visit_include(node); end
 

data/rbi/rbi.rbi

@@ -67,7 +67,8 @@ class RBI::Attr < ::RBI::NodeWithComments
   sig { returns(::RBI::Visibility) }
   def visibility; end
 
-  def visibility=(_arg0); end
+  sig { params(visibility: ::RBI::Visibility).returns(::RBI::Visibility) }
+  def visibility=(visibility); end
 
   private
 
@@ -232,7 +233,8 @@ class RBI::Class < ::RBI::Scope
   sig { returns(T.nilable(::String)) }
   def superclass_name; end
 
-  def superclass_name=(_arg0); end
+  sig { params(superclass_name: T.nilable(::String)).returns(T.nilable(::String)) }
+  def superclass_name=(superclass_name); end
 end
 
 class RBI::Comment < ::RBI::Node
@@ -245,7 +247,8 @@ class RBI::Comment < ::RBI::Node
   sig { returns(::String) }
   def text; end
 
-  def text=(_arg0); end
+  sig { params(text: ::String).returns(::String) }
+  def text=(text); end
 end
 
 class RBI::ConflictTree < ::RBI::Tree
@@ -365,12 +368,14 @@ class RBI::File
   sig { returns(::RBI::Tree) }
   def root; end
 
-  def root=(_arg0); end
+  sig { params(root: ::RBI::Tree).returns(::RBI::Tree) }
+  def root=(root); end
 
   sig { returns(T.nilable(::String)) }
   def strictness; end
 
-  def strictness=(_arg0); end
+  sig { params(strictness: T.nilable(::String)).returns(T.nilable(::String)) }
+  def strictness=(strictness); end
 
   sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) }
   def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
@@ -399,12 +404,36 @@ class RBI::Formatter
   sig { returns(T.nilable(::Integer)) }
   def max_line_length; end
 
-  def max_line_length=(_arg0); end
+  sig { params(max_line_length: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+  def max_line_length=(max_line_length); end
 
   sig { params(file: ::RBI::File).returns(::String) }
   def print_file(file); end
 end
 
+class RBI::ForwardingParam < ::RBI::Param
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T.nilable(T::Array[::RBI::Comment]),
+      block: T.nilable(T.proc.params(node: ::RBI::ForwardingParam).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(T::Boolean) }
+  def anonymous?; end
+
+  sig { override.returns(::NilClass) }
+  def name; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
 class RBI::Group < ::RBI::Tree
   sig { params(kind: ::RBI::Group::Kind).void }
   def initialize(kind); end
@@ -689,6 +718,9 @@ class RBI::Method < ::RBI::NodeWithComments
   sig { params(name: ::String).void }
   def add_block_param(name); end
 
+  sig { void }
+  def add_forwarding_param; end
+
   sig { params(name: ::String, default_value: ::String).void }
   def add_kw_opt_param(name, default_value); end
 
@@ -738,7 +770,8 @@ class RBI::Method < ::RBI::NodeWithComments
   sig { returns(T::Boolean) }
   def is_singleton; end
 
-  def is_singleton=(_arg0); end
+  sig { params(is_singleton: T::Boolean).returns(T::Boolean) }
+  def is_singleton=(is_singleton); end
 
   sig { override.params(other: ::RBI::Node).void }
   def merge_with(other); end
@@ -764,7 +797,8 @@ class RBI::Method < ::RBI::NodeWithComments
   sig { returns(::RBI::Visibility) }
   def visibility; end
 
-  def visibility=(_arg0); end
+  sig { params(visibility: ::RBI::Visibility).returns(::RBI::Visibility) }
+  def visibility=(visibility); end
 
   private
 
@@ -774,6 +808,9 @@ class RBI::Method < ::RBI::NodeWithComments
   sig { params(preferred: T::Array[::RBI::Param], fallback: T::Array[::RBI::Param]).returns(T::Array[::RBI::Param]) }
   def merge_params(preferred, fallback); end
 
+  sig { params(params: T::Array[::RBI::Param]).returns(T::Boolean) }
+  def params_have_forwarding?(params); end
+
   sig { params(sigs: T::Array[::RBI::Sig], params: T::Array[::RBI::Param]).void }
   def rename_sigs_params(sigs, params); end
 end
@@ -878,7 +915,8 @@ class RBI::Node
   sig { returns(T.nilable(::RBI::Loc)) }
   def loc; end
 
-  def loc=(_arg0); end
+  sig { params(loc: T.nilable(::RBI::Loc)).returns(T.nilable(::RBI::Loc)) }
+  def loc=(loc); end
 
   sig { params(other: ::RBI::Node).void }
   def merge_with(other); end
@@ -892,7 +930,8 @@ class RBI::Node
   sig { returns(T.nilable(::RBI::Tree)) }
   def parent_tree; end
 
-  def parent_tree=(_arg0); end
+  sig { params(parent_tree: T.nilable(::RBI::Tree)).returns(T.nilable(::RBI::Tree)) }
+  def parent_tree=(parent_tree); end
 
   sig do
     params(
@@ -950,6 +989,11 @@ class RBI::NodeWithComments < ::RBI::Node
 
   sig { returns(T::Array[::Gem::Requirement]) }
   def version_requirements; end
+
+  private
+
+  sig { params(index: T::Hash[::String, T::Array[::RBI::Comment]], comment: ::RBI::Comment).returns(T::Boolean) }
+  def index_comment(index, comment); end
 end
 
 class RBI::OptParam < ::RBI::Param
@@ -1237,7 +1281,8 @@ class RBI::Printer < ::RBI::Visitor
   sig { returns(T::Boolean) }
   def print_locs; end
 
-  def print_locs=(_arg0); end
+  sig { params(print_locs: T::Boolean).returns(T::Boolean) }
+  def print_locs=(print_locs); end
 
   sig { params(string: ::String).void }
   def printl(string); end
@@ -1316,6 +1361,9 @@ class RBI::Printer < ::RBI::Visitor
   sig { override.params(node: ::RBI::Extend).void }
   def visit_extend(node); end
 
+  sig { override.params(node: ::RBI::ForwardingParam).void }
+  def visit_forwarding_param(node); end
+
   sig { override.params(node: ::RBI::Group).void }
   def visit_group(node); end
 
@@ -1606,7 +1654,8 @@ class RBI::RBSPrinter < ::RBI::Visitor
   sig { returns(T::Boolean) }
   def positional_names; end
 
-  def positional_names=(_arg0); end
+  sig { params(positional_names: T::Boolean).returns(T::Boolean) }
+  def positional_names=(positional_names); end
 
   sig { returns(T.nilable(::RBI::Node)) }
   def previous_node; end
@@ -1620,7 +1669,8 @@ class RBI::RBSPrinter < ::RBI::Visitor
   sig { returns(T::Boolean) }
   def print_locs; end
 
-  def print_locs=(_arg0); end
+  sig { params(print_locs: T::Boolean).returns(T::Boolean) }
+  def print_locs=(print_locs); end
 
   sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
   def print_method_sig(node, sig); end
@@ -1682,6 +1732,9 @@ class RBI::RBSPrinter < ::RBI::Visitor
   sig { override.params(file: ::RBI::File).void }
   def visit_file(file); end
 
+  sig { override.params(node: ::RBI::ForwardingParam).void }
+  def visit_forwarding_param(node); end
+
   sig { override.params(node: ::RBI::Group).void }
   def visit_group(node); end
 
@@ -2297,42 +2350,50 @@ class RBI::Sig < ::RBI::NodeWithComments
   sig { returns(T::Boolean) }
   def allow_incompatible_override; end
 
-  def allow_incompatible_override=(_arg0); end
+  sig { params(allow_incompatible_override: T::Boolean).returns(T::Boolean) }
+  def allow_incompatible_override=(allow_incompatible_override); end
 
   sig { returns(T::Boolean) }
   def allow_incompatible_override_visibility; end
 
-  def allow_incompatible_override_visibility=(_arg0); end
+  sig { params(allow_incompatible_override_visibility: T::Boolean).returns(T::Boolean) }
+  def allow_incompatible_override_visibility=(allow_incompatible_override_visibility); end
 
   sig { returns(T.nilable(T.any(::RBI::Type, ::String))) }
   def bind_type; end
 
-  def bind_type=(_arg0); end
+  sig { params(bind_type: T.nilable(T.any(::RBI::Type, ::String))).returns(T.nilable(T.any(::RBI::Type, ::String))) }
+  def bind_type=(bind_type); end
 
   sig { returns(T.nilable(::Symbol)) }
   def checked; end
 
-  def checked=(_arg0); end
+  sig { params(checked: T.nilable(::Symbol)).returns(T.nilable(::Symbol)) }
+  def checked=(checked); end
 
   sig { returns(T::Boolean) }
   def is_abstract; end
 
-  def is_abstract=(_arg0); end
+  sig { params(is_abstract: T::Boolean).returns(T::Boolean) }
+  def is_abstract=(is_abstract); end
 
   sig { returns(T::Boolean) }
   def is_final; end
 
-  def is_final=(_arg0); end
+  sig { params(is_final: T::Boolean).returns(T::Boolean) }
+  def is_final=(is_final); end
 
   sig { returns(T::Boolean) }
   def is_overridable; end
 
-  def is_overridable=(_arg0); end
+  sig { params(is_overridable: T::Boolean).returns(T::Boolean) }
+  def is_overridable=(is_overridable); end
 
   sig { returns(T::Boolean) }
   def is_override; end
 
-  def is_override=(_arg0); end
+  sig { params(is_override: T::Boolean).returns(T::Boolean) }
+  def is_override=(is_override); end
 
   sig { returns(T::Array[::RBI::SigParam]) }
   def params; end
@@ -2340,7 +2401,8 @@ class RBI::Sig < ::RBI::NodeWithComments
   sig { returns(T.any(::RBI::Type, ::String)) }
   def return_type; end
 
-  def return_type=(_arg0); end
+  sig { params(return_type: T.any(::RBI::Type, ::String)).returns(T.any(::RBI::Type, ::String)) }
+  def return_type=(return_type); end
 
   sig { returns(T::Array[::String]) }
   def type_params; end
@@ -2351,7 +2413,8 @@ class RBI::Sig < ::RBI::NodeWithComments
   sig { returns(T::Boolean) }
   def without_runtime; end
 
-  def without_runtime=(_arg0); end
+  sig { params(without_runtime: T::Boolean).returns(T::Boolean) }
+  def without_runtime=(without_runtime); end
 end
 
 class RBI::SigParam < ::RBI::NodeWithComments
@@ -2418,12 +2481,14 @@ class RBI::Struct < ::RBI::Scope
   sig { returns(T::Boolean) }
   def keyword_init; end
 
-  def keyword_init=(_arg0); end
+  sig { params(keyword_init: T::Boolean).returns(T::Boolean) }
+  def keyword_init=(keyword_init); end
 
   sig { returns(T::Array[::Symbol]) }
   def members; end
 
-  def members=(_arg0); end
+  sig { params(members: T::Array[::Symbol]).returns(T::Array[::Symbol]) }
+  def members=(members); end
 
   sig { returns(::String) }
   def name; end
@@ -2547,7 +2612,8 @@ class RBI::TStructField < ::RBI::NodeWithComments
   sig { returns(T.nilable(::String)) }
   def default; end
 
-  def default=(_arg0); end
+  sig { params(default: T.nilable(::String)).returns(T.nilable(::String)) }
+  def default=(default); end
 
   sig { abstract.returns(T::Array[::String]) }
   def fully_qualified_names; end
@@ -2558,7 +2624,8 @@ class RBI::TStructField < ::RBI::NodeWithComments
   sig { returns(T.any(::RBI::Type, ::String)) }
   def type; end
 
-  def type=(_arg0); end
+  sig { params(type: T.any(::RBI::Type, ::String)).returns(T.any(::RBI::Type, ::String)) }
+  def type=(type); end
 end
 
 class RBI::TStructProp < ::RBI::TStructField
@@ -3478,6 +3545,9 @@ class RBI::Visitor
   sig { params(node: ::RBI::Extend).void }
   def visit_extend(node); end
 
+  sig { params(node: ::RBI::ForwardingParam).void }
+  def visit_forwarding_param(node); end
+
   sig { params(node: ::RBI::Group).void }
   def visit_group(node); end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Alexandre Terrasa