rbi 0.3.16 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c7c65440f9d48552a65ab2c087b141ab728a4eb03ba330b55e885df49792379
-  data.tar.gz: 4ed1352e4bdf88b220597979bc3b478e7f66227e156ce5fbfe71fcb5bf73ad34
+  metadata.gz: 20c28ba58d5d78165f3a26c3f354d3bd32c610ebf8364b4611a3a34ec69c360d
+  data.tar.gz: f446a5d9a2ce20676a082260cdf61c016deb31940dace2fce9891b797d8c5d20
 SHA512:
-  metadata.gz: 9d21c501fe9927818ed2afe2c7e68e0e4838c1d835a5c40ccbc57d49144fee05a4e8c2a447893bc4d8d6a0e774d4f5757791ec8202388a37e33fa445ec2946c8
-  data.tar.gz: 4b24fcee126547e8d0981e419994a1a39ff8f70a55aa93259fcaf7837d837a8842769da9205db28d414ed9920fb3a651eccdaa36c91dcf67ca323833926bca6d
+  metadata.gz: 5256315c81ad44aab890dc0c35cbc996787af24a650d21ab55d6405ab8ceec99f5e108ed085418b1e3207c05d7a4c5bbfc28c95b0c4ec49bd6a95ab665b9a3e6
+  data.tar.gz: f12fc80dcf8d4804fba40343956ddefc1f6fa60aeb237a5037977375835264db312f28d5d25920f90eb07190f0379de6631811824d81a588132633e8940f843f

data/README.md

@@ -1,25 +1,33 @@
 # RBI generation framework
 
-`RBI` provides a Ruby API to compose Ruby interface files consumed by Sorbet.
+`RBI` provides a Ruby API to build, parse, print, format, rewrite, and merge Ruby Interface files consumed by Sorbet.
 
 ## Installation
 
+`rbi` requires Ruby 3.3 or newer.
+
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'rbi'
+gem "rbi"
 ```
 
 And then execute:
 
-    $ bundle install
+```sh
+bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install rbi
+```sh
+gem install rbi
+```
 
 ## Usage
 
+### Generating RBI
+
 ```rb
 require "rbi"
 
@@ -42,33 +50,166 @@ module Foo
 end
 ```
 
+### Parsing RBI
+
+```rb
+require "rbi"
+
+tree = RBI::Parser.parse_string(<<~RBI)
+  class Foo
+    def bar; end
+  end
+RBI
+
+puts tree.nodes.first.fully_qualified_name # => ::Foo
+```
+
+### Formatting and rewriting RBI
+
+```rb
+require "rbi"
+
+tree = RBI::Parser.parse_string(<<~RBI)
+  class Foo
+    def bar; end
+  end
+RBI
+
+formatter = RBI::Formatter.new(add_sig_templates: true, group_nodes: true, sort_nodes: true)
+formatter.format_tree(tree)
+
+puts tree.string
+```
+
+will produce:
+
+```rb
+class Foo
+  # TODO: fill in signature with appropriate type information
+  sig { returns(::T.untyped) }
+  def bar; end
+end
+```
+
+### Merging RBI trees
+
+```rb
+require "rbi"
+
+left = RBI::Parser.parse_string(<<~RBI)
+  class Foo
+    def a; end
+  end
+RBI
+
+right = RBI::Parser.parse_string(<<~RBI)
+  class Foo
+    def b; end
+  end
+RBI
+
+puts left.merge(right).string
+```
+
+will produce:
+
+```rb
+class Foo
+  def a; end
+  def b; end
+end
+```
+
+### Working with Sorbet types
+
+```rb
+require "rbi"
+
+type = RBI::Type.parse_string("T.nilable(String)")
+
+puts type # => ::T.nilable(String)
+puts type.rbs_string # => String?
+```
+
+### Translating RBS comments to Sorbet signatures
+
+```rb
+require "rbi"
+
+tree = RBI::Parser.parse_string(<<~RBI)
+  #: (String) -> Integer
+  def foo(name); end
+RBI
+
+tree.translate_rbs_sigs!
+
+puts tree.string
+```
+
+will produce:
+
+```rb
+sig { params(name: String).returns(Integer) }
+def foo(name); end
+```
+
+### Printing RBS
+
+```rb
+require "rbi"
+
+file = RBI::File.new do |f|
+  f << RBI::Class.new("User") do |klass|
+    klass << RBI::Method.new("name", sigs: [RBI::Sig.new(return_type: "String")])
+  end
+end
+
+puts file.rbs_string
+```
+
+will produce:
+
+```rbs
+class User
+  def name: -> String
+end
+```
+
 ## Features
 
 * RBI generation API
