rbi 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63c13a793960350c524172eebfffa1bc3104225fdb5d0b734e7da3e47b5e802c
-  data.tar.gz: 7160713203c93afde24219389cc252417d71363cbc1b3634d5e6ad282f548cd3
+  metadata.gz: 7abed145bf2c620d24e9b6cd69c6b58e4a1a88230f1fa304018621098f13c89b
+  data.tar.gz: 24c00005fa963db2dcec897a7412cb8e953c3f03007e8ab7f986e66a4927ffad
 SHA512:
-  metadata.gz: a8b57f41c760a691f75b77d4a8272ef9221a72e6efe3c315c63bed079588d67882e7b9adeacdfeb8907c2734c77cd5212d1e2bdb65b4748da49dd1be72a49df3
-  data.tar.gz: e9aabb819ae1f5b5b82383088cafdce4c28078d3767808d95db80924929aa8244da7ac101418039630ae733277f1d2ceffe1581cc408b16fa3bdd1ea3047d032
+  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

@@ -542,14 +542,25 @@ module RBI
       params << KwRestParam.new(name)
     end
 
+    #: -> void
+    def add_no_kw_param
+      params << NoKwParam.new
+    end
+
     #: (String name) -> void
     def add_block_param(name)
       params << BlockParam.new(name)
     end
 
+    #: -> void
+    def add_forwarding_param
+      params << ForwardingParam.new
+    end
+
     #: (
     #|   ?params: Array[SigParam]?,
     #|   ?return_type: (String | Type),
+    #|   ?bind_type: (String | Type)?,
     #|   ?is_abstract: bool,
     #|   ?is_override: bool,
     #|   ?is_overridable: bool,
