rbi 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a2cb2f6b2287a3faed50161d70e0c863892c88c6eef5a3c798ccf8e16e0c441
-  data.tar.gz: e851f3b85aa62534a3a1c867085add40aa7669df3b003f17e62eb81ce36c58ed
+  metadata.gz: 3adefb9fc887432fdab8f11a5800c58fe0c4b7a089c1170d67fc5fa6374c475d
+  data.tar.gz: 5259d5132a2b83761a22419c10fca4beff9bb95e2e60c779c3e7b5583230476d
 SHA512:
-  metadata.gz: b566ecfc9c01ebf7524efb055302e3da780caf0e0cc3ab36bdca798ff8390cce5247bce1318c5373c8339fede498f3bc87ffd5071ace658880c0b3724a9f1d15
-  data.tar.gz: d95c6b6ea53cf84c348b2426b9bf10ad8213282f48ec9364cb9b1512aef9dd4c896d18c09c1dac79abe40f136194ab550571ac141e960eab61e4026bdbf3c578
+  metadata.gz: cb345c63c449eb4610d826b3a9a2e6da4633ac7f29ceaf0b46af689f956d5a6758939d02b6234f676c6f7ce6f49ccf119e4a6237946e87cd9a7d13b57f014f82
+  data.tar.gz: 674a6fe4acf7b92ea718ed12c0906d5d1b8a1e1942869e0c163060fd107d227a65e0eb58460d694f22c48f3809c37739033a3b806551676ac136fedc360b0750

data/lib/rbi/loc.rb

@@ -8,14 +8,14 @@ module RBI
     class << self
       extend T::Sig
 
-      sig { params(file: String, yarp_location: YARP::Location).returns(Loc) }
-      def from_yarp(file, yarp_location)
+      sig { params(file: String, prism_location: Prism::Location).returns(Loc) }
+      def from_prism(file, prism_location)
         new(
           file: file,
-          begin_line: yarp_location.start_line,
-          end_line: yarp_location.end_line,
-          begin_column: yarp_location.start_column,
-          end_column: yarp_location.end_column + 1, # TODO: Why is this off by one?
+          begin_line: prism_location.start_line,
+          end_line: prism_location.end_line,
+          begin_column: prism_location.start_column,
+          end_column: prism_location.end_column,
         )
       end
     end
@@ -45,7 +45,11 @@ module RBI
 
     sig { returns(String) }
     def to_s
-      "#{file}:#{begin_line}:#{begin_column}-#{end_line}:#{end_column}"
+      if end_line && end_column
+        "#{file}:#{begin_line}:#{begin_column}-#{end_line}:#{end_column}"
+      else
+        "#{file}:#{begin_line}:#{begin_column}"
+      end
     end
 
     sig { returns(T.nilable(String)) }

data/lib/rbi/model.rb

@@ -353,7 +353,7 @@ module RBI
     abstract!
 
     sig { returns(T::Array[Symbol]) }
-    attr_accessor :names
+    attr_reader :names
 
     sig { returns(Visibility) }
     attr_accessor :visibility
@@ -774,7 +774,7 @@ module RBI
     abstract!
 
     sig { returns(T::Array[String]) }