-* RBI parsing with Whitequark
-* RBI formatting
-* RBI validation
-* RBI merging
+* RBI parsing with Prism
+* RBI printing and formatting
+* RBI tree merging
+* RBI normalization rewrites
+* Sorbet type parsing and modeling
+* RBS comments to Sorbet signature translation
+* RBS output via `RBI::RBSPrinter`
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies.
+
+Useful commands:
 
-This repo uses itself (`rbi`) to retrieve and generate gem RBIs. You can run `dev rbi` to update local gem RBIs with RBIs from the central repo.
+* `bin/test` runs the test suite
+* `bin/typecheck` runs Sorbet
+* `bin/style` runs RuboCop
+* `bin/console` starts an interactive prompt
 
 ## Releasing
 
 ### Bump the gem version
 
-- [ ] Locally, update the version number in [`version.rb`](https://github.com/Shopify/spoom/blob/main/lib/rbi/version.rb)
-- [ ] Run `bundle install` to update the version number in `Gemfile.lock`
-- [ ] Commit this change with the message `Bump version to vx.y.z`
-- [ ] Push this change directly to main or open a PR
+* [ ] Locally, update the version number in [`version.rb`](https://github.com/Shopify/rbi/blob/main/lib/rbi/version.rb)
+* [ ] Run `bundle install` to update the version number in `Gemfile.lock`
+* [ ] Commit this change with the message `Bump version to vx.y.z`
+* [ ] Push this change directly to main or open a PR
 
 ### Create a new tag
 
-- [ ] Locally, create a new tag with the new version number: `git tag vx.y.z`
-- [ ] Push this tag up to the remote `git push origin vx.y.z`
+* [ ] Locally, create a new tag with the new version number: `git tag vx.y.z`
+* [ ] Push this tag up to the remote `git push origin vx.y.z`
 
 ### Release workflow will run automatically
 
@@ -76,12 +217,12 @@ We have a [release workflow](https://github.com/Shopify/rbi/actions/workflows/re
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/rbi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/Shopify/rbi/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/rbi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](CODE_OF_CONDUCT.md).
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
 ## Code of Conduct
 
-Everyone interacting in the Rbi project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rbi/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in this project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).

data/lib/rbi/model.rb

@@ -599,14 +599,36 @@ module RBI
 
   # @abstract
   class Param < NodeWithComments
+    #: (?loc: Loc?, ?comments: Array[Comment]?) -> void
+    def initialize(loc: nil, comments: nil)
+      super(loc: loc, comments: comments)
+    end
+
+    #: -> String?
+    def name
+      case self
+      when ReqParam, OptParam, KwParam, KwOptParam, RestParam, KwRestParam, BlockParam
+        name
+      end
+    end
+
+    # @abstract
+    #: -> bool
+    def anonymous?
+      raise NotImplementedError, "Abstract method called"
+    end
+  end
+
+  class ReqParam < Param
+    # @override
     #: String
     attr_reader :name
 
-    #: (String name, ?loc: Loc?, ?comments: Array[Comment]?) -> void
-    def initialize(name, loc: nil, comments: nil)
+    #: (String name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (ReqParam node) -> void } -> void
+    def initialize(name, loc: nil, comments: nil, &block)
       super(loc: loc, comments: comments)
       @name = name.to_s #: String
-      @anonymous = name.start_with?("_") #: bool
+      block&.call(self)
     end
 
     # @override
@@ -615,42 +637,61 @@ module RBI
       name
     end
 
+    # @override
     #: -> bool
     def anonymous?
-      @anonymous
+      false
     end
 
     #: (Object? other) -> bool
     def ==(other)
-      self.class === other &&
-        (name == other.name || anonymous? || other.anonymous?)
-    end
-  end
-
-  class ReqParam < Param
-    #: (String name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (ReqParam node) -> void } -> void
-    def initialize(name, loc: nil, comments: nil, &block)
-      super(name, loc: loc, comments: comments)
-      block&.call(self)
+      ReqParam === other && (name == other.name)
     end
   end
 
   class OptParam < Param
+    # @override
+    #: String
+    attr_reader :name
+
     #: String
     attr_reader :value
 
     #: (String name, String value, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (OptParam node) -> void } -> void
     def initialize(name, value, loc: nil, comments: nil, &block)
-      super(name, loc: loc, comments: comments)
+      super(loc: loc, comments: comments)
+      @name = name.to_s #: String
       @value = value
       block&.call(self)
     end
+
+    # @override
+    #: -> String
+    def to_s
+      "#{name} = #{value}"
+    end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      false
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      OptParam === other && (name == other.name)
+    end
   end
 
   class RestParam < Param
-    #: (String name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (RestParam node) -> void } -> void
+    # @override
+    #: String?
+    attr_reader :name
+
+    #: (String? name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (RestParam node) -> void } -> void
     def initialize(name, loc: nil, comments: nil, &block)
-      super(name, loc: loc, comments: comments)
+      super(loc: loc, comments: comments)
+      @name = name&.to_s #: String?
       block&.call(self)
     end
 
@@ -659,12 +700,28 @@ module RBI
     def to_s
       "*#{name}"
     end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      name.nil?
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      RestParam === other && (name == other.name || anonymous? || other.anonymous?)
+    end
   end
 
   class KwParam < Param
+    # @override
+    #: String
+    attr_reader :name
+
     #: (String name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (KwParam node) -> void } -> void
     def initialize(name, loc: nil, comments: nil, &block)
-      super(name, loc: loc, comments: comments)
+      super(loc: loc, comments: comments)
+      @name = name.to_s #: String
       block&.call(self)
     end
 
@@ -673,15 +730,31 @@ module RBI
     def to_s
       "#{name}:"
     end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      false
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      KwParam === other && (name == other.name)
+    end
   end
 
   class KwOptParam < Param
+    # @override
+    #: String
+    attr_reader :name
+
     #: String
     attr_reader :value
 
     #: (String name, String value, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (KwOptParam node) -> void } -> void
     def initialize(name, value, loc: nil, comments: nil, &block)
-      super(name, loc: loc, comments: comments)
+      super(loc: loc, comments: comments)
+      @name = name.to_s #: String
       @value = value
       block&.call(self)
     end
@@ -689,28 +762,60 @@ module RBI
     # @override
     #: -> String
     def to_s
-      "#{name}:"
+      "#{name}: #{value}"
+    end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      false
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      KwOptParam === other && (name == other.name)
     end
   end
 
   class KwRestParam < Param
-    #: (String name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (KwRestParam node) -> void } -> void
+    # @override
+    #: String?
+    attr_reader :name
+
+    #: (String? name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (KwRestParam node) -> void } -> void
     def initialize(name, loc: nil, comments: nil, &block)
-      super(name, loc: loc, comments: comments)
+      super(loc: loc, comments: comments)
+      @name = name&.to_s #: String?
       block&.call(self)
     end
 
     # @override
     #: -> String
     def to_s
-      "**#{name}:"
+      "**#{name}"
+    end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      name.nil?
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      KwRestParam === other && (name == other.name || anonymous? || other.anonymous?)
     end
   end
 
   class BlockParam < Param
-    #: (String name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (BlockParam node) -> void } -> void
+    # @override
+    #: String?
+    attr_reader :name
+
+    #: (String? name, ?loc: Loc?, ?comments: Array[Comment]?) ?{ (BlockParam node) -> void } -> void
     def initialize(name, loc: nil, comments: nil, &block)
-      super(name, loc: loc, comments: comments)
+      super(loc: loc, comments: comments)
+      @name = name
       block&.call(self)
     end
 
@@ -719,6 +824,17 @@ module RBI
     def to_s
       "&#{name}"
     end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      name.nil?
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      BlockParam === other && (name == other.name || anonymous? || other.anonymous?)
+    end
   end
 
   # Mixins
@@ -1023,11 +1139,17 @@ module RBI
     def initialize(name, type, loc: nil, comments: nil, &block)
       super(loc: loc, comments: comments)
       @name = name.to_s #: String
-      @anonymous = name.start_with?("_") #: bool
+      @anonymous = name == "*" || name == "**" || name == "&" #: bool
       @type = type
       block&.call(self)
     end
 
+    # @override
+    #: -> String
+    def to_s
+      name
+    end
+
     #: -> bool
     def anonymous?
       @anonymous

data/lib/rbi/parser.rb

@@ -726,7 +726,7 @@ module RBI
             )
           when Prism::RestParameterNode
             RestParam.new(
-              param.name&.to_s || "*args",
+              param.name&.to_s,
               loc: node_loc(param),
               comments: node_comments(param),
             )
