rbi 0.3.3 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5d95986e2041432d98662ec8d46d89eb8a1b8cafafd8bba4d78ac7218e4379e
-  data.tar.gz: bbc117ade8b85f2834e172f6d7c4fac54c71846634b176b52adf607a0c82d37a
+  metadata.gz: 80df141e229452edf3fb51dc8933c130ce2a2f972ee6906be79680d79f33a720
+  data.tar.gz: '099a5b5fb43ccd50cf262bcdbc0d8fde6cd0aa14983851c9de14f488def2a56b'
 SHA512:
-  metadata.gz: bc76dff9e19e46d13dd54d458b018cf0f41210f2ca00d7b6a053012740017fc4d47ac9b5f09ea66921b9e3634c415116f5ad4d3bc3c34d53bd4d208dc5cb9362
-  data.tar.gz: 37eafcb497a99293ebac8a2614863bcebdb294effa0a02e479f24b853a2b9886a16f927bfdb1f31d4c31d66527310ef716d21ee6e62f885db7c27a9133ed6c7d
+  metadata.gz: 791d993759d3e237a52d34be622c23eec92d1adb26b267aa47b3aa9e7ce1767b96fff75e02d895493fb63b84fe3f15cb1c37f880db1698e5a8b9e17cba77503e
+  data.tar.gz: cdf11ef801d7ac8a1329b39e095c4895d006ae46ad800d50d1d2cb52aa9c41fdb704557a8a660376b53e4bdb86a076bacde0a5a2c33d0031478dda36850297b1

data/Gemfile

@@ -9,8 +9,8 @@ group(:development, :test) do
   gem("byebug")
   gem("minitest")
   gem("minitest-reporters")
-  gem("rake", "~> 13.2")
-  gem("rubocop", "~> 1.75", require: false)
+  gem("rake", "~> 13.3")
+  gem("rubocop", "~> 1.76", require: false)
   gem("rubocop-shopify", require: false)
   gem("rubocop-sorbet", require: false)
   gem("sorbet", ">= 0.5.9204", require: false)

data/lib/rbi/index.rb

@@ -3,8 +3,6 @@
 
 module RBI
   class Index < Visitor
-    include T::Enumerable
-
     class << self
       #: (*Node node) -> Index
       def index(*node)
@@ -67,17 +65,14 @@ module RBI
   end
 
   # A Node that can be referred to by a unique ID inside an index
+  # @interface
   module Indexable
-    extend T::Sig
-    extend T::Helpers
-
-    interface!
-
     # Unique IDs that refer to this node.
     #
     # Some nodes can have multiple ids, for example an attribute accessor matches the ID of the
     # getter and the setter.
-    sig { abstract.returns(T::Array[String]) }
+    # @abstract
+    #: -> Array[String]
     def index_ids; end
   end
 

data/lib/rbi/loc.rb

@@ -31,6 +31,17 @@ module RBI
       @end_column = end_column
     end
 
+    #: (Loc) -> Loc
+    def join(other)
+      Loc.new(
+        file: file,
+        begin_line: begin_line,
+        begin_column: begin_column,
+        end_line: other.end_line,
+        end_column: other.end_column,
+      )
+    end
+
     #: -> String
     def to_s
       if end_line && end_column

data/lib/rbi/model.rb

@@ -4,11 +4,8 @@
 module RBI
   class ReplaceNodeError < Error; end
 
+  # @abstract
   class Node
-    extend T::Helpers
-
-    abstract!
-
     #: Tree?
     attr_accessor :parent_tree
 
@@ -87,11 +84,8 @@ module RBI
     end
   end
 
+  # @abstract
   class NodeWithComments < Node
-    extend T::Helpers
-
-    abstract!
-
     #: Array[Comment]
     attr_accessor :comments
 
@@ -165,13 +159,10 @@ module RBI
 
   # Scopes
 
+  # @abstract
   class Scope < Tree
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
-    sig { abstract.returns(String) }
+    # @abstract
+    #: -> String
     def fully_qualified_name; end
 
     # @override
@@ -297,12 +288,8 @@ module RBI
 
   # Attributes
 
