rbi 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ab48b069bf534228e48c5c76caeb71daca4dd905a00cbdbfdd0ce7ce9374987
-  data.tar.gz: f301b0ce6eff170542931c88095d78ff60ffd5e20720eb04461bdbb3eeb98a8d
+  metadata.gz: 3adefb9fc887432fdab8f11a5800c58fe0c4b7a089c1170d67fc5fa6374c475d
+  data.tar.gz: 5259d5132a2b83761a22419c10fca4beff9bb95e2e60c779c3e7b5583230476d
 SHA512:
-  metadata.gz: d2f844f5e4d6ec819125d1b91bd40e9af9821f32a4ca76036ccabe5beac985dc566d0cc8d9946ed1488c78115d3a64d798833d13256d829c686df1668353e314
-  data.tar.gz: a1bb0eabd7e81e3563e20bfb35eb0bf2044d152c0019ed78018327d6b60c4897b89a94f4fd741f077e7cb5186a82fbd7cf3c08b3340d2f1caa913b2d773adddc
+  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,
+          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

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,7 +93,7 @@ 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?
         message = result.errors.map { |e| "#{e.message}." }.join(" ")
         error = result.errors.first
@@ -104,14 +104,12 @@ module RBI
       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
@@ -121,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 }
@@ -134,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
@@ -158,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),
@@ -196,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)
 
@@ -217,9 +213,9 @@ module RBI
         elsif type_variable_definition?(node.value)
           TypeMember.new(
             case node
-            when YARP::ConstantWriteNode
+            when Prism::ConstantWriteNode
               node.name.to_s
-            when YARP::ConstantPathWriteNode
+            when Prism::ConstantPathWriteNode
               node_string!(node.target)
             end,
             node_string!(node.value),
@@ -229,9 +225,9 @@ module RBI
         else
           Const.new(
             case node
-            when YARP::ConstantWriteNode
+            when Prism::ConstantWriteNode
               node.name.to_s
-            when YARP::ConstantPathWriteNode
+            when Prism::ConstantPathWriteNode
               node_string!(node.target)
             end,
             node_string!(node.value),
@@ -241,8 +237,9 @@ 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.to_s,
           params: parse_params(node.parameters),
@@ -251,10 +248,12 @@ module RBI
           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),
@@ -266,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),
@@ -289,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(
@@ -303,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 }),
@@ -313,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 }),
@@ -323,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 }),
@@ -333,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.to_s },
+            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) }),
@@ -354,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) }),
@@ -363,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) }),
@@ -372,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}`",
@@ -385,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),
@@ -411,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
@@ -449,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)
@@ -476,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 = []
 
@@ -494,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(":"),
@@ -523,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,
@@ -539,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,
@@ -550,7 +597,7 @@ module RBI
         end
 
         rest = node.rest
-        if rest.is_a?(YARP::RestParameterNode)
+        if rest.is_a?(Prism::RestParameterNode)
           params << RestParam.new(
             rest.name&.to_s || "*args",
             loc: node_loc(rest),
@@ -559,7 +606,7 @@ module RBI
         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
@@ -579,7 +626,7 @@ 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&.to_s || "**kwargs",
             loc: node_loc(rest_kw),
@@ -588,7 +635,7 @@ module RBI
         end
 
         block = node.block
-        if block.is_a?(YARP::BlockParameterNode)
+        if block.is_a?(Prism::BlockParameterNode)
           params << BlockParam.new(
             block.name&.to_s || "&block",
             loc: node_loc(block),
@@ -599,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)
 
@@ -609,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
@@ -623,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)
@@ -644,9 +691,9 @@ module RBI
         end
 
         name = case node
-        when YARP::ConstantWriteNode
+        when Prism::ConstantWriteNode
           node.name.to_s
-        when YARP::ConstantPathWriteNode
+        when Prism::ConstantPathWriteNode
           node_string!(node.target)
         end
 
@@ -659,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
@@ -675,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)
@@ -696,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"
@@ -734,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"
@@ -756,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
@@ -770,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
@@ -782,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
@@ -801,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.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-11 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.11.0
+        version: 0.5.9204
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.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