@@ -745,13 +745,13 @@ module RBI
             )
           when Prism::KeywordRestParameterNode
             KwRestParam.new(
-              param.name&.to_s || "**kwargs",
+              param.name&.to_s,
               loc: node_loc(param),
               comments: node_comments(param),
             )
           when Prism::BlockParameterNode
             BlockParam.new(
-              param.name&.to_s || "",
+              param.name&.to_s,
               loc: node_loc(param),
               comments: node_comments(param),
             )
@@ -977,11 +977,21 @@ module RBI
       #: (Prism::AssocNode node) -> void
       def visit_assoc_node(node)
         @current.params << SigParam.new(
-          node_string!(node.key).delete_suffix(":"),
+          sig_param_name(node.key),
           node_string!(node.value),
         )
       end
 
+      #: (Prism::Node node) -> String
+      def sig_param_name(node)
+        case node
+        when Prism::SymbolNode
+          node.value.to_s
+        else
+          node_string!(node).delete_suffix(":")
+        end
+      end
+
       #: (Prism::CallNode node, String value) -> bool
       def allow_incompatible_override?(node, value)
         args = node.arguments&.arguments

data/lib/rbi/printer.rb

@@ -363,51 +363,43 @@ module RBI
     # @override
     #: (ReqParam node) -> void
     def visit_req_param(node)