+  # @abstract
   class Attr < NodeWithComments
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     #: Array[Symbol]
     attr_reader :names
 
@@ -320,7 +307,8 @@ module RBI
       @sigs = sigs
     end
 
-    sig { abstract.returns(T::Array[String]) }
+    # @abstract
+    #: -> Array[String]
     def fully_qualified_names; end
   end
 
@@ -510,11 +498,8 @@ module RBI
     end
   end
 
+  # @abstract
   class Param < NodeWithComments
-    extend T::Helpers
-
-    abstract!
-
     #: String
     attr_reader :name
 
@@ -662,11 +647,8 @@ module RBI
 
   # Mixins
 
+  # @abstract
   class Mixin < NodeWithComments
-    extend T::Helpers
-
-    abstract!
-
     #: Array[String]
     attr_reader :names
 
@@ -707,11 +689,8 @@ module RBI
 
   # Visibility
 
+  # @abstract
   class Visibility < NodeWithComments
-    extend T::Helpers
-
-    abstract!
-
     #: Symbol
     attr_reader :visibility
 
@@ -942,12 +921,8 @@ module RBI
     end
   end
 
+  # @abstract
   class TStructField < NodeWithComments
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     #: String
     attr_accessor :name
 
@@ -965,7 +940,8 @@ module RBI
       @default = default
     end
 
-    sig { abstract.returns(T::Array[String]) }
+    # @abstract
+    #: -> Array[String]
     def fully_qualified_names; end
   end
 

data/lib/rbi/parser.rb

@@ -380,7 +380,7 @@ module RBI
           comments = detach_comments_from_sigs(sigs) + node_comments(node)
 
           current_scope << AttrReader.new(
-            *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
+            *args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym },
             sigs: sigs,
             loc: node_loc(node),
             comments: comments,
@@ -397,7 +397,7 @@ module RBI
           comments = detach_comments_from_sigs(sigs) + node_comments(node)
 
           current_scope << AttrWriter.new(
-            *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
+            *args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym },
             sigs: sigs,
             loc: node_loc(node),
             comments: comments,
@@ -414,7 +414,7 @@ module RBI
           comments = detach_comments_from_sigs(sigs) + node_comments(node)
 
           current_scope << AttrAccessor.new(
-            *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
+            *args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym },
             sigs: sigs,
             loc: node_loc(node),
             comments: comments,
@@ -443,7 +443,7 @@ module RBI
           end
 
           current_scope << Extend.new(
-            *T.unsafe(args.arguments.map { |arg| node_string!(arg) }),
+            *args.arguments.map { |arg| node_string!(arg) },
             loc: node_loc(node),
             comments: node_comments(node),
           )
@@ -456,7 +456,7 @@ module RBI
           end
 
           current_scope << Include.new(
-            *T.unsafe(args.arguments.map { |arg| node_string!(arg) }),
+            *args.arguments.map { |arg| node_string!(arg) },
             loc: node_loc(node),
             comments: node_comments(node),
           )
@@ -469,7 +469,7 @@ module RBI
           end
 
           current_scope << MixesInClassMethods.new(
-            *T.unsafe(args.arguments.map { |arg| node_string!(arg) }),
+            *args.arguments.map { |arg| node_string!(arg) },
             loc: node_loc(node),
             comments: node_comments(node),
           )
@@ -607,28 +607,66 @@ module RBI
         start_line = node.location.start_line
         start_line -= 1 unless @comments_by_line.key?(start_line)
 
+        rbs_continuation = [] #: Array[Prism::Comment]
+
         start_line.downto(1) do |line|
           comment = @comments_by_line[line]
           break unless comment
 
