rbi 0.2.2 → 0.3.3

data/lib/rbi/rbs_printer.rb

@@ -5,65 +5,70 @@ module RBI
   class RBSPrinter < Visitor
     class Error < RBI::Error; end
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_accessor :print_locs, :in_visibility_group
 
-    sig { returns(T.nilable(Node)) }
+    #: Node?
     attr_reader :previous_node
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :current_indent
 
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def initialize(out: $stdout, indent: 0, print_locs: false)
+    #: bool
+    attr_accessor :positional_names
+
+    #: (?out: (IO | StringIO), ?indent: Integer, ?print_locs: bool, ?positional_names: bool) -> void
+    def initialize(out: $stdout, indent: 0, print_locs: false, positional_names: true)
       super()
       @out = out
       @current_indent = indent
       @print_locs = print_locs
-      @in_visibility_group = T.let(false, T::Boolean)
-      @previous_node = T.let(nil, T.nilable(Node))
+      @in_visibility_group = false #: bool
+      @previous_node = nil #: Node?
+      @positional_names = positional_names #: bool
     end
 
     # Printing
 
-    sig { void }
+    #: -> void
     def indent
       @current_indent += 2
     end
 
-    sig { void }
+    #: -> void
     def dedent
       @current_indent -= 2
     end
 
     # Print a string without indentation nor `\n` at the end.
-    sig { params(string: String).void }
+    #: (String string) -> void
     def print(string)
       @out.print(string)
     end
 
     # Print a string without indentation but with a `\n` at the end.
-    sig { params(string: T.nilable(String)).void }
+    #: (?String? string) -> void
     def printn(string = nil)
       print(string) if string
       print("\n")
     end
 
     # Print a string with indentation but without a `\n` at the end.
-    sig { params(string: T.nilable(String)).void }
+    #: (?String? string) -> void
     def printt(string = nil)
       print(" " * @current_indent)
       print(string) if string
     end
 
     # Print a string with indentation and `\n` at the end.
-    sig { params(string: String).void }
+    #: (String string) -> void
     def printl(string)
       printt
       printn(string)
     end
 
-    sig { override.params(nodes: T::Array[Node]).void }
+    # @override
+    #: (Array[Node] nodes) -> void
     def visit_all(nodes)
       previous_node = @previous_node
       @previous_node = nil
@@ -74,7 +79,8 @@ module RBI
       @previous_node = previous_node
     end
 
-    sig { override.params(file: File).void }
+    # @override
+    #: (File file) -> void
     def visit_file(file)
       unless file.comments.empty?
         visit_all(file.comments)
@@ -86,7 +92,8 @@ module RBI
       end
     end
 
-    sig { override.params(node: Comment).void }
+    # @override
+    #: (Comment node) -> void
     def visit_comment(node)
       lines = node.text.lines
 
@@ -102,39 +109,45 @@ module RBI
       end
     end
 
-    sig { override.params(node: BlankLine).void }
+    # @override
+    #: (BlankLine node) -> void
     def visit_blank_line(node)
       printn
     end
 
-    sig { override.params(node: Tree).void }
+    # @override
+    #: (Tree node) -> void
     def visit_tree(node)
       visit_all(node.comments)
       printn if !node.comments.empty? && !node.empty?
       visit_all(node.nodes)
     end
 
-    sig { override.params(node: Module).void }
+    # @override
+    #: (Module node) -> void
     def visit_module(node)
       visit_scope(node)
     end
 
-    sig { override.params(node: Class).void }
+    # @override
+    #: (Class node) -> void
     def visit_class(node)
       visit_scope(node)
     end
 
-    sig { override.params(node: Struct).void }
+    # @override
+    #: (Struct node) -> void
     def visit_struct(node)
       visit_scope(node)
     end
 
-    sig { override.params(node: SingletonClass).void }
+    # @override
+    #: (SingletonClass node) -> void
     def visit_singleton_class(node)
       visit_scope(node)
     end
 
