rbi 0.4.2 → 0.5.0

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/type.rb

@@ -315,29 +315,29 @@ module RBI
       #: Simple
       attr_reader :type
 
-      #: Type?
-      attr_reader :type_parameter
+      #: Array[Type]
+      attr_reader :type_parameters
 
-      #: (Simple type, ?Type? type_parameter) -> void
-      def initialize(type, type_parameter = nil)
+      #: (Simple type, *Type type_parameters) -> void
+      def initialize(type, *type_parameters)
         super()
         @type = type
-        @type_parameter = type_parameter
+        @type_parameters = type_parameters #: Array[Type]
       end
 
       # @override
       #: (BasicObject other) -> bool
       def ==(other)
-        ClassOf === other && @type == other.type && @type_parameter == other.type_parameter
+        ClassOf === other && @type == other.type && @type_parameters == other.type_parameters
       end
 
       # @override
       #: -> String
       def to_rbi
-        if @type_parameter
-          "::T.class_of(#{@type.to_rbi})[#{@type_parameter.to_rbi}]"
-        else
+        if @type_parameters.empty?
           "::T.class_of(#{@type.to_rbi})"
+        else
+          "::T.class_of(#{@type.to_rbi})[#{@type_parameters.map(&:to_rbi).join(", ")}]"
         end
       end
 
@@ -913,9 +913,9 @@ module RBI
       end
 
       # Builds a type that represents the singleton class of another type like `T.class_of(Foo)`.
-      #: (Simple type, ?Type? type_parameter) -> ClassOf
-      def class_of(type, type_parameter = nil)
-        ClassOf.new(type, type_parameter)
+      #: (Simple type, *(Type | Array[Type]) type_parameters) -> ClassOf
+      def class_of(type, *type_parameters)
+        ClassOf.new(type, *type_parameters.flatten)
       end
 
       # Builds a type that represents a nilable of another type like `T.nilable(String)`.

data/lib/rbi/type_parser.rb

@@ -130,7 +130,7 @@ module RBI
               return Type::Generic.new(recv.slice, *args.map { |arg| parse_node(arg) })
             end
           when Prism::CallNode
-            # `T.class_of(Foo)[Bar]`
+            # `T.class_of(Foo)[Foo]` or `T.class_of(Foo)[Foo, Bar]`
             if t_class_of?(recv)
               type_args = check_arguments_exactly!(recv, 1)
               type = parse_node(
@@ -138,11 +138,9 @@ module RBI
               )
               raise Error, "Expected a simple type, got `#{type}`" unless type.is_a?(Type::Simple)
 
-              type_param_args = check_arguments_exactly!(node, 1)
-              type_param = parse_node(
-                type_param_args.first, #: as !nil
-              )
-              return Type::ClassOf.new(type, type_param)
+              type_parameter_args = check_arguments_at_least!(node, 1)
+              type_parameters = type_parameter_args.map { |arg| parse_node(arg) }
+              return Type::ClassOf.new(type, *type_parameters)
             end
           end
 

data/lib/rbi/version.rb

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

data/lib/rbi/visitor.rb

@@ -63,8 +63,12 @@ module RBI
         visit_kw_opt_param(node)
       when KwRestParam
         visit_kw_rest_param(node)
+      when NoKwParam
+        visit_no_kw_param(node)
       when BlockParam
         visit_block_param(node)
+      when ForwardingParam
+        visit_forwarding_param(node)
       when Include
         visit_include(node)
       when Extend
@@ -173,9 +177,15 @@ module RBI
     #: (KwRestParam node) -> void
     def visit_kw_rest_param(node); end
 
+    #: (NoKwParam node) -> void
+    def visit_no_kw_param(node); end
+
     #: (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