-    attr_accessor :names
+    attr_reader :names
 
     sig do
       params(

data/lib/rbi/parser.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "yarp"
+require "prism"
 
 module RBI
   class ParseError < StandardError
@@ -93,22 +93,23 @@ module RBI
 
     sig { params(source: String, file: String).returns(Tree) }
     def parse(source, file:)
-      result = YARP.parse(source)
+      result = Prism.parse(source)
       unless result.success?
-        raise ParseError.new(result.errors.map(&:message).join(" "), Loc.from_yarp(file, result.errors.first.location))
+        message = result.errors.map { |e| "#{e.message}." }.join(" ")
+        error = result.errors.first
+        location = Loc.new(file: file, begin_line: error.location.start_line, begin_column: error.location.start_column)
+        raise ParseError.new(message, location)
       end
 
       visitor = TreeBuilder.new(source, comments: result.comments, file: file)
       visitor.visit(result.value)
       visitor.tree
-    rescue YARP::ParseError => e
-      raise ParseError.new(e.message, Loc.from_yarp(file, e.location))
     rescue ParseError => e
       raise e
     rescue => e
       last_node = visitor&.last_node
       last_location = if last_node
-        Loc.from_yarp(file, last_node.location)
+        Loc.from_prism(file, last_node.location)
       else
         Loc.new(file: file)
       end
@@ -118,7 +119,7 @@ module RBI
       raise exception
     end
 
-    class Visitor < YARP::Visitor
+    class Visitor < Prism::Visitor
       extend T::Sig
 
       sig { params(source: String, file: String).void }
@@ -131,19 +132,19 @@ module RBI
 
       private
 
-      sig { params(node: YARP::Node).returns(Loc) }
+      sig { params(node: Prism::Node).returns(Loc) }
       def node_loc(node)
-        Loc.from_yarp(@file, node.location)
+        Loc.from_prism(@file, node.location)
       end
 
-      sig { params(node: T.nilable(YARP::Node)).returns(T.nilable(String)) }
+      sig { params(node: T.nilable(Prism::Node)).returns(T.nilable(String)) }
       def node_string(node)
         return unless node
 
         node.slice
       end
 
-      sig { params(node: YARP::Node).returns(String) }
+      sig { params(node: Prism::Node).returns(String) }
       def node_string!(node)
         T.must(node_string(node))
       end
@@ -155,32 +156,25 @@ module RBI
       sig { returns(Tree) }
       attr_reader :tree
 
-      sig { returns(T.nilable(YARP::Node)) }
+      sig { returns(T.nilable(Prism::Node)) }
       attr_reader :last_node
 
-      sig { params(source: String, comments: T::Array[YARP::Comment], file: String).void }
+      sig { params(source: String, comments: T::Array[Prism::Comment], file: String).void }
       def initialize(source, comments:, file:)
         super(source, file: file)
 
-        @comments_by_line = T.let(comments.to_h { |c| [c.location.start_line, c] }, T::Hash[Integer, YARP::Comment])
+        @comments_by_line = T.let(comments.to_h { |c| [c.location.start_line, c] }, T::Hash[Integer, Prism::Comment])
         @tree = T.let(Tree.new, Tree)
 
         @scopes_stack = T.let([@tree], T::Array[Tree])
-        @last_node = T.let(nil, T.nilable(YARP::Node))
+        @last_node = T.let(nil, T.nilable(Prism::Node))
         @last_sigs = T.let([], T::Array[RBI::Sig])
         @last_sigs_comments = T.let([], T::Array[Comment])
       end
 
-      sig { override.params(node: T.nilable(YARP::Node)).void }
-      def visit(node)
-        return unless node
-
-        @last_node = node
-        super
-      end
-
-      sig { override.params(node: YARP::ClassNode).void }
+      sig { override.params(node: Prism::ClassNode).void }
       def visit_class_node(node)
+        @last_node = node
         scope = Class.new(
           node_string!(node.constant_path),
           superclass_name: node_string(node.superclass),
@@ -193,19 +187,24 @@ module RBI
         visit(node.body)
         collect_dangling_comments(node)
         @scopes_stack.pop
+        @last_node = nil
       end
 
-      sig { override.params(node: YARP::ConstantWriteNode).void }
+      sig { override.params(node: Prism::ConstantWriteNode).void }
       def visit_constant_write_node(node)
+        @last_node = node
         visit_constant_assign(node)
+        @last_node = nil
       end
 
-      sig { override.params(node: YARP::ConstantPathWriteNode).void }
+      sig { override.params(node: Prism::ConstantPathWriteNode).void }
       def visit_constant_path_write_node(node)
+        @last_node = node
         visit_constant_assign(node)
+        @last_node = nil
       end
 
-      sig { params(node: T.any(YARP::ConstantWriteNode, YARP::ConstantPathWriteNode)).void }
+      sig { params(node: T.any(Prism::ConstantWriteNode, Prism::ConstantPathWriteNode)).void }
       def visit_constant_assign(node)
         struct = parse_struct(node)
 
@@ -214,9 +213,9 @@ module RBI
         elsif type_variable_definition?(node.value)
           TypeMember.new(
             case node
-            when YARP::ConstantWriteNode
-              node.name
-            when YARP::ConstantPathWriteNode
+            when Prism::ConstantWriteNode
+              node.name.to_s
+            when Prism::ConstantPathWriteNode
               node_string!(node.target)
             end,
             node_string!(node.value),
@@ -226,9 +225,9 @@ module RBI
         else
           Const.new(
             case node
-            when YARP::ConstantWriteNode
-              node.name
-            when YARP::ConstantPathWriteNode
+            when Prism::ConstantWriteNode
+              node.name.to_s
+            when Prism::ConstantPathWriteNode
               node_string!(node.target)
             end,
             node_string!(node.value),
@@ -238,20 +237,23 @@ module RBI
         end
       end
 
-      sig { override.params(node: YARP::DefNode).void }
+      sig { override.params(node: Prism::DefNode).void }
       def visit_def_node(node)
+        @last_node = node
         current_scope << Method.new(
-          node.name,
+          node.name.to_s,
           params: parse_params(node.parameters),
           sigs: current_sigs,
           loc: node_loc(node),
           comments: current_sigs_comments + node_comments(node),
           is_singleton: !!node.receiver,
         )
+        @last_node = nil
       end
 
-      sig { override.params(node: YARP::ModuleNode).void }
+      sig { override.params(node: Prism::ModuleNode).void }
       def visit_module_node(node)
+        @last_node = node
         scope = Module.new(
           node_string!(node.constant_path),
           loc: node_loc(node),
@@ -263,19 +265,23 @@ module RBI
         visit(node.body)
         collect_dangling_comments(node)
         @scopes_stack.pop
+        @last_node = nil
       end
 
-      sig { override.params(node: YARP::ProgramNode).void }
+      sig { override.params(node: Prism::ProgramNode).void }
       def visit_program_node(node)
+        @last_node = node
         super
 
         collect_orphan_comments
         separate_header_comments
         set_root_tree_loc
+        @last_node = nil
       end
 
-      sig { override.params(node: YARP::SingletonClassNode).void }
+      sig { override.params(node: Prism::SingletonClassNode).void }
       def visit_singleton_class_node(node)
+        @last_node = node
         scope = SingletonClass.new(
           loc: node_loc(node),
           comments: node_comments(node),
@@ -286,11 +292,13 @@ module RBI
         visit(node.body)
         collect_dangling_comments(node)
         @scopes_stack.pop
+        @last_node = nil
       end
 
-      sig { params(node: YARP::CallNode).void }
+      sig { params(node: Prism::CallNode).void }
       def visit_call_node(node)
-        message = node.name
+        @last_node = node
+        message = node.name.to_s
         case message
         when "abstract!", "sealed!", "interface!"
           current_scope << Helper.new(
@@ -300,7 +308,11 @@ module RBI
           )
         when "attr_reader"
           args = node.arguments
-          return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any?
+
+          unless args.is_a?(Prism::ArgumentsNode) && args.arguments.any?
+            @last_node = nil
+            return
+          end
 
           current_scope << AttrReader.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
@@ -310,7 +322,11 @@ module RBI
           )
         when "attr_writer"
           args = node.arguments
-          return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any?
+
+          unless args.is_a?(Prism::ArgumentsNode) && args.arguments.any?
+            @last_node = nil
+            return
+          end
 
           current_scope << AttrWriter.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
@@ -320,7 +336,11 @@ module RBI
           )
         when "attr_accessor"
           args = node.arguments
-          return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any?
+
+          unless args.is_a?(Prism::ArgumentsNode) && args.arguments.any?
+            @last_node = nil
+            return
+          end
 
           current_scope << AttrAccessor.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg).delete_prefix(":").to_sym }),
@@ -330,19 +350,31 @@ module RBI
           )
         when "enums"
           block = node.block