-          comments.unshift(parse_comment(comment))
+          text = comment.location.slice
+
+          # If we find a RBS comment continuation `#|`, we store it until we find the start with `#:`
+          if text.start_with?("#|")
+            rbs_continuation << comment
+            @comments_by_line.delete(line)
+            next
+          end
+
+          loc = Loc.from_prism(@file, comment.location)
+
+          # If we find the start of a RBS comment, we create a new RBSComment
+          # Note that we ignore RDoc directives such as `:nodoc:`
+          # See https://ruby.github.io/rdoc/RDoc/MarkupReference.html#class-RDoc::MarkupReference-label-Directives
+          if text.start_with?("#:") && !(text =~ /^#:[a-z_]+:/)
+            text = text.sub(/^#: ?/, "").rstrip
+
+            # If we found continuation comments, we merge them in reverse order (since we go from bottom to top)
+            rbs_continuation.reverse_each do |rbs_comment|
+              continuation_text = rbs_comment.location.slice.sub(/^#\| ?/, "").strip
+              continuation_loc = Loc.from_prism(@file, rbs_comment.location)
+              loc = loc.join(continuation_loc)
+              text = "#{text}#{continuation_text}"
+            end
+
+            rbs_continuation.clear
+            comments.unshift(RBSComment.new(text, loc: loc))
+          else
+            # If we have unused continuation comments, we should inject them back to not lose them
+            rbs_continuation.each do |rbs_comment|
+              comments.unshift(parse_comment(rbs_comment))
+            end
+
+            rbs_continuation.clear
+            comments.unshift(parse_comment(comment))
+          end
+
           @comments_by_line.delete(line)
         end
 
+        # If we have unused continuation comments, we should inject them back to not lose them
+        rbs_continuation.each do |rbs_comment|
+          comments.unshift(parse_comment(rbs_comment))
+        end
+        rbs_continuation.clear
+
         comments
       end
 
       #: (Prism::Comment node) -> Comment
       def parse_comment(node)
+        text = node.location.slice.sub(/^# ?/, "").rstrip
         loc = Loc.from_prism(@file, node.location)
-        string = node.location.slice
-        # We also ignore RDoc directives such as `:nodoc:`
-        # See https://ruby.github.io/rdoc/RDoc/MarkupReference.html#class-RDoc::MarkupReference-label-Directives
-        if string.start_with?("#:") && !(string =~ /^#:[a-z_]+:/)
-          RBSComment.new(string.gsub(/^#: ?/, "").rstrip, loc: loc)
-        else
-          Comment.new(string.gsub(/^# ?/, "").rstrip, loc: loc)
-        end
+        Comment.new(text, loc: loc)
       end
 
       #: (Prism::Node? node) -> Array[Arg]
@@ -659,76 +697,68 @@ module RBI
 
       #: (Prism::Node? node) -> Array[Param]
       def parse_params(node)
-        params = []
-        return params unless node.is_a?(Prism::ParametersNode)
-
-        node.requireds.each do |param|
-          next unless param.is_a?(Prism::RequiredParameterNode)
-
-          params << ReqParam.new(
-            param.name.to_s,
-            loc: node_loc(param),
-            comments: node_comments(param),
-          )
-        end
-
-        node.optionals.each do |param|
-          next unless param.is_a?(Prism::OptionalParameterNode)
-
-          params << OptParam.new(
-            param.name.to_s,
-            node_string!(param.value),
-            loc: node_loc(param),
-            comments: node_comments(param),
-          )
-        end
-
-        rest = node.rest
-        if rest.is_a?(Prism::RestParameterNode)
-          params << RestParam.new(
-            rest.name&.to_s || "*args",
-            loc: node_loc(rest),
-            comments: node_comments(rest),
-          )
-        end
-
-        node.keywords.each do |param|
+        return [] unless node.is_a?(Prism::ParametersNode)
+
+        node_params = [
+          *node.requireds,
+          *node.optionals,
+          *node.rest,
+          *node.posts,
+          *node.keywords,
+          *node.keyword_rest,
+          *node.block,
+        ].flatten
+
+        node_params.map do |param|
           case param
+          when Prism::RequiredParameterNode
+            ReqParam.new(
+              param.name.to_s,
+              loc: node_loc(param),
+              comments: node_comments(param),
+            )
+          when Prism::OptionalParameterNode
+            OptParam.new(
+              param.name.to_s,
+              node_string!(param.value),
+              loc: node_loc(param),
+              comments: node_comments(param),
+            )
+          when Prism::RestParameterNode
+            RestParam.new(
+              param.name&.to_s || "*args",
+              loc: node_loc(param),
+              comments: node_comments(param),
+            )
           when Prism::RequiredKeywordParameterNode
-            params << KwParam.new(
+            KwParam.new(
               param.name.to_s.delete_suffix(":"),
               loc: node_loc(param),
               comments: node_comments(param),
             )
           when Prism::OptionalKeywordParameterNode
-            params << KwOptParam.new(
+            KwOptParam.new(
               param.name.to_s.delete_suffix(":"),
               node_string!(param.value),
               loc: node_loc(param),
               comments: node_comments(param),
             )
+          when Prism::KeywordRestParameterNode
+            KwRestParam.new(
+              param.name&.to_s || "**kwargs",
+              loc: node_loc(param),
+              comments: node_comments(param),
+            )
+          when Prism::BlockParameterNode
+            BlockParam.new(
+              param.name&.to_s || "&block",
+              loc: node_loc(param),
+              comments: node_comments(param),
+            )
+          else
+            raise ParseError.new("Unexpected parameter node `#{param.class}`", node_loc(param))
           end
         end
-
-        rest_kw = node.keyword_rest
-        if rest_kw.is_a?(Prism::KeywordRestParameterNode)
-          params << KwRestParam.new(
-            rest_kw.name&.to_s || "**kwargs",
-            loc: node_loc(rest_kw),
-            comments: node_comments(rest_kw),
-          )
-        end
-
-        block = node.block
-        if block.is_a?(Prism::BlockParameterNode)
-          params << BlockParam.new(
-            block.name&.to_s || "&block",
-            loc: node_loc(block),
-            comments: node_comments(block),
-          )
-        end
-
-        params
       end
 
       #: (Prism::CallNode node) -> Sig

data/lib/rbi/rbs/type_translator.rb

@@ -5,35 +5,31 @@ module RBI
   module RBS
     class TypeTranslator
       class << self
-        NodeType = T.type_alias do
-          T.any(
-            ::RBS::Types::Alias,
-            ::RBS::Types::Bases::Any,
-            ::RBS::Types::Bases::Bool,
-            ::RBS::Types::Bases::Bottom,
-            ::RBS::Types::Bases::Class,
-            ::RBS::Types::Bases::Instance,
-            ::RBS::Types::Bases::Nil,
-            ::RBS::Types::Bases::Self,
-            ::RBS::Types::Bases::Top,
-            ::RBS::Types::Bases::Void,
-            ::RBS::Types::ClassSingleton,
-            ::RBS::Types::ClassInstance,
-            ::RBS::Types::Function,
-            ::RBS::Types::Interface,
-            ::RBS::Types::Intersection,
-            ::RBS::Types::Literal,
-            ::RBS::Types::Optional,
-            ::RBS::Types::Proc,
-            ::RBS::Types::Record,
-            ::RBS::Types::Tuple,
-            ::RBS::Types::Union,
-            ::RBS::Types::UntypedFunction,
-            ::RBS::Types::Variable,
-          )
-        end
-
-        #: (NodeType) -> Type
+        #: (
+        #|   ::RBS::Types::Alias |
+        #|   ::RBS::Types::Bases::Any |
+        #|   ::RBS::Types::Bases::Bool |
+        #|   ::RBS::Types::Bases::Bottom |
+        #|   ::RBS::Types::Bases::Class |
+        #|   ::RBS::Types::Bases::Instance |
+        #|   ::RBS::Types::Bases::Nil |
+        #|   ::RBS::Types::Bases::Self |
+        #|   ::RBS::Types::Bases::Top |
+        #|   ::RBS::Types::Bases::Void |
+        #|   ::RBS::Types::ClassSingleton |
+        #|   ::RBS::Types::ClassInstance |
+        #|   ::RBS::Types::Function |
+        #|   ::RBS::Types::Interface |
+        #|   ::RBS::Types::Intersection |
+        #|   ::RBS::Types::Literal |
+        #|   ::RBS::Types::Optional |
+        #|   ::RBS::Types::Proc |
+        #|   ::RBS::Types::Record |
+        #|   ::RBS::Types::Tuple |
+        #|   ::RBS::Types::Union |
+        #|   ::RBS::Types::UntypedFunction |
+        #|   ::RBS::Types::Variable
+        #| ) -> Type
         def translate(type)
           case type
           when ::RBS::Types::Alias
@@ -100,7 +96,7 @@ module RBI
           return Type.simple(type.name.to_s) if type.args.empty?
 
           type_name = translate_t_generic_type(type.name.to_s)
-          T.unsafe(Type).generic(type_name, *type.args.map { |arg| translate(arg) })
+          Type.generic(type_name, *type.args.map { |arg| translate(arg) })
         end
 
         #: (::RBS::Types::Function) -> Type

data/lib/rbi/rbs_printer.rb

@@ -17,8 +17,17 @@ module RBI
     #: 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)
+    #: Integer?
+    attr_reader :max_line_length
+
+    #: (
+    #|   ?out: (IO | StringIO),
+    #|   ?indent: Integer,
+    #|   ?print_locs: bool,
+    #|   ?positional_names: bool,
+    #|   ?max_line_length: Integer?
+    #| ) -> void
+    def initialize(out: $stdout, indent: 0, print_locs: false, positional_names: true, max_line_length: nil)
       super()
       @out = out
       @current_indent = indent
@@ -26,6 +35,7 @@ module RBI
       @in_visibility_group = false #: bool
       @previous_node = nil #: Node?
       @positional_names = positional_names #: bool
+      @max_line_length = max_line_length #: Integer?
     end
 
     # Printing
@@ -386,6 +396,23 @@ module RBI
 
     #: (RBI::Method node, Sig sig) -> void
     def print_method_sig(node, sig)
+      old_out = @out
+      new_out = StringIO.new
+
+      @out = new_out
+      print_method_sig_inline(node, sig)
+      @out = old_out
+
+      max_line_length = @max_line_length
+      if max_line_length.nil? || new_out.string.size <= max_line_length
+        print(new_out.string)
+      else
+        print_method_sig_multiline(node, sig)
+      end
+    end
+
+    #: (RBI::Method node, Sig sig) -> void
+    def print_method_sig_inline(node, sig)
       unless sig.type_params.empty?
         print("[#{sig.type_params.join(", ")}] ")
       end
@@ -446,6 +473,72 @@ 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
+
+      block_param = node.params.find { |param| param.is_a?(BlockParam) }
+      sig_block_param = sig.params.find { |param| param.name == block_param&.name }
+
+      sig_params = sig.params.dup
+      if block_param
+        sig_params.reject! do |param|
+          param.name == block_param.name
+        end
+      end
+
+      unless sig_params.empty?
+        printl("(")
+        indent
+        sig_params.each_with_index do |param, index|
+          printt
+          print_sig_param(node, param)
+          print(",") if index < sig_params.size - 1
+          printn
+        end
+        dedent
+        printt(") ")
+      end
+      if sig_block_param
+        block_type = sig_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
+      end
+
+      type = parse_type(sig.return_type)
+      print("-> #{type.rbs_string}")
+
+      loc = sig.loc
+      print(" # #{loc}") if loc && print_locs
+    end
+
     #: (Sig node) -> void
     def visit_sig(node)
       if node.params
@@ -856,7 +949,7 @@ module RBI
     def parse_type(type)
       return type if type.is_a?(Type)
 
-      Type.parse_string(type)
+      Type.parse_string(type).simplify
     rescue Type::Error => e
       raise Error, "Failed to parse type `#{type}` (#{e.message})"
     end
@@ -890,9 +983,10 @@ module RBI
     #: String
     attr_reader :string
 
-    #: -> void
-    def initialize
+    #: (?max_line_length: Integer?) -> void
+    def initialize(max_line_length: nil)
       @string = String.new #: String
+      @max_line_length = max_line_length
     end
 
     #: (Type node) -> void

data/lib/rbi/rewriters/attr_to_methods.rb

@@ -54,7 +54,8 @@ module RBI
   end
 
   class Attr
-    sig { abstract.returns(T::Array[Method]) }
+    # @abstract
+    #: -> Array[Method]
     def convert_to_methods; end
 
     private