rbi 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63c13a793960350c524172eebfffa1bc3104225fdb5d0b734e7da3e47b5e802c
-  data.tar.gz: 7160713203c93afde24219389cc252417d71363cbc1b3634d5e6ad282f548cd3
+  metadata.gz: a187f51ebadb01bef099fcb043616e2006c6de1ca6c11ee1ad542c5289ae2a79
+  data.tar.gz: 50ab0f1cdee28c524c4519aee5d67dd67adac2cb6377137f2de84d114ebd4a3f
 SHA512:
-  metadata.gz: a8b57f41c760a691f75b77d4a8272ef9221a72e6efe3c315c63bed079588d67882e7b9adeacdfeb8907c2734c77cd5212d1e2bdb65b4748da49dd1be72a49df3
-  data.tar.gz: e9aabb819ae1f5b5b82383088cafdce4c28078d3767808d95db80924929aa8244da7ac101418039630ae733277f1d2ceffe1581cc408b16fa3bdd1ea3047d032
+  metadata.gz: ba665a75493caea2312e6dea8ae3267b2a20a693e51b026b71d5914858cfdc6ce2eb98f665eeb6e307ce51da9446fee82f269984e1872c615414179528c00745
+  data.tar.gz: a6da77cf6a8ec3a3bc1f9a89378b05d416213aef48bbcffaf699b5e6c43198d9f30a030cd590a0f9deb75dc058f7670743fabbd629e37ac012670ea2a1bd44b2

data/lib/rbi/model.rb

@@ -542,6 +542,11 @@ 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)
@@ -550,6 +555,7 @@ module RBI
     #: (
     #|   ?params: Array[SigParam]?,
     #|   ?return_type: (String | Type),
+    #|   ?bind_type: (String | Type)?,
     #|   ?is_abstract: bool,
     #|   ?is_override: bool,
     #|   ?is_overridable: bool,
@@ -559,6 +565,7 @@ module RBI
     def add_sig(
       params: [],
       return_type: "void",
+      bind_type: nil,
       is_abstract: false,
       is_override: false,
       is_overridable: false,
@@ -570,6 +577,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,
@@ -807,6 +815,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?
@@ -1028,6 +1061,9 @@ module RBI
     #: (Type | String)
     attr_accessor :return_type
 
+    #: (Type | String)?
+    attr_accessor :bind_type
+
     #: bool
     attr_accessor :is_abstract
 
@@ -1065,6 +1101,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 +1117,7 @@ module RBI
     def initialize(
       params: nil,
       return_type: "void",
+      bind_type: nil,
       is_abstract: false,
       is_override: false,
       is_overridable: false,
@@ -1096,6 +1134,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 +1161,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(
@@ -743,6 +758,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,
@@ -828,7 +848,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 +956,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 +976,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 +1002,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

@@ -396,6 +396,12 @@ 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)
@@ -829,7 +835,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 +852,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

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,6 +583,12 @@ 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)
@@ -1116,9 +1085,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

@@ -45,12 +45,14 @@ module RBI
         return unless method.sigs.empty?
 
         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,

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.4.3"
 end

data/lib/rbi/visitor.rb

@@ -63,6 +63,8 @@ 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 Include
@@ -173,6 +175,9 @@ 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
 

data/rbi/rbi.rbi

@@ -698,6 +698,9 @@ class RBI::Method < ::RBI::NodeWithComments
   sig { params(name: ::String).void }
   def add_kw_rest_param(name); end
 
+  sig { void }
+  def add_no_kw_param; end
+
   sig { params(name: ::String, default_value: ::String).void }
   def add_opt_param(name, default_value); end
 
@@ -711,6 +714,7 @@ class RBI::Method < ::RBI::NodeWithComments
     params(
       params: T.nilable(T::Array[::RBI::SigParam]),
       return_type: T.any(::RBI::Type, ::String),
+      bind_type: T.nilable(T.any(::RBI::Type, ::String)),
       is_abstract: T::Boolean,
       is_override: T::Boolean,
       is_overridable: T::Boolean,
@@ -720,7 +724,7 @@ class RBI::Method < ::RBI::NodeWithComments
       block: T.nilable(T.proc.params(node: ::RBI::Sig).void)
     ).void
   end
-  def add_sig(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), &block); end
+  def add_sig(params: T.unsafe(nil), return_type: T.unsafe(nil), bind_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), &block); end
 
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
@@ -839,6 +843,26 @@ class RBI::Module < ::RBI::Scope
   def name; end
 end
 
+class RBI::NoKwParam < ::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::NoKwParam).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(::String) }
+  def to_s; end
+end
+
 class RBI::Node
   abstract!
 
@@ -1039,6 +1063,9 @@ class RBI::Parser::SigBuilder < ::RBI::Parser::Visitor
   sig { params(node: ::Prism::Node).returns(::String) }
   def sig_param_name(node); end
 
+  sig { params(node: ::Prism::CallNode).returns(T.nilable(::String)) }
+  def sig_type_argument(node); end
+
   sig { override.params(node: ::Prism::AssocNode).void }
   def visit_assoc_node(node); end
 
@@ -1150,6 +1177,9 @@ class RBI::Parser::Visitor < ::Prism::Visitor
   sig { params(node: ::Prism::Node).returns(::Prism::Location) }
   def adjust_prism_location_for_heredoc(node); end
 