-      print(node.name)
+      self.print(node.to_s)
     end
 
     # @override
     #: (OptParam node) -> void
     def visit_opt_param(node)
-      print(node.name)
-      print(" = ")
-      print(node.value)
+      self.print(node.to_s)
     end
 
     # @override
     #: (RestParam node) -> void
     def visit_rest_param(node)
-      print("*")
-      print(node.name)
+      self.print(node.to_s)
     end
 
     # @override
     #: (KwParam node) -> void
     def visit_kw_param(node)
-      print(node.name)
-      print(":")
+      self.print(node.to_s)
     end
 
     # @override
     #: (KwOptParam node) -> void
     def visit_kw_opt_param(node)
-      print(node.name)
-      print(": ")
-      print(node.value)
+      self.print(node.to_s)
     end
 
     # @override
     #: (KwRestParam node) -> void
     def visit_kw_rest_param(node)
-      print("**")
-      print(node.name)
+      self.print(node.to_s)
     end
 
     # @override
     #: (BlockParam node) -> void
     def visit_block_param(node)
-      print("&")
-      print(node.name) unless node.name.empty?
+      self.print(node.to_s)
     end
 
     # @override
@@ -522,7 +514,7 @@ module RBI
     # @override
     #: (SigParam node) -> void
     def visit_sig_param(node)
-      print(node.name)
+      print(node.anonymous? ? node.name.inspect : node.name)
       print(": ")
       self.print(node.type.to_s)
     end