-    sig { params(node: Scope).void }
+    #: (Scope node) -> void
     def visit_scope(node)
       print_blank_line_before(node)
       print_loc(node)
@@ -144,7 +157,7 @@ module RBI
       visit_scope_body(node)
     end
 
-    sig { params(node: Scope).void }
+    #: (Scope node) -> void
     def visit_scope_header(node)
       node.nodes.grep(Helper).each do |helper|
         visit(Comment.new("@#{helper.name}"))
@@ -197,7 +210,7 @@ module RBI
       printn
     end
 
-    sig { params(node: Scope).void }
+    #: (Scope node) -> void
     def visit_scope_body(node)
       unless node.empty?
         indent
@@ -209,7 +222,8 @@ module RBI
       end
     end
 
-    sig { override.params(node: Const).void }
+    # @override
+    #: (Const node) -> void
     def visit_const(node)
       print_blank_line_before(node)
       print_loc(node)
@@ -224,22 +238,25 @@ module RBI
       end
     end
 
-    sig { override.params(node: AttrAccessor).void }
+    # @override
+    #: (AttrAccessor node) -> void
     def visit_attr_accessor(node)
       visit_attr(node)
     end
 
-    sig { override.params(node: AttrReader).void }
+    # @override
+    #: (AttrReader node) -> void
     def visit_attr_reader(node)
       visit_attr(node)
     end
 
-    sig { override.params(node: AttrWriter).void }
+    # @override
+    #: (AttrWriter node) -> void
     def visit_attr_writer(node)
       visit_attr(node)
     end
 
-    sig { params(node: Attr).void }
+    #: (Attr node) -> void
     def visit_attr(node)
       print_blank_line_before(node)
 
@@ -271,40 +288,58 @@ module RBI
       end
     end
 
-    sig { params(node: RBI::Attr, sig: Sig).void }
+    #: (RBI::Attr node, Sig sig) -> void
     def print_attr_sig(node, sig)
+      ret_type = sig.return_type
+
       type = case node
-      when AttrAccessor, AttrReader
-        parse_type(sig.return_type)
+      when AttrReader, AttrAccessor
+        parse_type(ret_type).rbs_string
       else
-        first_arg = sig.params.first
-        if first_arg
-          parse_type(first_arg.type)
+        # For attr_writer, Sorbet will prioritize the return type over the argument type in case of mismatch
+        arg_type = sig.params.first
+        if arg_type && (ret_type.is_a?(Type::Void) || ret_type == "void")
+          # If we have an argument type and the return type is void, we prioritize the argument type
+          parse_type(arg_type.type).rbs_string
         else
-          Type.untyped
+          # Otherwise, we prioritize the return type
+          parse_type(ret_type).rbs_string
         end
       end
 
-      print(type.rbs_string)
+      print(type)
     end
 
-    sig { override.params(node: Method).void }
+    # @override
+    #: (Method node) -> void
     def visit_method(node)
       print_blank_line_before(node)
       visit_all(node.comments)
 
+      if node.sigs.any?(&:without_runtime)
+        printl("# @without_runtime")
+      end
+
       if node.sigs.any?(&:is_abstract)
         printl("# @abstract")
       end
 
       if node.sigs.any?(&:is_override)
-        printl("# @override")
+        if node.sigs.any?(&:allow_incompatible_override)
+          printl("# @override(allow_incompatible: true)")
+        else
+          printl("# @override")
+        end
       end
 
       if node.sigs.any?(&:is_overridable)
         printl("# @overridable")
       end
 
+      if node.sigs.any?(&:is_final)
+        printl("# @final")
+      end
+
       print_loc(node)
       printt
       unless in_visibility_group || node.visibility.public?
@@ -318,7 +353,10 @@ module RBI
       print(": ")
       if sigs.any?
         first, *rest = sigs