+  sig { params(node: ::Prism::Node).returns(T::Boolean) }
+  def braceless_shape?(node); end
+
   sig { params(node: ::Prism::Node).returns(::RBI::Loc) }
   def node_loc(node); end
 
@@ -1164,6 +1194,9 @@ class RBI::Parser::Visitor < ::Prism::Visitor
 
   sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
   def t_sig_without_runtime?(node); end
+
+  sig { params(node: ::Prism::Node).returns(::String) }
+  def type_string(node); end
 end
 
 class RBI::Printer < ::RBI::Visitor
@@ -1316,6 +1349,9 @@ class RBI::Printer < ::RBI::Visitor
   sig { override.params(node: ::RBI::Module).void }
   def visit_module(node); end
 
+  sig { override.params(node: ::RBI::NoKwParam).void }
+  def visit_no_kw_param(node); end
+
   sig { override.params(node: ::RBI::OptParam).void }
   def visit_opt_param(node); end
 
@@ -1589,11 +1625,11 @@ class RBI::RBSPrinter < ::RBI::Visitor
   sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
   def print_method_sig(node, sig); end
 
-  sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
-  def print_method_sig_inline(node, sig); end
+  sig { params(sig_param: T.nilable(::RBI::SigParam)).void }
+  def print_method_sig_block(sig_param); end
 
-  sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
-  def print_method_sig_multiline(node, sig); end
+  sig { params(node: ::RBI::Method, sig: ::RBI::Sig, multiline: T::Boolean).void }
+  def print_method_sig_content(node, sig, multiline:); end
 
   sig { params(string: ::String).void }
   def printl(string); end
@@ -1679,6 +1715,9 @@ class RBI::RBSPrinter < ::RBI::Visitor
   sig { override.params(node: ::RBI::Module).void }
   def visit_module(node); end
 
+  sig { override.params(node: ::RBI::NoKwParam).void }
+  def visit_no_kw_param(node); end
+
   sig { override.params(node: ::RBI::OptParam).void }
   def visit_opt_param(node); end
 
@@ -2229,6 +2268,7 @@ class RBI::Sig < ::RBI::NodeWithComments
     params(
       params: T.nilable(T::Array[::RBI::SigParam]),
       return_type: T.any(::RBI::Type, ::String),
+      bind_type: T.nilable(T.any(::RBI::Type, ::String)),
       is_abstract: T::Boolean,
       is_override: T::Boolean,
       is_overridable: T::Boolean,
@@ -2243,7 +2283,7 @@ class RBI::Sig < ::RBI::NodeWithComments
       block: T.nilable(T.proc.params(node: ::RBI::Sig).void)
     ).void
   end
-  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), allow_incompatible_override: T.unsafe(nil), allow_incompatible_override_visibility: T.unsafe(nil), without_runtime: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), bind_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), allow_incompatible_override: T.unsafe(nil), allow_incompatible_override_visibility: T.unsafe(nil), without_runtime: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
   sig { params(param: ::RBI::SigParam).void }
   def <<(param); end
@@ -2264,6 +2304,11 @@ class RBI::Sig < ::RBI::NodeWithComments
 
   def allow_incompatible_override_visibility=(_arg0); end
 
+  sig { returns(T.nilable(T.any(::RBI::Type, ::String))) }
+  def bind_type; end
+
+  def bind_type=(_arg0); end
+
   sig { returns(T.nilable(::Symbol)) }
   def checked; end
 
@@ -2671,8 +2716,13 @@ class RBI::Type
     sig { returns(::RBI::Type::Boolean) }
     def boolean; end
 
-    sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).returns(::RBI::Type::ClassOf) }
-    def class_of(type, type_parameter = T.unsafe(nil)); end
+    sig do
+      params(
+        type: ::RBI::Type::Simple,
+        type_parameters: T.any(::RBI::Type, T::Array[::RBI::Type])
+      ).returns(::RBI::Type::ClassOf)
+    end
+    def class_of(type, *type_parameters); end
 
     sig { params(name: ::String, params: T.any(::RBI::Type, T::Array[::RBI::Type])).returns(::RBI::Type::Generic) }
     def generic(name, *params); end
@@ -2865,8 +2915,8 @@ class RBI::Type::Class < ::RBI::Type
 end
 
 class RBI::Type::ClassOf < ::RBI::Type
-  sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).void }
-  def initialize(type, type_parameter = T.unsafe(nil)); end
+  sig { params(type: ::RBI::Type::Simple, type_parameters: ::RBI::Type).void }
+  def initialize(type, *type_parameters); end
 
   sig { override.params(other: ::BasicObject).returns(T::Boolean) }
   def ==(other); end
@@ -2883,8 +2933,8 @@ class RBI::Type::ClassOf < ::RBI::Type
   sig { returns(::RBI::Type::Simple) }
   def type; end
 
-  sig { returns(T.nilable(::RBI::Type)) }
-  def type_parameter; end
+  sig { returns(T::Array[::RBI::Type]) }
+  def type_parameters; end
 end
 
 class RBI::Type::Composite < ::RBI::Type
@@ -3458,6 +3508,9 @@ class RBI::Visitor
   sig { params(node: ::RBI::Module).void }
   def visit_module(node); end
 
+  sig { params(node: ::RBI::NoKwParam).void }
+  def visit_no_kw_param(node); end
+
   sig { params(node: ::RBI::OptParam).void }
   def visit_opt_param(node); end
 

metadata

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