-          return unless block.is_a?(YARP::BlockNode)
+
+          unless block.is_a?(Prism::BlockNode)
+            @last_node = nil
+            return
+          end
 
           body = block.body
-          return unless body.is_a?(YARP::StatementsNode)
+
+          unless body.is_a?(Prism::StatementsNode)
+            @last_node = nil
+            return
+          end
 
           current_scope << TEnumBlock.new(
-            body.body.map { |stmt| T.cast(stmt, YARP::ConstantWriteNode).name },
+            body.body.map { |stmt| T.cast(stmt, Prism::ConstantWriteNode).name.to_s },
             loc: node_loc(node),
             comments: node_comments(node),
           )
         when "extend"
           args = node.arguments
-          return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any?
+
+          unless args.is_a?(Prism::ArgumentsNode) && args.arguments.any?
+            @last_node = nil
+            return
+          end
 
           current_scope << Extend.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg) }),
@@ -351,7 +383,11 @@ module RBI
           )
         when "include"
           args = node.arguments
-          return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any?
+
+          unless args.is_a?(Prism::ArgumentsNode) && args.arguments.any?
+            @last_node = nil
+            return
+          end
 
           current_scope << Include.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg) }),
@@ -360,7 +396,11 @@ module RBI
           )
         when "mixes_in_class_methods"
           args = node.arguments