@@ -694,25 +686,15 @@ module RBI
     def print_param_comment_leading_space(node, last:)
       printn
       printt
-      print(" " * (node.name.size + 1))
+      print(" " * (node.to_s.size + 1))
       print(" ") unless last
-      case node
-      when OptParam
-        print(" " * (node.value.size + 3))
-      when RestParam, KwParam, BlockParam
-        print(" ")
-      when KwRestParam
-        print("  ")
-      when KwOptParam
-        print(" " * (node.value.size + 2))
-      end
     end
 
     #: (SigParam node, last: bool) -> void
     def print_sig_param_comment_leading_space(node, last:)
       printn
       printt
-      print(" " * (node.name.size + node.type.to_s.size + 3))
+      print(" " * (node.to_s.size + node.type.to_s.size + 3))
       print(" ") unless last
     end
 

data/lib/rbi/rbs/method_type_translator.rb

@@ -64,7 +64,7 @@ module RBI
         block_param = @method.params.grep(RBI::BlockParam).first
         raise Error, "No block param found" unless block_param
 
-        block_name = block_param.name.empty? ? "block" : block_param.name
+        block_name = block_param.name || "&"
         block_type = translate_type(type.type) #: as RBI::Type::Proc
 
         bind = type.self_type
@@ -123,15 +123,27 @@ module RBI
         param_name = param.name&.to_s
 
         unless param_name
-          method_param_name = @method.params[index]
-          raise Error, "No method param name found for parameter ##{index}" unless method_param_name
+          method_param = @method.params[index]
+          raise Error, "No method param name found for parameter ##{index}" unless method_param
 
-          param_name = method_param_name.name
+          param_name = method_param.name || anonymous_param_name(method_param)
         end
 
         SigParam.new(param_name, param_type)
       end
 
+      #: (Param) -> String?
+      def anonymous_param_name(param)
+        case param
+        when RestParam
+          "*"
+        when KwRestParam
+          "**"
+        when BlockParam
+          "&"
+        end
+      end
+
       #: (untyped) -> Type
       def translate_type(type)
         @type_translator.translate(type)

data/lib/rbi/rbs_printer.rb

@@ -613,7 +613,8 @@ module RBI
     # @override
     #: (KwRestParam node) -> void
     def visit_kw_rest_param(node)
-      print("**#{node.name}: untyped")
+      print("**untyped")
+      print(" #{node.name}") if node.name
     end
 
     # @override
@@ -912,25 +913,15 @@ module RBI
     def print_param_comment_leading_space(node, last:)
       printn
       printt
-      print(" " * (node.name.size + 1))
+      print(" " * (node.to_s.size + 1))
       print(" ") unless last
-      case node
-      when OptParam
-        print(" " * (node.value.size + 3))
-      when RestParam, KwParam, BlockParam
-        print(" ")
-      when KwRestParam
-        print("  ")
-      when KwOptParam
-        print(" " * (node.value.size + 2))
-      end
     end
 
     #: (SigParam node, last: bool) -> void
     def print_sig_param_comment_leading_space(node, last:)
       printn
       printt
-      print(" " * (node.name.size + node.type.to_s.size + 3))
+      print(" " * (node.to_s.size + node.type.to_s.size + 3))
       print(" ") unless last
     end
 

data/lib/rbi/rewriters/add_sig_templates.rb

@@ -45,7 +45,21 @@ module RBI
         return unless method.sigs.empty?
 
         method.sigs << Sig.new(
-          params: method.params.map { |param| SigParam.new(param.name, "::T.untyped") },
+          params: method.params.map do |param|
+            case param
+            when RBI::RestParam
+              SigParam.new(param.name || "*", "::T.untyped")
+            when RBI::KwRestParam
+              SigParam.new(param.name || "**", "::T.untyped")
+            when RBI::BlockParam
+              SigParam.new(param.name || "&", "::T.untyped")
+            else
+              SigParam.new(
+                param.name, #: as !nil
+                "::T.untyped",
+              )
+            end
+          end,
           return_type: "::T.untyped",
         )
         add_todo_comment(method)