-        print_method_sig(node, T.must(first))
+        print_method_sig(
+          node,
+          first, #: as !nil
+        )
         if rest.any?
           spaces = node.name.size + 4
           rest.each do |sig|
@@ -346,10 +384,10 @@ module RBI
       printn
     end
 
-    sig { params(node: RBI::Method, sig: Sig).void }
+    #: (RBI::Method node, Sig sig) -> void
     def print_method_sig(node, sig)
       unless sig.type_params.empty?
-        print("[#{sig.type_params.map { |t| "TYPE_#{t}" }.join(", ")}] ")
+        print("[#{sig.type_params.join(", ")}] ")
       end
 
       block_param = node.params.find { |param| param.is_a?(BlockParam) }
@@ -388,9 +426,7 @@ module RBI
           type_string = "(?) -> untyped"
           block_is_nilable = true
         when Type::Simple
-          if block_type.name == "Proc"
-            type_string = "(?) -> untyped"
-          end
+          type_string = "(?) -> untyped"
           skip = true if block_type.name == "NilClass"
         end
 
@@ -410,52 +446,91 @@ module RBI
       print(" # #{loc}") if loc && print_locs
     end
 
-    sig { override.params(node: ReqParam).void }
+    #: (Sig node) -> void
+    def visit_sig(node)
+      if node.params
+        print("(")
+        node.params.each do |param|
+          visit(param)
+        end
+        print(") ")
+      end
+
+      print("-> #{parse_type(node.return_type).rbs_string}")
+    end
+
+    #: (SigParam node) -> void
+    def visit_sig_param(node)
+      print(parse_type(node.type).rbs_string)
+    end
+
+    # @override
+    #: (ReqParam node) -> void
     def visit_req_param(node)
-      print("untyped #{node.name}")
+      if @positional_names
+        print("untyped #{node.name}")
+      else
+        print("untyped")
+      end
     end
 
-    sig { override.params(node: OptParam).void }
+    # @override
+    #: (OptParam node) -> void
     def visit_opt_param(node)
-      print("?untyped #{node.name}")
+      if @positional_names
+        print("?untyped #{node.name}")
+      else
+        print("?untyped")
+      end
     end
 
-    sig { override.params(node: RestParam).void }
+    # @override
+    #: (RestParam node) -> void
     def visit_rest_param(node)
-      print("*untyped #{node.name}")
+      if @positional_names
+        print("*untyped #{node.name}")
+      else
+        print("*untyped")
+      end
     end
 
-    sig { override.params(node: KwParam).void }
+    # @override
+    #: (KwParam node) -> void
     def visit_kw_param(node)
       print("#{node.name}: untyped")
     end
 
-    sig { override.params(node: KwOptParam).void }
+    # @override
+    #: (KwOptParam node) -> void
     def visit_kw_opt_param(node)
       print("?#{node.name}: untyped")
     end
 
-    sig { override.params(node: KwRestParam).void }
+    # @override
+    #: (KwRestParam node) -> void
     def visit_kw_rest_param(node)
       print("**#{node.name}: untyped")
     end
 
-    sig { override.params(node: BlockParam).void }
+    # @override
+    #: (BlockParam node) -> void
     def visit_block_param(node)
       print("{ (*untyped) -> untyped } ")
     end
 
-    sig { override.params(node: Include).void }
+    # @override
+    #: (Include node) -> void
     def visit_include(node)
       visit_mixin(node)
     end
 
-    sig { override.params(node: Extend).void }
+    # @override
+    #: (Extend node) -> void
     def visit_extend(node)
       visit_mixin(node)
     end
 
-    sig { params(node: Mixin).void }
+    #: (Mixin node) -> void
     def visit_mixin(node)
       return if node.is_a?(MixesInClassMethods) # no-op, `mixes_in_class_methods` is not supported in RBS
 
@@ -472,22 +547,25 @@ module RBI
       printn(" #{node.names.join(", ")}")
     end
 
-    sig { override.params(node: Public).void }
+    # @override
+    #: (Public node) -> void
     def visit_public(node)
       visit_visibility(node)
     end
 
-    sig { override.params(node: Protected).void }
+    # @override
+    #: (Protected node) -> void
     def visit_protected(node)
       # no-op, `protected` is not supported in RBS
     end
 
-    sig { override.params(node: Private).void }
+    # @override
+    #: (Private node) -> void
     def visit_private(node)
       visit_visibility(node)
     end
 
-    sig { params(node: Visibility).void }
+    #: (Visibility node) -> void
     def visit_visibility(node)
       print_blank_line_before(node)
       print_loc(node)
@@ -496,22 +574,26 @@ module RBI
       printl(node.visibility.to_s)
     end
 
-    sig { override.params(node: Send).void }
+    # @override
+    #: (Send node) -> void
     def visit_send(node)
       # no-op, arbitrary sends are not supported in RBS
     end
 
-    sig { override.params(node: Arg).void }
+    # @override
+    #: (Arg node) -> void
     def visit_arg(node)
       # no-op
     end
 
-    sig { override.params(node: KwArg).void }
+    # @override
+    #: (KwArg node) -> void
     def visit_kw_arg(node)
       # no-op
     end
 
-    sig { override.params(node: TStruct).void }
+    # @override
+    #: (TStruct node) -> void
     def visit_tstruct(node)
       print_blank_line_before(node)
       print_loc(node)
@@ -545,65 +627,77 @@ module RBI
       printl("end")
     end
 
-    sig { override.params(node: TStructConst).void }
+    # @override
+    #: (TStructConst node) -> void
     def visit_tstruct_const(node)
       # `T::Struct.const` is not supported in RBS instead we generate an attribute reader
       accessor = AttrReader.new(node.name.to_sym, comments: node.comments, sigs: [Sig.new(return_type: node.type)])
       visit_attr_reader(accessor)
     end
 
-    sig { override.params(node: TStructProp).void }
+    # @override
+    #: (TStructProp node) -> void
     def visit_tstruct_prop(node)
       # `T::Struct.prop` is not supported in RBS instead we generate an attribute accessor
       accessor = AttrAccessor.new(node.name.to_sym, comments: node.comments, sigs: [Sig.new(return_type: node.type)])
       visit_attr_accessor(accessor)
     end
 
-    sig { override.params(node: TEnum).void }
+    # @override
+    #: (TEnum node) -> void
     def visit_tenum(node)
       visit_scope(node)
     end
 
-    sig { override.params(node: TEnumBlock).void }
+    # @override
+    #: (TEnumBlock node) -> void
     def visit_tenum_block(node)
-      node.nodes.each do |child|
-        child = if child.is_a?(Const) && child.value == "new"
-          parent = node.parent_scope
-          Const.new(
-            child.name,
-            "T.let(nil, #{parent.is_a?(TEnum) ? parent.name : "T.untyped"})",
-            comments: child.comments,
-          )
-        else
-          child
-        end
-        visit(child)
-        @previous_node = child
+      visit_all(node.nodes)
+    end
+
+    # @override
+    #: (TEnumValue node) -> void
+    def visit_tenum_value(node)
+      print_blank_line_before(node)
+      print_loc(node)
+      visit_all(node.comments)
+
+      t_enum = node.parent_scope&.parent_scope
+
+      if t_enum.is_a?(TEnum)
+        printl("#{node.name}: #{t_enum.name}")
+      else
+        printl("#{node.name}: untyped")
       end
     end
 
-    sig { override.params(node: TypeMember).void }
+    # @override
+    #: (TypeMember node) -> void
     def visit_type_member(node)
       # no-op, we already show them in the scope header
     end
 
-    sig { override.params(node: Helper).void }
+    # @override
+    #: (Helper node) -> void
     def visit_helper(node)
       # no-op, we already show them in the scope header
     end
 
-    sig { override.params(node: MixesInClassMethods).void }
+    # @override
+    #: (MixesInClassMethods node) -> void
     def visit_mixes_in_class_methods(node)
       visit_mixin(node)
     end
 
-    sig { override.params(node: Group).void }
+    # @override
+    #: (Group node) -> void
     def visit_group(node)
       printn unless previous_node.nil?
       visit_all(node.nodes)
     end
 
-    sig { override.params(node: VisibilityGroup).void }
+    # @override
+    #: (VisibilityGroup node) -> void
     def visit_visibility_group(node)
       self.in_visibility_group = true
       if node.visibility.public?
@@ -616,12 +710,14 @@ module RBI
       self.in_visibility_group = false
     end
 
-    sig { override.params(node: RequiresAncestor).void }
+    # @override
+    #: (RequiresAncestor node) -> void
     def visit_requires_ancestor(node)
       # no-op, we already show them in the scope header
     end
 
-    sig { override.params(node: ConflictTree).void }
+    # @override
+    #: (ConflictTree node) -> void
     def visit_conflict_tree(node)
       printl("<<<<<<< #{node.left_name}")
       visit(node.left)
@@ -630,7 +726,8 @@ module RBI
       printl(">>>>>>> #{node.right_name}")
     end
 
-    sig { override.params(node: ScopeConflict).void }
+    # @override
+    #: (ScopeConflict node) -> void
     def visit_scope_conflict(node)
       print_blank_line_before(node)
       print_loc(node)
@@ -646,7 +743,7 @@ module RBI
 
     private
 
-    sig { params(node: Node).void }
+    #: (Node node) -> void
     def print_blank_line_before(node)
       previous_node = self.previous_node
       return unless previous_node
@@ -665,13 +762,13 @@ module RBI
       printn
     end
 
-    sig { params(node: Node).void }
+    #: (Node node) -> void
     def print_loc(node)
       loc = node.loc
       printl("# #{loc}") if loc && print_locs
     end
 
-    sig { params(node: Method, param: SigParam).void }
+    #: (Method node, SigParam param) -> void
     def print_sig_param(node, param)
       type = parse_type(param.type).rbs_string
 
@@ -679,11 +776,23 @@ module RBI
 
       case orig_param
       when ReqParam
-        print("#{type} #{param.name}")
+        if @positional_names
+          print("#{type} #{param.name}")
+        else
+          print(type)
+        end
       when OptParam
-        print("?#{type} #{param.name}")
+        if @positional_names
+          print("?#{type} #{param.name}")
+        else
+          print("?#{type}")
+        end
       when RestParam
-        print("*#{type} #{param.name}")
+        if @positional_names
+          print("*#{type} #{param.name}")
+        else
+          print("*#{type}")
+        end
       when KwParam
         print("#{param.name}: #{type}")
       when KwOptParam
@@ -695,7 +804,7 @@ module RBI
       end
     end
 
-    sig { params(node: Param, last: T::Boolean).void }
+    #: (Param node, last: bool) -> void
     def print_param_comment_leading_space(node, last:)
       printn
       printt
@@ -713,7 +822,7 @@ module RBI
       end
     end
 
-    sig { params(node: SigParam, last: T::Boolean).void }
+    #: (SigParam node, last: bool) -> void
     def print_sig_param_comment_leading_space(node, last:)
       printn
       printt
@@ -721,7 +830,7 @@ module RBI
       print(" ") unless last
     end
 
-    sig { params(node: Node).returns(T::Boolean) }
+    #: (Node node) -> bool
     def oneline?(node)
       case node
       when ScopeConflict
@@ -743,7 +852,7 @@ module RBI
       end
     end
 
-    sig { params(type: T.any(Type, String)).returns(Type) }
+    #: ((Type | String) type) -> Type
     def parse_type(type)
       return type if type.is_a?(Type)
 
@@ -755,7 +864,7 @@ module RBI
     # Parse a string containing a `T.let(x, X)` and extract the type
     #
     # Returns `nil` is the string is not a `T.let`.
-    sig { params(code: T.nilable(String)).returns(T.nilable(String)) }
+    #: (String? code) -> String?
     def parse_t_let(code)
       return unless code
 
@@ -778,17 +887,15 @@ module RBI
   end
 
   class TypePrinter
-    extend T::Sig
-
-    sig { returns(String) }
+    #: String
     attr_reader :string
 
-    sig { void }
+    #: -> void
     def initialize
-      @string = T.let(String.new, String)
+      @string = String.new #: String
     end
 
-    sig { params(node: Type).void }
+    #: (Type node) -> void
     def visit(node)
       case node
       when Type::Simple
@@ -832,19 +939,19 @@ module RBI
       end
     end
 
-    sig { params(type: Type::Simple).void }
+    #: (Type::Simple type) -> void
     def visit_simple(type)
-      @string << translate_t_type(type.name)
+      @string << translate_t_type(type.name.gsub(/\s/, ""))
     end
 
-    sig { params(type: Type::Boolean).void }
+    #: (Type::Boolean type) -> void
     def visit_boolean(type)
       @string << "bool"
     end
 
-    sig { params(type: Type::Generic).void }
+    #: (Type::Generic type) -> void
     def visit_generic(type)
-      @string << translate_t_type(type.name)
+      @string << translate_t_type(type.name.gsub(/\s/, ""))
       @string << "["
       type.params.each_with_index do |arg, index|
         visit(arg)
@@ -853,50 +960,57 @@ module RBI
       @string << "]"
     end
 
-    sig { params(type: Type::Anything).void }
+    #: (Type::Anything type) -> void
     def visit_anything(type)
       @string << "top"
     end
 
-    sig { params(type: Type::Void).void }
+    #: (Type::Void type) -> void
     def visit_void(type)
       @string << "void"
     end
 
-    sig { params(type: Type::NoReturn).void }
+    #: (Type::NoReturn type) -> void
     def visit_no_return(type)
       @string << "bot"
     end
 
-    sig { params(type: Type::Untyped).void }
+    #: (Type::Untyped type) -> void
     def visit_untyped(type)
       @string << "untyped"
     end
 
-    sig { params(type: Type::SelfType).void }
+    #: (Type::SelfType type) -> void
     def visit_self_type(type)
       @string << "self"
     end
 
-    sig { params(type: Type::AttachedClass).void }
+    #: (Type::AttachedClass type) -> void
     def visit_attached_class(type)
       @string << "instance"
     end
 
-    sig { params(type: Type::Nilable).void }
+    #: (Type::Nilable type) -> void
     def visit_nilable(type)
-      visit(type.type)
+      inner = type.type
+      if inner.is_a?(Type::Proc)
+        @string << "("
+      end
+      visit(inner)
+      if inner.is_a?(Type::Proc)
+        @string << ")"
+      end
       @string << "?"
     end
 
-    sig { params(type: Type::ClassOf).void }
+    #: (Type::ClassOf type) -> void
     def visit_class_of(type)
       @string << "singleton("
       visit(type.type)
       @string << ")"
     end
 
-    sig { params(type: Type::All).void }
+    #: (Type::All type) -> void
     def visit_all(type)
       @string << "("
       type.types.each_with_index do |arg, index|
@@ -906,7 +1020,7 @@ module RBI
       @string << ")"
     end
 
-    sig { params(type: Type::Any).void }
+    #: (Type::Any type) -> void
     def visit_any(type)
       @string << "("
       type.types.each_with_index do |arg, index|
@@ -916,7 +1030,7 @@ module RBI
       @string << ")"
     end
 
-    sig { params(type: Type::Tuple).void }
+    #: (Type::Tuple type) -> void
     def visit_tuple(type)
       @string << "["
       type.types.each_with_index do |arg, index|
@@ -926,18 +1040,27 @@ module RBI
       @string << "]"
     end
 
-    sig { params(type: Type::Shape).void }
+    #: (Type::Shape type) -> void
     def visit_shape(type)
       @string << "{"
       type.types.each_with_index do |(key, value), index|
-        @string << "#{key}: "
+        @string << case key
+        when String
+          "\"#{key}\" => "
+        when Symbol
+          if key.match?(/\A[a-zA-Z_]+[a-zA-Z0-9_]*\z/)
+            "#{key}: "
+          else
+            "\"#{key}\": "
+          end
+        end
         visit(value)
         @string << ", " if index < type.types.size - 1
       end
       @string << "}"
     end
 
-    sig { params(type: Type::Proc).void }
+    #: (Type::Proc type) -> void
     def visit_proc(type)
       @string << "^"
       if type.proc_params.any?
@@ -949,25 +1072,31 @@ module RBI
         end
         @string << ") "
       end
+      proc_bind = type.proc_bind
+      if proc_bind
+        @string << "[self: "
+        visit(proc_bind)
+        @string << "] "
+      end
       @string << "-> "
       visit(type.proc_returns)
     end
 
-    sig { params(type: Type::TypeParameter).void }
+    #: (Type::TypeParameter type) -> void
     def visit_type_parameter(type)
-      @string << "TYPE_#{type.name}"
+      @string << type.name.to_s
     end
 
-    sig { params(type: Type::Class).void }
+    #: (Type::Class type) -> void
     def visit_class(type)
-      @string << "singleton("
+      @string << "Class["
       visit(type.type)
-      @string << ")"
+      @string << "]"
     end
 
     private
 
-    sig { params(type_name: String).returns(String) }
+    #: (String type_name) -> String
     def translate_t_type(type_name)
       case type_name
       when "T::Array"
@@ -983,15 +1112,13 @@ module RBI
   end
 
   class File
-    extend T::Sig
-
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+    #: (?out: (IO | StringIO), ?indent: Integer, ?print_locs: bool) -> void
     def rbs_print(out: $stdout, indent: 0, print_locs: false)
       p = RBSPrinter.new(out: out, indent: indent, print_locs: print_locs)
       p.visit_file(self)
     end
 
-    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
+    #: (?indent: Integer, ?print_locs: bool) -> String
     def rbs_string(indent: 0, print_locs: false)
       out = StringIO.new
       rbs_print(out: out, indent: indent, print_locs: print_locs)
@@ -1000,26 +1127,22 @@ module RBI
   end
 
   class Node
-    extend T::Sig
-
-    sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
-    def rbs_print(out: $stdout, indent: 0, print_locs: false)
-      p = RBSPrinter.new(out: out, indent: indent, print_locs: print_locs)
+    #: (?out: (IO | StringIO), ?indent: Integer, ?print_locs: bool, ?positional_names: bool) -> void
+    def rbs_print(out: $stdout, indent: 0, print_locs: false, positional_names: true)
+      p = RBSPrinter.new(out: out, indent: indent, print_locs: print_locs, positional_names: positional_names)
       p.visit(self)
     end
 
-    sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
-    def rbs_string(indent: 0, print_locs: false)
+    #: (?indent: Integer, ?print_locs: bool, ?positional_names: bool) -> String
+    def rbs_string(indent: 0, print_locs: false, positional_names: true)
       out = StringIO.new
-      rbs_print(out: out, indent: indent, print_locs: print_locs)
+      rbs_print(out: out, indent: indent, print_locs: print_locs, positional_names: positional_names)
       out.string
     end
   end
 
   class Type
-    extend T::Sig
-
-    sig { returns(String) }
+    #: -> String
     def rbs_string
       p = TypePrinter.new
       p.visit(self)