-          return unless args.is_a?(YARP::ArgumentsNode) && args.arguments.any?
+
+          unless args.is_a?(Prism::ArgumentsNode) && args.arguments.any?
+            @last_node = nil
+            return
+          end
 
           current_scope << MixesInClassMethods.new(
             *T.unsafe(args.arguments.map { |arg| node_string!(arg) }),
@@ -369,12 +409,12 @@ module RBI
           )
         when "private", "protected", "public"
           args = node.arguments
-          if args.is_a?(YARP::ArgumentsNode) && args.arguments.any?
+          if args.is_a?(Prism::ArgumentsNode) && args.arguments.any?
             visit(node.arguments)
             last_node = @scopes_stack.last&.nodes&.last
             case last_node
             when Method, Attr
-              last_node.visibility = parse_visibility(node.name, node)
+              last_node.visibility = parse_visibility(node.name.to_s, node)
             else
               raise ParseError.new(
                 "Unexpected token `#{node.message}` before `#{last_node&.string&.strip}`",
@@ -382,16 +422,24 @@ module RBI
               )
             end
           else
-            current_scope << parse_visibility(node.name, node)
+            current_scope << parse_visibility(node.name.to_s, node)
           end
         when "prop", "const"
           parse_tstruct_field(node)
         when "requires_ancestor"
           block = node.block
-          return unless block.is_a?(YARP::BlockNode)
+
+          unless block.is_a?(Prism::BlockNode)
+            @last_node = nil
+            return
+          end
 
           body = block.body
-          return unless body.is_a?(YARP::StatementsNode)
+
+          unless body.is_a?(Prism::StatementsNode)
+            @last_node = nil
+            return
+          end
 
           current_scope << RequiresAncestor.new(
             node_string!(body),
@@ -408,12 +456,14 @@ module RBI
             comments: node_comments(node),
           )
         end
+
+        @last_node = nil
       end
 
       private
 
       # Collect all the remaining comments within a node
-      sig { params(node: YARP::Node).void }
+      sig { params(node: Prism::Node).void }
       def collect_dangling_comments(node)
         first_line = node.location.start_line
         last_line = node.location.end_line
@@ -446,7 +496,7 @@ module RBI
 
           # Preserve blank lines in comments
           if last_line && line > last_line + 1
-            recv << BlankLine.new(loc: Loc.from_yarp(@file, comment.location))
+            recv << BlankLine.new(loc: Loc.from_prism(@file, comment.location))
           end
 
           recv << parse_comment(comment)
@@ -473,7 +523,7 @@ module RBI
         comments
       end
 
-      sig { params(node: YARP::Node).returns(T::Array[Comment]) }
+      sig { params(node: Prism::Node).returns(T::Array[Comment]) }
       def node_comments(node)
         comments = []
 
@@ -491,21 +541,21 @@ module RBI
         comments
       end
 
-      sig { params(node: YARP::Comment).returns(Comment) }
+      sig { params(node: Prism::Comment).returns(Comment) }
       def parse_comment(node)