data/lib/rbi/rewriters/merge_trees.rb

@@ -464,11 +464,17 @@ module RBI
     # @override
     #: (Node other) -> bool
     def compatible_with?(other)
-      other.is_a?(Method) &&
-        name == other.name &&
-        params == other.params &&
-        at_most_one_side_anonymous?(other) &&
-        (sigs.empty? || other.sigs.empty? || sigs == other.sigs)
+      return false unless other.is_a?(Method)
+      return false unless name == other.name
+      return false unless params.size == other.params.size
+
+      if sigs.empty? && other.sigs.empty?
+        compatible_params?(other)
+      elsif sigs.empty? || other.sigs.empty?
+        true
+      else
+        compatible_params?(other) && sigs == other.sigs
+      end
     end
 
     # @override
@@ -478,15 +484,15 @@ module RBI
 
       super
 
-      # If self is the all-anonymous side (since compatible_with? ensures
-      # at most one side is), or if self has no sigs but other does, adopt
-      # other's non-anonymous param names and sigs.
-      if params.all?(&:anonymous?) || (sigs.empty? && !other.sigs.empty?)
+      if sigs.empty? && !other.sigs.empty?
         @params = other.params.dup
-        @sigs = other.sigs.dup unless other.sigs.empty?
+        @sigs = other.sigs.dup
         return
       end
 
+      @params = merge_params(params, other.params)
+      rename_sigs_params(sigs, @params)
+
       other.sigs.each do |sig|
         sigs << sig unless sigs.include?(sig)
       end
@@ -495,10 +501,47 @@ module RBI
     private
 
     #: (Method other) -> bool
-    def at_most_one_side_anonymous?(other)
-      (params.all?(&:anonymous?) && other.params.none?(&:anonymous?)) ||
-        (params.none?(&:anonymous?) && other.params.all?(&:anonymous?)) ||
-        (params.none?(&:anonymous?) && other.params.none?(&:anonymous?))
+    def compatible_params?(other)
+      return true if params == other.params
+
+      params.zip(other.params).all? do |p1, p2|
+        p1.compatible_with?(p2)
+      end
+    end
+
+    #: (Array[Param] preferred, Array[Param] fallback) -> Array[Param]
+    def merge_params(preferred, fallback)
+      preferred.zip(fallback).map do |p1, p2|
+        if p1.anonymous?
+          p2.dup #: as !nil
+        else
+          p1.dup
+        end
+      end
+    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?
+            param.name #: as !nil
+          else
+            sig_param.name
+          end
+          SigParam.new(name, sig_param.type)
+        end
+        sig.params.replace(sig_params)
+      end
+    end
+  end
+
+  class Param
+    # @override
+    #: (Node? other) -> bool
+    def compatible_with?(other)
+      self.class === other && (anonymous? || other.anonymous? || name == other.name)
     end
   end
 

data/lib/rbi/version.rb

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

data/rbi/rbi.rbi

