prism 2.0.0.rc1-x86_64-linux-gnu → 2.0.0-x86_64-linux-gnu

data/rbi/generated/prism/parse_result.rbi

@@ -23,8 +23,11 @@ module Prism
     # lists described by the attributes of the same names. They are passed in
     # empty when the source is created by the parser and filled in afterward,
     # because the comments themselves refer to the source.
-    sig { params(source: String, start_line: Integer, offsets: T::Array[Integer], comments: T::Array[Comment], comment_attachments: T::Array[Comment], comment_ranges: T::Array[::T.nilable(Integer)]).returns(Source) }
-    def self.for(source, start_line, offsets, comments = T.unsafe(nil), comment_attachments = T.unsafe(nil), comment_ranges = T.unsafe(nil)); end
+    #
+    # The checksum parameter is the value described by the attribute of the same
+    # name. It is nil when the source is not created by the parser.
+    sig { params(source: String, start_line: Integer, offsets: T::Array[Integer], comments: T::Array[Comment], comment_attachments: T::Array[Comment], comment_ranges: T::Array[::T.nilable(Integer)], checksum: ::T.nilable(Integer)).returns(Source) }
+    def self.for(source, start_line, offsets, comments = T.unsafe(nil), comment_attachments = T.unsafe(nil), comment_ranges = T.unsafe(nil), checksum = T.unsafe(nil)); end
 
     # The source code that this source object represents.
     sig { returns(String) }
@@ -34,6 +37,11 @@ module Prism
     sig { returns(Integer) }
     attr_reader :start_line
 
+    # The checksum of the source code which can be used to quickly determine if
+    # the source has changed.
+    sig { returns(::T.nilable(Integer)) }
+    attr_reader :checksum
+
     # The list of comments that were encountered during parsing. When the source
     # is parsed with the attach_comments option, these are sorted by start
     # offset.
@@ -62,13 +70,17 @@ module Prism
     # Create a new source object with the given source code. The offsets
     # parameter can be either an Array of Integer byte offsets or a packed
     # binary string of uint32_t values (from the C extension).
-    sig { params(source: String, start_line: Integer, offsets: ::T.any(T::Array[Integer], String), comments: T::Array[Comment], comment_attachments: T::Array[Comment], comment_ranges: T::Array[::T.nilable(Integer)]).void }
-    def initialize(source, start_line, offsets, comments = T.unsafe(nil), comment_attachments = T.unsafe(nil), comment_ranges = T.unsafe(nil)); end
+    sig { params(source: String, start_line: Integer, offsets: ::T.any(T::Array[Integer], String), comments: T::Array[Comment], comment_attachments: T::Array[Comment], comment_ranges: T::Array[::T.nilable(Integer)], checksum: ::T.nilable(Integer)).void }
+    def initialize(source, start_line, offsets, comments = T.unsafe(nil), comment_attachments = T.unsafe(nil), comment_ranges = T.unsafe(nil), checksum = T.unsafe(nil)); end
 
     # Replace the value of start_line with the given value.
     sig { params(start_line: Integer).void }
     def replace_start_line(start_line); end
 
+    # Replace the value of checksum with the given value.
+    sig { params(checksum: Integer).void }
+    def replace_checksum(checksum); end
+
     # Replace the value of offsets with the given value.
     sig { params(offsets: T::Array[Integer]).void }
     def replace_offsets(offsets); end

data/rbi/generated/prism/serialize.rbi

@@ -138,8 +138,8 @@ module Prism
       sig { returns(Integer) }
       def load_uint32; end
 
-      sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean).returns(::T.nilable(Node)) }
-      def load_optional_node(constant_pool, encoding, freeze); end
+      sig { returns(Integer) }
+      def load_uint64; end
 
       sig { params(encoding: Encoding).returns(String) }
       def load_string(encoding); end
@@ -168,8 +168,12 @@ module Prism
       sig { params(constant_pool: ConstantPool, encoding: Encoding).returns(::T.nilable(Symbol)) }
       def load_optional_constant(constant_pool, encoding); end
 
-      sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean).returns(Node) }
-      def load_node(constant_pool, encoding, freeze); end
+      # Load the nodes that are serialized before the given offset and return
+      # the root. Nodes are serialized in post-order, so the children of each
+      # node are the topmost values on the stack, in field order, by the time
+      # its record is read.
+      sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean, finish: Integer).returns(Node) }
+      def load_nodes(constant_pool, encoding, freeze, finish); end
 
       sig { void }
       def define_load_node_lambdas; end

data/rbi/generated/prism/string_query.rbi

@@ -13,6 +13,9 @@ module Prism
     sig { params(string: String).returns(T::Boolean) }
     def self.method_name?(string); end
 
+    sig { params(string: String).returns(T::Boolean) }
+    def self.keyword?(string); end
+
     # The string that this query is wrapping.
     sig { returns(String) }
     attr_reader :string
@@ -32,5 +35,9 @@ module Prism
     # Whether or not this string is a valid method name.
     sig { returns(T::Boolean) }
     def method_name?; end
+
+    # Whether or not this string is a valid keyword.
+    sig { returns(T::Boolean) }
+    def keyword?; end
   end
 end