-        Comment.new(node.location.slice.gsub(/^# ?/, "").rstrip, loc: Loc.from_yarp(@file, node.location))
+        Comment.new(node.location.slice.gsub(/^# ?/, "").rstrip, loc: Loc.from_prism(@file, node.location))
       end
 
-      sig { params(node: T.nilable(YARP::Node)).returns(T::Array[Arg]) }
+      sig { params(node: T.nilable(Prism::Node)).returns(T::Array[Arg]) }
       def parse_send_args(node)
         args = T.let([], T::Array[Arg])
-        return args unless node.is_a?(YARP::ArgumentsNode)
+        return args unless node.is_a?(Prism::ArgumentsNode)
 
         node.arguments.each do |arg|
           case arg
-          when YARP::KeywordHashNode
+          when Prism::KeywordHashNode
             arg.elements.each do |assoc|
-              next unless assoc.is_a?(YARP::AssocNode)
+              next unless assoc.is_a?(Prism::AssocNode)
 
               args << KwArg.new(
                 node_string!(assoc.key).delete_suffix(":"),
@@ -520,13 +570,13 @@ module RBI
         args
       end
 
-      sig { params(node: T.nilable(YARP::Node)).returns(T::Array[Param]) }
+      sig { params(node: T.nilable(Prism::Node)).returns(T::Array[Param]) }
       def parse_params(node)
         params = []
-        return params unless node.is_a?(YARP::ParametersNode)
+        return params unless node.is_a?(Prism::ParametersNode)
 
         node.requireds.each do |param|
-          next unless param.is_a?(YARP::RequiredParameterNode)
+          next unless param.is_a?(Prism::RequiredParameterNode)
 
           params << ReqParam.new(
             param.name.to_s,
@@ -536,7 +586,7 @@ module RBI
         end
 
         node.optionals.each do |param|
-          next unless param.is_a?(YARP::OptionalParameterNode)
+          next unless param.is_a?(Prism::OptionalParameterNode)
 
           params << OptParam.new(
             param.name.to_s,
@@ -547,28 +597,28 @@ module RBI
         end
 
         rest = node.rest
-        if rest.is_a?(YARP::RestParameterNode)
+        if rest.is_a?(Prism::RestParameterNode)
           params << RestParam.new(
-            rest.name || "*args",
+            rest.name&.to_s || "*args",
             loc: node_loc(rest),
             comments: node_comments(rest),
           )
         end
 
         node.keywords.each do |param|
-          next unless param.is_a?(YARP::KeywordParameterNode)
+          next unless param.is_a?(Prism::KeywordParameterNode)
 
           value = param.value
           params << if value
             KwOptParam.new(
-              param.name.delete_suffix(":"),
+              param.name.to_s.delete_suffix(":"),
               node_string!(value),
               loc: node_loc(param),
               comments: node_comments(param),
             )
           else
             KwParam.new(
-              param.name.delete_suffix(":"),
+              param.name.to_s.delete_suffix(":"),
               loc: node_loc(param),
               comments: node_comments(param),
             )
@@ -576,18 +626,18 @@ module RBI
         end
 
         rest_kw = node.keyword_rest
-        if rest_kw.is_a?(YARP::KeywordRestParameterNode)
+        if rest_kw.is_a?(Prism::KeywordRestParameterNode)
           params << KwRestParam.new(
-            rest_kw.name || "**kwargs",
+            rest_kw.name&.to_s || "**kwargs",
             loc: node_loc(rest_kw),
             comments: node_comments(rest_kw),
           )
         end
 
         block = node.block
-        if block.is_a?(YARP::BlockParameterNode)
+        if block.is_a?(Prism::BlockParameterNode)
           params << BlockParam.new(
-            block.name || "&block",
+            block.name&.to_s || "&block",
             loc: node_loc(block),
             comments: node_comments(block),
           )
@@ -596,7 +646,7 @@ module RBI
         params
       end
 
-      sig { params(node: YARP::CallNode).returns(Sig) }
+      sig { params(node: Prism::CallNode).returns(Sig) }
       def parse_sig(node)
         @last_sigs_comments = node_comments(node)
 
@@ -606,10 +656,10 @@ module RBI
         builder.current
       end
 
-      sig { params(node: T.any(YARP::ConstantWriteNode, YARP::ConstantPathWriteNode)).returns(T.nilable(Struct)) }
+      sig { params(node: T.any(Prism::ConstantWriteNode, Prism::ConstantPathWriteNode)).returns(T.nilable(Struct)) }
       def parse_struct(node)
         send = node.value
-        return unless send.is_a?(YARP::CallNode)
+        return unless send.is_a?(Prism::CallNode)
         return unless send.message == "new"
 
         recv = send.receiver
@@ -620,14 +670,14 @@ module RBI
         keyword_init = T.let(false, T::Boolean)
 
         args = send.arguments
-        if args.is_a?(YARP::ArgumentsNode)
+        if args.is_a?(Prism::ArgumentsNode)
           args.arguments.each do |arg|
             case arg
-            when YARP::SymbolNode
+            when Prism::SymbolNode
               members << arg.value
-            when YARP::KeywordHashNode
+            when Prism::KeywordHashNode
               arg.elements.each do |assoc|
-                next unless assoc.is_a?(YARP::AssocNode)
+                next unless assoc.is_a?(Prism::AssocNode)
 
                 key = node_string!(assoc.key)
                 val = node_string(assoc.value)
@@ -641,9 +691,9 @@ module RBI
         end
 
         name = case node
-        when YARP::ConstantWriteNode
-          node.name
-        when YARP::ConstantPathWriteNode
+        when Prism::ConstantWriteNode
+          node.name.to_s
+        when Prism::ConstantPathWriteNode
           node_string!(node.target)
         end
 
@@ -656,10 +706,10 @@ module RBI
         struct
       end
 
-      sig { params(send: YARP::CallNode).void }
+      sig { params(send: Prism::CallNode).void }
       def parse_tstruct_field(send)
         args = send.arguments
-        return unless args.is_a?(YARP::ArgumentsNode)
+        return unless args.is_a?(Prism::ArgumentsNode)
 
         name_arg, type_arg, *rest = args.arguments
         return unless name_arg
@@ -672,10 +722,10 @@ module RBI
         default_value = T.let(nil, T.nilable(String))
 
         rest&.each do |arg|
-          next unless arg.is_a?(YARP::KeywordHashNode)
+          next unless arg.is_a?(Prism::KeywordHashNode)
 
           arg.elements.each do |assoc|
-            next unless assoc.is_a?(YARP::AssocNode)
+            next unless assoc.is_a?(Prism::AssocNode)
 
             if node_string(assoc.key) == "default:"
               default_value = node_string(assoc.value)
@@ -693,7 +743,7 @@ module RBI
         end
       end
 
-      sig { params(name: String, node: YARP::Node).returns(Visibility) }
+      sig { params(name: String, node: Prism::Node).returns(Visibility) }
       def parse_visibility(name, node)
         case name
         when "public"
@@ -731,9 +781,9 @@ module RBI
         )
       end
 
-      sig { params(node: T.nilable(YARP::Node)).returns(T::Boolean) }
+      sig { params(node: T.nilable(Prism::Node)).returns(T::Boolean) }
       def type_variable_definition?(node)
-        return false unless node.is_a?(YARP::CallNode)
+        return false unless node.is_a?(Prism::CallNode)
         return false unless node.block
 
         node.message == "type_member" || node.message == "type_template"
@@ -744,7 +794,7 @@ module RBI
       extend T::Sig
 
       sig { returns(Sig) }
-      attr_accessor :current
+      attr_reader :current
 
       sig { params(content: String, file: String).void }
       def initialize(content, file:)
@@ -753,12 +803,12 @@ module RBI
         @current = T.let(Sig.new, Sig)
       end
 
-      sig { override.params(node: YARP::CallNode).void }
+      sig { override.params(node: Prism::CallNode).void }
       def visit_call_node(node)
         case node.message
         when "sig"
           args = node.arguments
-          if args.is_a?(YARP::ArgumentsNode)
+          if args.is_a?(Prism::ArgumentsNode)
             args.arguments.each do |arg|
               @current.is_final = node_string(arg) == ":final"
             end
@@ -767,7 +817,7 @@ module RBI
           @current.is_abstract = true
         when "checked"
           args = node.arguments
-          if args.is_a?(YARP::ArgumentsNode)
+          if args.is_a?(Prism::ArgumentsNode)
             arg = node_string(args.arguments.first)
             @current.checked = arg&.delete_prefix(":")&.to_sym
           end
@@ -779,13 +829,13 @@ module RBI
           visit(node.arguments)
         when "returns"
           args = node.arguments
-          if args.is_a?(YARP::ArgumentsNode)
+          if args.is_a?(Prism::ArgumentsNode)
             first = args.arguments.first
             @current.return_type = node_string!(first) if first
           end
         when "type_parameters"
           args = node.arguments
-          if args.is_a?(YARP::ArgumentsNode)
+          if args.is_a?(Prism::ArgumentsNode)
             args.arguments.each do |arg|
               @current.type_params << node_string!(arg).delete_prefix(":")
             end
@@ -798,7 +848,7 @@ module RBI
         visit(node.block)
       end
 
-      sig { override.params(node: YARP::AssocNode).void }
+      sig { override.params(node: Prism::AssocNode).void }
       def visit_assoc_node(node)
         @current.params << SigParam.new(
           node_string!(node.key).delete_suffix(":"),

data/lib/rbi/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module RBI
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-07 00:00:00.000000000 Z
+date: 2023-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sorbet-runtime
+  name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.15.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.15.1
 - !ruby/object:Gem::Dependency
-  name: yarp
+  name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.5.9204
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.5.9204
 description: 
 email:
 - ruby@shopify.com
@@ -86,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.4.21
 signing_key: 
 specification_version: 4
 summary: RBI generation framework