@@ -187,7 +187,7 @@ end
 class RBI::BlockParam < ::RBI::Param
   sig do
     params(
-      name: ::String,
+      name: T.nilable(::String),
       loc: T.nilable(::RBI::Loc),
       comments: T.nilable(T::Array[::RBI::Comment]),
       block: T.nilable(T.proc.params(node: ::RBI::BlockParam).void)
@@ -195,6 +195,15 @@ class RBI::BlockParam < ::RBI::Param
   end
   def initialize(name, 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(T.nilable(::String)) }
+  def name; end
+
   sig { override.returns(::String) }
   def to_s; end
 end
@@ -537,6 +546,15 @@ class RBI::KwOptParam < ::RBI::Param
   end
   def initialize(name, value, 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(::String) }
+  def name; end
+
   sig { override.returns(::String) }
   def to_s; end
 
@@ -555,6 +573,15 @@ class RBI::KwParam < ::RBI::Param
   end
   def initialize(name, 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(::String) }
+  def name; end
+
   sig { override.returns(::String) }
   def to_s; end
 end
@@ -562,7 +589,7 @@ end
 class RBI::KwRestParam < ::RBI::Param
   sig do
     params(
-      name: ::String,
+      name: T.nilable(::String),
       loc: T.nilable(::RBI::Loc),
       comments: T.nilable(T::Array[::RBI::Comment]),
       block: T.nilable(T.proc.params(node: ::RBI::KwRestParam).void)
@@ -570,6 +597,15 @@ class RBI::KwRestParam < ::RBI::Param
   end
   def initialize(name, 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(T.nilable(::String)) }
+  def name; end
+
   sig { override.returns(::String) }
   def to_s; end
 end
@@ -729,7 +765,13 @@ class RBI::Method < ::RBI::NodeWithComments
   private
 
   sig { params(other: ::RBI::Method).returns(T::Boolean) }
-  def at_most_one_side_anonymous?(other); end
+  def compatible_params?(other); end
+
+  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(sigs: T::Array[::RBI::Sig], params: T::Array[::RBI::Param]).void }
+  def rename_sigs_params(sigs, params); end
 end
 
 class RBI::MixesInClassMethods < ::RBI::Mixin
@@ -898,6 +940,18 @@ class RBI::OptParam < ::RBI::Param
   end
   def initialize(name, value, 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(::String) }
+  def name; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+
   sig { returns(::String) }
   def value; end
 end
@@ -905,20 +959,17 @@ end
 class RBI::Param < ::RBI::NodeWithComments
   abstract!
 
-  sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void }
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
+  sig { params(loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  sig { returns(T::Boolean) }
+  sig { abstract.returns(T::Boolean) }
   def anonymous?; end
 
-  sig { returns(::String) }
-  def name; end
+  sig { override.params(other: T.nilable(::RBI::Node)).returns(T::Boolean) }
+  def compatible_with?(other); end
 
-  sig { override.returns(::String) }
-  def to_s; end
+  sig { returns(T.nilable(::String)) }
+  def name; end
 end
 
 class RBI::ParseError < ::RBI::Error
@@ -985,6 +1036,9 @@ class RBI::Parser::SigBuilder < ::RBI::Parser::Visitor
   sig { returns(::RBI::Sig) }
   def current; end
 
+  sig { params(node: ::Prism::Node).returns(::String) }
+  def sig_param_name(node); end
+
   sig { override.params(node: ::Prism::AssocNode).void }
   def visit_assoc_node(node); end
 
@@ -1400,6 +1454,9 @@ class RBI::RBS::MethodTypeTranslator
 
   private
 
+  sig { params(param: ::RBI::Param).returns(T.nilable(::String)) }
+  def anonymous_param_name(param); end
+
   sig { params(param: ::RBS::Types::Function::Param, index: ::Integer).returns(::RBI::SigParam) }
   def translate_function_param(param, index); end
 
@@ -1740,6 +1797,18 @@ class RBI::ReqParam < ::RBI::Param
     ).void
   end
   def initialize(name, 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(::String) }
+  def name; end
+
+  sig { override.returns(::String) }
+  def to_s; end
 end
 
 class RBI::RequiresAncestor < ::RBI::NodeWithComments
@@ -1761,7 +1830,7 @@ end
 class RBI::RestParam < ::RBI::Param
   sig do
     params(
-      name: ::String,
+      name: T.nilable(::String),
       loc: T.nilable(::RBI::Loc),
       comments: T.nilable(T::Array[::RBI::Comment]),
       block: T.nilable(T.proc.params(node: ::RBI::RestParam).void)
@@ -1769,6 +1838,15 @@ class RBI::RestParam < ::RBI::Param
   end
   def initialize(name, 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(T.nilable(::String)) }
+  def name; end
+
   sig { override.returns(::String) }
   def to_s; end
 end
@@ -2252,6 +2330,9 @@ class RBI::SigParam < ::RBI::NodeWithComments
   sig { returns(::String) }
   def name; end
 
+  sig { override.returns(::String) }
+  def to_s; end
+
   sig { returns(T.any(::RBI::Type, ::String)) }
   def type; end
 end

metadata

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