@@ -559,6 +570,7 @@ module RBI
     def add_sig(
       params: [],
       return_type: "void",
+      bind_type: nil,
       is_abstract: false,
       is_override: false,
       is_overridable: false,
@@ -570,6 +582,7 @@ module RBI
       sig = Sig.new(
         params: params,
         return_type: return_type,
+        bind_type: bind_type,
         is_abstract: is_abstract,
         is_override: is_override,
         is_overridable: is_overridable,
@@ -607,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
@@ -807,6 +820,31 @@ module RBI
     end
   end
 
+  class NoKwParam < Param
+    #: (?loc: Loc?, ?comments: Array[Comment]?) ?{ (NoKwParam node) -> void } -> void
+    def initialize(loc: nil, comments: nil, &block)
+      super(loc: loc, comments: comments)
+      block&.call(self)
+    end
+
+    # @override
+    #: -> String
+    def to_s
+      "**nil"
+    end
+
+    # @override
+    #: -> bool
+    def anonymous?
+      false
+    end
+
+    #: (Object? other) -> bool
+    def ==(other)
+      NoKwParam === other
+    end
+  end
+
   class BlockParam < Param
     # @override
     #: String?
@@ -837,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
@@ -1028,6 +1098,9 @@ module RBI
     #: (Type | String)
     attr_accessor :return_type
 
+    #: (Type | String)?
+    attr_accessor :bind_type
+
     #: bool
     attr_accessor :is_abstract
 
@@ -1065,6 +1138,7 @@ module RBI
     #: (
     #|   ?params: Array[SigParam]?,
     #|   ?return_type: (Type | String),
+    #|   ?bind_type: (Type | String)?,
     #|   ?is_abstract: bool,
     #|   ?is_override: bool,
     #|   ?is_overridable: bool,
@@ -1080,6 +1154,7 @@ module RBI
     def initialize(
       params: nil,
       return_type: "void",
+      bind_type: nil,
       is_abstract: false,
       is_override: false,
       is_overridable: false,
@@ -1096,6 +1171,7 @@ module RBI
       super(loc: loc, comments: comments)
       @params = params #: Array[SigParam]?
       @return_type = return_type
+      @bind_type = bind_type
       @is_abstract = is_abstract
       @is_override = is_override
       @is_overridable = is_overridable
@@ -1122,7 +1198,8 @@ module RBI
     def ==(other)
       return false unless other.is_a?(Sig)
 
-      params == other.params && return_type.to_s == other.return_type.to_s && is_abstract == other.is_abstract &&
+      params == other.params && return_type.to_s == other.return_type.to_s &&
+        bind_type&.to_s == other.bind_type&.to_s && is_abstract == other.is_abstract &&
         is_override == other.is_override && is_overridable == other.is_overridable && is_final == other.is_final &&
         without_runtime == other.without_runtime && type_params == other.type_params && checked == other.checked
     end

data/lib/rbi/parser.rb

@@ -139,6 +139,21 @@ module RBI
         node_string(node) #: as !nil
       end
 
+      #: (Prism::Node node) -> String
+      def type_string(node)
+        type = node_string!(node)
+        braceless_shape?(node) ? "{#{type}}" : type
+      end
+
+      #: (Prism::Node node) -> bool
+      def braceless_shape?(node)
+        return false unless node.is_a?(Prism::KeywordHashNode)
+
+        node.elements.all? do |element|
+          element.is_a?(Prism::AssocNode) && element.operator_loc
+        end
+      end
+
       #: (Prism::Node node) -> Prism::Location
       def adjust_prism_location_for_heredoc(node)
         visitor = HeredocLocationVisitor.new(
@@ -537,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)
@@ -743,6 +757,11 @@ module RBI
               loc: node_loc(param),
               comments: node_comments(param),
             )
+          when Prism::NoKeywordsParameterNode
+            NoKwParam.new(
+              loc: node_loc(param),
+              comments: node_comments(param),
+            )
           when Prism::KeywordRestParameterNode
             KwRestParam.new(
               param.name&.to_s,
@@ -755,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
@@ -828,7 +852,7 @@ module RBI
         return unless type_arg
 
         name = node_string!(name_arg).delete_prefix(":")
-        type = node_string!(type_arg)
+        type = type_string(type_arg)
         loc = node_loc(send)
         comments = node_comments(send)
         default_value = nil #: String?
@@ -936,6 +960,9 @@ module RBI
               @current.is_final = node_string(arg) == ":final"
             end
           end
+        when "bind"
+          bind_type = sig_type_argument(node)
+          @current.bind_type = bind_type if bind_type
         when "abstract"
           @current.is_abstract = true
         when "checked"
@@ -953,11 +980,8 @@ module RBI
         when "params"
           visit(node.arguments)
         when "returns"
-          args = node.arguments
-          if args.is_a?(Prism::ArgumentsNode)
-            first = args.arguments.first
-            @current.return_type = node_string!(first) if first
-          end
+          return_type = sig_type_argument(node)
+          @current.return_type = return_type if return_type
         when "type_parameters"
           args = node.arguments
           if args.is_a?(Prism::ArgumentsNode)
@@ -982,6 +1006,17 @@ module RBI
         )
       end
 
+      #: (Prism::CallNode node) -> String?
+      def sig_type_argument(node)
+        args = node.arguments
+        return unless args.is_a?(Prism::ArgumentsNode)
+
+        type_node = args.arguments.first
+        return unless type_node
+
+        type_string(type_node)
+      end
+
       #: (Prism::Node node) -> String
       def sig_param_name(node)
         case node

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
@@ -396,12 +396,24 @@ module RBI
       self.print(node.to_s)
     end
 
+    # @override
+    #: (NoKwParam node) -> void
+    def visit_no_kw_param(node)
+      self.print(node.to_s)
+    end
+
     # @override
     #: (BlockParam node) -> void
     def visit_block_param(node)
       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)
@@ -829,7 +841,7 @@ module RBI
 
     #: (Sig node) -> Array[String]
     def sig_modifiers(node)
-      return EMPTY_MODIFIERS unless node.is_abstract || node.is_override || node.is_overridable ||
+      return EMPTY_MODIFIERS unless node.is_abstract || node.is_override || node.is_overridable || node.bind_type ||
         node.type_params? || node.checked
 
       modifiers = [] #: Array[String]
@@ -846,6 +858,7 @@ module RBI
       end
 
       modifiers << "overridable" if node.is_overridable
+      modifiers << "bind(#{node.bind_type})" if node.bind_type
       if node.type_params?
         modifiers << "type_parameters(#{node.type_params.map { |type| ":#{type}" }.join(", ")})"
       end

data/lib/rbi/rbs/method_type_translator.rb

@@ -110,7 +110,7 @@ module RBI
         end
 
         rest_keyword = type.rest_keywords
-        if rest_keyword
+        if rest_keyword && !rest_keyword.type.is_a?(::RBS::Types::Bases::Nil)
           result.params << translate_function_param(rest_keyword, index)
         end
 

data/lib/rbi/rbs/type_translator.rb

@@ -66,9 +66,12 @@ module RBI
         when ::RBS::Types::Bases::Void
           Type.void
         when ::RBS::Types::ClassSingleton
-          type_arg = type.args.first
-          type_parameter = translate(type_arg) if type_arg && !@options.erase_generic_types
-          Type.class_of(Type.simple(type.name.to_s), type_parameter)
+          type_parameters = if @options.erase_generic_types
+            []
+          else
+            type.args.map { |type_arg| translate(type_arg) }
+          end
+          Type.class_of(Type.simple(type.name.to_s), *type_parameters)
         when ::RBS::Types::ClassInstance
           translate_class_instance(type)
         when ::RBS::Types::Function
@@ -203,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

@@ -411,75 +411,75 @@ module RBI
       new_out = StringIO.new
 
       @out = new_out
-      print_method_sig_inline(node, sig)
+      print_method_sig_content(node, sig, multiline: false)
       @out = old_out
 
       max_line_length = @max_line_length
       if @force_multiline_signatures || (max_line_length && new_out.string.size > max_line_length)
-        print_method_sig_multiline(node, sig)
+        print_method_sig_content(node, sig, multiline: true)
       else
         print(new_out.string)
       end
     end
 
-    #: (RBI::Method node, Sig sig) -> void
-    def print_method_sig_inline(node, sig)
+    #: (RBI::Method node, Sig sig, multiline: bool) -> void
+    def print_method_sig_content(node, sig, multiline:)
       unless sig.type_params.empty?
         print("[#{sig.type_params.join(", ")}] ")
       end
 
-      raise Error, "Arity mismatch between method and signature" if sig.params.size != node.params.size
+      no_kw_params, method_params = node.params.partition { |param| param.is_a?(NoKwParam) }
+      raise Error, "Multiple no-keywords parameters found" if no_kw_params.size > 1
+      raise Error, "Arity mismatch between method and signature" if sig.params.size != method_params.size
 
-      block_params, params = sig.params.zip(node.params).partition do |_sig_param, method_param|
+      params = sig.params.zip(method_params) #: Array[[SigParam?, Param?]]
+      block_params, params = params.partition do |_sig_param, method_param|
         method_param.is_a?(BlockParam)
       end
 
       raise Error, "Multiple block parameters found" if block_params.size > 1
 
-      block_param = block_params.first if block_params.any?
+      no_kw_param = no_kw_params.first
+      params << [nil, no_kw_param] if no_kw_param
 
       unless params.empty?
-        print("(")
-        params.each_with_index do |(sig_param, method_param), index|
-          print(", ") if index > 0
-          print_sig_param(
-            sig_param,
-            method_param, #: as !nil
-          )
-        end
-        print(") ")
-      end
-      if (sig_param = block_param&.first)
-        block_type = sig_param.type
-        block_type = Type.parse_string(block_type) if block_type.is_a?(String)
-
-        block_is_nilable = false
-        if block_type.is_a?(Type::Nilable)
-          block_is_nilable = true
-          block_type = block_type.type
+        if multiline
+          printl("(")
+          indent
+        else
+          print("(")
         end
 
-        type_string = parse_type(block_type).rbs_string.delete_prefix("^")
-
-        skip = false
-        case block_type
-        when Type::Untyped
-          type_string = "(?) -> untyped"
-          block_is_nilable = true
-        when Type::Simple
-          type_string = "(?) -> untyped"
-          skip = true if block_type.name == "NilClass"
+        params.each_with_index do |(sig_param, method_param), index|
+          if multiline
+            printt
+          elsif index > 0
+            print(", ")
+          end
+          if method_param.is_a?(NoKwParam)
+            visit(method_param)
+          else
+            print_sig_param(
+              sig_param, #: as !nil
+              method_param, #: as !nil
+            )
+          end
+          if multiline
+            print(",") if index < params.size - 1
+            printn
+          end
         end
 
-        if skip
-          # no-op, we skip the block definition
-        elsif block_is_nilable
-          print("?{ #{type_string} } ")
+        if multiline
+          dedent
+          printt(") ")
         else
-          print("{ #{type_string} } ")
+          print(") ")
         end
       end
 
+      print_method_sig_block(block_params.first&.first)
+
       type = parse_type(sig.return_type)
       print("-> #{type.rbs_string}")
 
@@ -487,73 +487,36 @@ module RBI
       print(" # #{loc}") if loc && print_locs
     end
 
-    #: (RBI::Method node, Sig sig) -> void
-    def print_method_sig_multiline(node, sig)
-      unless sig.type_params.empty?
-        print("[#{sig.type_params.join(", ")}] ")
-      end
+    #: (SigParam? sig_param) -> void
+    def print_method_sig_block(sig_param)
+      return unless sig_param
 
-      raise Error, "Arity mismatch between method and signature" if sig.params.size != node.params.size
+      block_type = sig_param.type
+      block_type = Type.parse_string(block_type) if block_type.is_a?(String)
 
-      block_params, params = sig.params.zip(node.params).partition do |_sig_param, method_param|
-        method_param.is_a?(BlockParam)
+      block_is_nilable = false
+      if block_type.is_a?(Type::Nilable)
+        block_is_nilable = true
+        block_type = block_type.type
       end
 
-      raise Error, "Multiple block parameters found" if block_params.size > 1
+      type_string = parse_type(block_type).rbs_string.delete_prefix("^")
 
-      block_param = block_params.first if block_params.any?
+      case block_type
+      when Type::Untyped
+        type_string = "(?) -> untyped"
+        block_is_nilable = true
+      when Type::Simple
+        return if block_type.name == "NilClass"
 
-      unless params.empty?
-        printl("(")
-        indent
-        params.each_with_index do |(sig_param, method_param), index|
-          printt
-          print_sig_param(
-            sig_param,
-            method_param, #: as !nil
-          )
-          print(",") if index < params.size - 1
-          printn
-        end
-        dedent
-        printt(") ")
+        type_string = "(?) -> untyped"
       end
-      if (block_param = block_param&.first)
-        block_type = block_param.type
-        block_type = Type.parse_string(block_type) if block_type.is_a?(String)
-
-        block_is_nilable = false
-        if block_type.is_a?(Type::Nilable)
-          block_is_nilable = true
-          block_type = block_type.type
-        end
-
-        type_string = parse_type(block_type).rbs_string.delete_prefix("^")
 
-        skip = false
-        case block_type
-        when Type::Untyped
-          type_string = "(?) -> untyped"
-          block_is_nilable = true
-        when Type::Simple
-          type_string = "(?) -> untyped"
-          skip = true if block_type.name == "NilClass"
-        end
-
-        if skip
-          # no-op, we skip the block definition
-        elsif block_is_nilable
-          print("?{ #{type_string} } ")
-        else
-          print("{ #{type_string} } ")
-        end
+      if block_is_nilable
+        print("?{ #{type_string} } ")
+      else
+        print("{ #{type_string} } ")
       end
-
-      type = parse_type(sig.return_type)
-      print("-> #{type.rbs_string}")
-
-      loc = sig.loc
-      print(" # #{loc}") if loc && print_locs
     end
 
     #: (Sig node) -> void
@@ -620,12 +583,24 @@ module RBI
       print(" #{node.name}") unless node.anonymous?
     end
 
+    # @override
+    #: (NoKwParam node) -> void
+    def visit_no_kw_param(node)
+      print("**nil")
+    end
+
     # @override
     #: (BlockParam node) -> void
     def visit_block_param(node)
       print("{ (*untyped) -> untyped } ")
     end
 
+    # @override
+    #: (ForwardingParam node) -> void
+    def visit_forwarding_param(node)
+      print("...")
+    end
+
     # @override
     #: (Include node) -> void
     def visit_include(node)
@@ -1116,9 +1091,12 @@ module RBI
       @string << "singleton("
       visit(type.type)
       @string << ")"
-      if (type_parameter = type.type_parameter)
+      unless type.type_parameters.empty?
         @string << "["
-        visit(type_parameter)
+        type.type_parameters.each_with_index do |type_parameter, index|
+          visit(type_parameter)
+          @string << ", " if index < type.type_parameters.size - 1
+        end
         @string << "]"
       end
     end

data/lib/rbi/rewriters/add_sig_templates.rb

@@ -44,13 +44,18 @@ 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.map do |param|
+          params: method.params.filter_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::NoKwParam
+              next
             when RBI::BlockParam
               SigParam.new(param.name || "&", "::T.untyped")
             else

data/lib/rbi/rewriters/attr_to_methods.rb

@@ -103,6 +103,7 @@ module RBI
         Sig.new(
           params: params,
           return_type: "void",
+          bind_type: sig.bind_type,
           is_abstract: sig.is_abstract,
           is_override: sig.is_override,
           is_overridable: sig.is_overridable,