rbi 0.3.2 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c1564f6fad1d76035f6cd07bf31237251e6c622350aa4911797980b3a17414
-  data.tar.gz: 1d1350fa25cf2dad93c59e74288372701bfe73c6214d46e279350a953269786d
+  metadata.gz: a8a42ab1d61b3ca13faf2257a62127bb43088d92aec433711820f68333c1a550
+  data.tar.gz: 86fc4e3e2ad745b719272569426d667195a241ecbfd3aa42703e29819bd23d75
 SHA512:
-  metadata.gz: a273b8f7e57c8471e8a9d46f71c7b554e2416243e7ef1c953137720543f7dd70f4166b0c916e327dcb9cf516e0668deaf56027ade2c36485f9fce10cfedb9d9d
-  data.tar.gz: e03adcd232b2557c68d6a18a62c0e0b1977e8f4cccb3a8718f711ae2ec35ded301026021a7d39829da51286348089cdde3593d0b3bb1703da8d69a86af6364c5
+  metadata.gz: 9c668f46c96e059154b09afe9e1e33efc8135d5bf8a92debb63a1378a6362004b86fa29df097a1e64fd1db60d7ee243f4560a3ee878f4c40d7aceccfc55755a1
+  data.tar.gz: 1d7248cfa39b703ecd02c444013148b2208dcc560d49f470024a6f718687e4ec7ef336c1cd1fd6161d8e54fc80d1d39484af39076dac82dacb6577eccb9b7965

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
 
@@ -853,7 +832,7 @@ module RBI
     attr_accessor :return_type
 
     #: bool
-    attr_accessor :is_abstract, :is_override, :is_overridable, :is_final, :allow_incompatible_override
+    attr_accessor :is_abstract, :is_override, :is_overridable, :is_final, :allow_incompatible_override, :without_runtime
 
     #: Array[String]
     attr_reader :type_params
@@ -861,7 +840,7 @@ module RBI
     #: Symbol?
     attr_accessor :checked
 
-    #: (?params: Array[SigParam], ?return_type: (Type | String), ?is_abstract: bool, ?is_override: bool, ?is_overridable: bool, ?is_final: bool, ?allow_incompatible_override: bool, ?type_params: Array[String], ?checked: Symbol?, ?loc: Loc?, ?comments: Array[Comment]) ?{ (Sig node) -> void } -> void
+    #: (?params: Array[SigParam], ?return_type: (Type | String), ?is_abstract: bool, ?is_override: bool, ?is_overridable: bool, ?is_final: bool, ?allow_incompatible_override: bool, ?without_runtime: bool, ?type_params: Array[String], ?checked: Symbol?, ?loc: Loc?, ?comments: Array[Comment]) ?{ (Sig node) -> void } -> void
     def initialize(
       params: [],
       return_type: "void",
@@ -870,6 +849,7 @@ module RBI
       is_overridable: false,
       is_final: false,
       allow_incompatible_override: false,
+      without_runtime: false,
       type_params: [],
       checked: nil,
       loc: nil,
@@ -884,6 +864,7 @@ module RBI
       @is_overridable = is_overridable
       @is_final = is_final
       @allow_incompatible_override = allow_incompatible_override
+      @without_runtime = without_runtime
       @type_params = type_params
       @checked = checked
       block&.call(self)
@@ -905,7 +886,7 @@ module RBI
 
       params == other.params && return_type.to_s == other.return_type.to_s && is_abstract == other.is_abstract &&
         is_override == other.is_override && is_overridable == other.is_overridable && is_final == other.is_final &&
-        type_params == other.type_params && checked == other.checked
+        without_runtime == other.without_runtime && type_params == other.type_params && checked == other.checked
     end
   end
 
@@ -940,12 +921,8 @@ module RBI
     end
   end
 
+  # @abstract
   class TStructField < NodeWithComments
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     #: String
     attr_accessor :name
 
@@ -963,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

@@ -149,6 +149,16 @@ module RBI
         visitor.visit(node)
         visitor.location
       end
+
+      #: (Prism::Node? node) -> bool
+      def self?(node)
+        node.is_a?(Prism::SelfNode)
+      end
+
+      #: (Prism::Node? node) -> bool
+      def t_sig_without_runtime?(node)
+        !!(node.is_a?(Prism::ConstantPathNode) && node_string(node) =~ /(::)?T::Sig::WithoutRuntime/)
+      end
     end
 
     class TreeBuilder < Visitor
@@ -370,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,
@@ -387,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,
@@ -404,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,
@@ -433,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),
           )
@@ -446,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),
           )
@@ -459,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),
           )
@@ -505,6 +515,10 @@ module RBI
             comments: node_comments(node),
           )
         when "sig"
+          unless node.receiver.nil? || self?(node.receiver) || t_sig_without_runtime?(node.receiver)
+            @last_node = nil
+            return
+          end
           @last_sigs << parse_sig(node)
         else
           current_scope << Send.new(
@@ -593,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]
@@ -645,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
@@ -884,6 +928,8 @@ module RBI
       def visit_call_node(node)
         case node.message
         when "sig"
+          @current.without_runtime = t_sig_without_runtime?(node.receiver)
+
           args = node.arguments
           if args.is_a?(Prism::ArgumentsNode)
             args.arguments.each do |arg|
@@ -961,6 +1007,7 @@ module RBI
         @offset_last_newline = false #: bool
       end
 
+      # @override
       #: (Prism::StringNode node) -> void
       def visit_string_node(node)
         return unless node.heredoc?
@@ -971,6 +1018,7 @@ module RBI
         handle_string_node(node)
       end
 
+      # @override
       #: (Prism::InterpolatedStringNode node) -> void
       def visit_interpolated_string_node(node)
         return super unless node.heredoc?

data/lib/rbi/printer.rb

@@ -707,7 +707,9 @@ module RBI
 
     #: (Sig node) -> void
     def print_sig_as_line(node)
-      printt("sig")
+      printt
+      print("T::Sig::WithoutRuntime.") if node.without_runtime
+      print("sig")
       print("(:final)") if node.is_final
       print(" { ")
       sig_modifiers(node).each do |modifier|
@@ -734,7 +736,9 @@ module RBI
     def print_sig_as_block(node)
       modifiers = sig_modifiers(node)
 
-      printt("sig")
+      printt
+      print("T::Sig::WithoutRuntime.") if node.without_runtime
+      print("sig")
       print("(:final)") if node.is_final
       printn(" do")
       indent

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