prism 1.2.0 → 1.3.0

data/lib/prism/translation/parser/compiler.rb

@@ -188,7 +188,7 @@ module Prism
                 rescue_clause.exceptions.any? ? builder.array(nil, visit_all(rescue_clause.exceptions), nil) : nil,
                 token(rescue_clause.operator_loc),
                 visit(rescue_clause.reference),
-                srange_find(find_start_offset, find_end_offset, [";"]),
+                srange_find(find_start_offset, find_end_offset, ";"),
                 visit(rescue_clause.statements)
               )
             end until (rescue_clause = rescue_clause.subsequent).nil?
@@ -294,7 +294,7 @@ module Prism
                       visit_all(arguments),
                       token(node.closing_loc),
                     ),
-                    srange_find(node.message_loc.end_offset, node.arguments.arguments.last.location.start_offset, ["="]),
+                    srange_find(node.message_loc.end_offset, node.arguments.arguments.last.location.start_offset, "="),
                     visit(node.arguments.arguments.last)
                   ),
                   block
@@ -311,7 +311,7 @@ module Prism
             if name.end_with?("=") && !message_loc.slice.end_with?("=") && node.arguments && block.nil?
               builder.assign(
                 builder.attr_asgn(visit(node.receiver), call_operator, token(message_loc)),
-                srange_find(message_loc.end_offset, node.arguments.location.start_offset, ["="]),
+                srange_find(message_loc.end_offset, node.arguments.location.start_offset, "="),
                 visit(node.arguments.arguments.last)
               )
             else
@@ -733,10 +733,10 @@ module Prism
             visit(node.index),
             token(node.in_keyword_loc),
             visit(node.collection),
-            if node.do_keyword_loc
-              token(node.do_keyword_loc)
+            if (do_keyword_loc = node.do_keyword_loc)
+              token(do_keyword_loc)
             else
-              srange_find(node.collection.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset, [";"])
+              srange_find(node.collection.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset, ";")
             end,
             visit(node.statements),
             token(node.end_keyword_loc)
@@ -865,10 +865,10 @@ module Prism
             builder.condition(
               token(node.if_keyword_loc),
               visit(node.predicate),
-              if node.then_keyword_loc
-                token(node.then_keyword_loc)
+              if (then_keyword_loc = node.then_keyword_loc)
+                token(then_keyword_loc)
               else
-                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.subsequent&.location || node.end_keyword_loc).start_offset, [";"])
+                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.subsequent&.location || node.end_keyword_loc).start_offset, ";")
               end,
               visit(node.statements),
               case node.subsequent
@@ -931,7 +931,11 @@ module Prism
             token(node.in_loc),
             pattern,
             guard,
-            srange_find(node.pattern.location.end_offset, node.statements&.location&.start_offset, [";", "then"]),
+            if (then_loc = node.then_loc)
+              token(then_loc)
+            else
+              srange_find(node.pattern.location.end_offset, node.statements&.location&.start_offset, ";")
+            end,
             visit(node.statements)
           )
         end
@@ -1781,10 +1785,10 @@ module Prism
             builder.condition(
               token(node.keyword_loc),
               visit(node.predicate),
-              if node.then_keyword_loc
-                token(node.then_keyword_loc)
+              if (then_keyword_loc = node.then_keyword_loc)
+                token(then_keyword_loc)
               else
-                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.else_clause&.location || node.end_keyword_loc).start_offset, [";"])
+                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.else_clause&.location || node.end_keyword_loc).start_offset, ";")
               end,
               visit(node.else_clause),
               token(node.else_clause&.else_keyword_loc),
@@ -1812,7 +1816,11 @@ module Prism
               :until,
               token(node.keyword_loc),
               visit(node.predicate),
-              srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, [";", "do"]),
+              if (do_keyword_loc = node.do_keyword_loc)
+                token(do_keyword_loc)
+              else
+                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, ";")
+              end,
               visit(node.statements),
               token(node.closing_loc)
             )
@@ -1832,10 +1840,10 @@ module Prism
           builder.when(
             token(node.keyword_loc),
             visit_all(node.conditions),
-            if node.then_keyword_loc
-              token(node.then_keyword_loc)
+            if (then_keyword_loc = node.then_keyword_loc)
+              token(then_keyword_loc)
             else
-              srange_find(node.conditions.last.location.end_offset, node.statements&.location&.start_offset, [";"])
+              srange_find(node.conditions.last.location.end_offset, node.statements&.location&.start_offset, ";")
             end,
             visit(node.statements)
           )
@@ -1852,7 +1860,11 @@ module Prism
               :while,
               token(node.keyword_loc),
               visit(node.predicate),
-              srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, [";", "do"]),
+              if (do_keyword_loc = node.do_keyword_loc)
+                token(do_keyword_loc)
+              else
+                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, ";")
+              end,
               visit(node.statements),
               token(node.closing_loc)
             )
@@ -1985,18 +1997,16 @@ module Prism
           Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
         end
 
-        # Constructs a new source range by finding the given tokens between the
-        # given start offset and end offset. If the needle is not found, it
+        # Constructs a new source range by finding the given character between
+        # the given start offset and end offset. If the needle is not found, it
         # returns nil. Importantly it does not search past newlines or comments.
         #
         # Note that end_offset is allowed to be nil, in which case this will
         # search until the end of the string.
-        def srange_find(start_offset, end_offset, tokens)
-          if (match = source_buffer.source.byteslice(start_offset...end_offset).match(/\A(\s*)(#{tokens.join("|")})/))
-            _, whitespace, token = *match
-            token_offset = start_offset + whitespace.bytesize
-
-            [token, Range.new(source_buffer, offset_cache[token_offset], offset_cache[token_offset + token.bytesize])]
+        def srange_find(start_offset, end_offset, character)
+          if (match = source_buffer.source.byteslice(start_offset...end_offset)[/\A\s*#{character}/])
+            final_offset = start_offset + match.bytesize
+            [character, Range.new(source_buffer, offset_cache[final_offset - character.bytesize], offset_cache[final_offset])]
           end
         end
 

data/lib/prism/translation/ruby_parser.rb

@@ -881,6 +881,7 @@ module Prism
         # Visit the interpolated content of the string-like node.
         private def visit_interpolated_parts(parts)
           visited = []
+
           parts.each do |part|
             result = visit(part)
 
@@ -892,6 +893,7 @@ module Prism
               else
                 visited << result
               end
+              visited << :space
             elsif result[0] == :dstr
               if !visited.empty? && part.parts[0].is_a?(StringNode)
                 # If we are in the middle of an implicitly concatenated string,
@@ -907,8 +909,9 @@ module Prism
           end
 
           state = :beginning #: :beginning | :string_content | :interpolated_content
+          results = []
 
-          visited.each_with_object([]) do |result, results|
+          visited.each_with_index do |result, index|
             case state
             when :beginning
               if result.is_a?(String)
@@ -923,7 +926,9 @@ module Prism
                 state = :interpolated_content
               end
             when :string_content
-              if result.is_a?(String)
+              if result == :space
+                # continue
+              elsif result.is_a?(String)
                 results[0] << result
               elsif result.is_a?(Array) && result[0] == :str
                 results[0] << result[1]
@@ -932,7 +937,9 @@ module Prism
                 state = :interpolated_content
               end
             when :interpolated_content
-              if result.is_a?(Array) && result[0] == :str && results[-1][0] == :str && (results[-1].line_max == result.line)
+              if result == :space
+                # continue
+              elsif visited[index - 1] != :space && result.is_a?(Array) && result[0] == :str && results[-1][0] == :str && (results[-1].line_max == result.line)
                 results[-1][1] << result[1]
                 results[-1].line_max = result.line_max
               else
@@ -940,6 +947,8 @@ module Prism
               end
             end
           end
+
+          results
         end
 
         # -> { it }

data/lib/prism.rb

@@ -24,7 +24,9 @@ module Prism
   autoload :Pack, "prism/pack"
   autoload :Pattern, "prism/pattern"
   autoload :Reflection, "prism/reflection"
+  autoload :Relocation, "prism/relocation"
   autoload :Serialize, "prism/serialize"
+  autoload :StringQuery, "prism/string_query"
   autoload :Translation, "prism/translation"
   autoload :Visitor, "prism/visitor"
 
@@ -75,13 +77,13 @@ require_relative "prism/parse_result"
 # it's going to require the built library. Otherwise, it's going to require a
 # module that uses FFI to call into the library.
 if RUBY_ENGINE == "ruby" and !ENV["PRISM_FFI_BACKEND"]
-  require "prism/prism"
-
   # The C extension is the default backend on CRuby.
   Prism::BACKEND = :CEXT
-else
-  require_relative "prism/ffi"
 
+  require "prism/prism"
+else
   # The FFI backend is used on other Ruby implementations.
   Prism::BACKEND = :FFI
+
+  require_relative "prism/ffi"
 end

data/prism.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "prism"
-  spec.version = "1.2.0"
+  spec.version = "1.3.0"
   spec.authors = ["Shopify"]
   spec.email = ["ruby@shopify.com"]
 
@@ -35,6 +35,7 @@ Gem::Specification.new do |spec|
     "docs/parser_translation.md",
     "docs/parsing_rules.md",
     "docs/releasing.md",
+    "docs/relocation.md",
     "docs/ripper_translation.md",
     "docs/ruby_api.md",
     "docs/ruby_parser_translation.md",
@@ -88,7 +89,9 @@ Gem::Specification.new do |spec|
     "lib/prism/polyfill/byteindex.rb",
     "lib/prism/polyfill/unpack1.rb",
     "lib/prism/reflection.rb",
+    "lib/prism/relocation.rb",
     "lib/prism/serialize.rb",
+    "lib/prism/string_query.rb",
     "lib/prism/translation.rb",
     "lib/prism/translation/parser.rb",
     "lib/prism/translation/parser33.rb",
@@ -109,6 +112,7 @@ Gem::Specification.new do |spec|
     "rbi/prism/node.rbi",
     "rbi/prism/parse_result.rbi",
     "rbi/prism/reflection.rbi",
+    "rbi/prism/string_query.rbi",
     "rbi/prism/translation/parser.rbi",
     "rbi/prism/translation/parser33.rbi",
     "rbi/prism/translation/parser34.rbi",
@@ -128,7 +132,9 @@ Gem::Specification.new do |spec|
     "sig/prism/parse_result.rbs",
     "sig/prism/pattern.rbs",
     "sig/prism/reflection.rbs",
+    "sig/prism/relocation.rbs",
     "sig/prism/serialize.rbs",
+    "sig/prism/string_query.rbs",
     "sig/prism/visitor.rbs",
     "src/diagnostic.c",
     "src/encoding.c",

data/rbi/prism/dsl.rbi

@@ -451,14 +451,14 @@ module Prism::DSL
   sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, predicate: Prism::Node, then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode), else_clause: T.nilable(Prism::ElseNode), end_keyword_loc: T.nilable(Prism::Location)).returns(Prism::UnlessNode) }
   def unless_node(source: default_source, node_id: 0, location: default_location, flags: 0, keyword_loc: location, predicate: default_node(source, location), then_keyword_loc: nil, statements: nil, else_clause: nil, end_keyword_loc: nil); end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::UntilNode) }
-  def until_node(source: default_source, node_id: 0, location: default_location, flags: 0, keyword_loc: location, closing_loc: nil, predicate: default_node(source, location), statements: nil); end
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, do_keyword_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::UntilNode) }
+  def until_node(source: default_source, node_id: 0, location: default_location, flags: 0, keyword_loc: location, do_keyword_loc: nil, closing_loc: nil, predicate: default_node(source, location), statements: nil); end
 
   sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, conditions: T::Array[Prism::Node], then_keyword_loc: T.nilable(Prism::Location), statements: T.nilable(Prism::StatementsNode)).returns(Prism::WhenNode) }
   def when_node(source: default_source, node_id: 0, location: default_location, flags: 0, keyword_loc: location, conditions: [], then_keyword_loc: nil, statements: nil); end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::WhileNode) }
-  def while_node(source: default_source, node_id: 0, location: default_location, flags: 0, keyword_loc: location, closing_loc: nil, predicate: default_node(source, location), statements: nil); end
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, do_keyword_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::WhileNode) }
+  def while_node(source: default_source, node_id: 0, location: default_location, flags: 0, keyword_loc: location, do_keyword_loc: nil, closing_loc: nil, predicate: default_node(source, location), statements: nil); end
 
   sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, opening_loc: Prism::Location, content_loc: Prism::Location, closing_loc: Prism::Location, unescaped: String).returns(Prism::XStringNode) }
   def x_string_node(source: default_source, node_id: 0, location: default_location, flags: 0, opening_loc: location, content_loc: location, closing_loc: location, unescaped: ""); end

data/rbi/prism/node.rbi

@@ -408,8 +408,8 @@ end
 #     foo in [1, 2]
 #     ^^^^^^^^^^^^^
 #
-#     foo in *1
-#     ^^^^^^^^^
+#     foo in *bar
+#     ^^^^^^^^^^^
 #
 #     foo in Bar[]
 #     ^^^^^^^^^^^^
@@ -8244,6 +8244,9 @@ class Prism::UntilNode < Prism::Node
   sig { returns(Prism::Location) }
   def keyword_loc; end
 
+  sig { returns(T.nilable(Prism::Location)) }
+  def do_keyword_loc; end
+
   sig { returns(T.nilable(Prism::Location)) }
   def closing_loc; end
 
@@ -8253,8 +8256,8 @@ class Prism::UntilNode < Prism::Node
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).void }
-  def initialize(source, node_id, location, flags, keyword_loc, closing_loc, predicate, statements); end
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, do_keyword_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).void }
+  def initialize(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -8271,8 +8274,8 @@ class Prism::UntilNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::UntilNode) }
-  def copy(node_id: self.node_id, location: self.location, flags: self.flags, keyword_loc: self.keyword_loc, closing_loc: self.closing_loc, predicate: self.predicate, statements: self.statements); end
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, do_keyword_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::UntilNode) }
+  def copy(node_id: self.node_id, location: self.location, flags: self.flags, keyword_loc: self.keyword_loc, do_keyword_loc: self.do_keyword_loc, closing_loc: self.closing_loc, predicate: self.predicate, statements: self.statements); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -8280,6 +8283,9 @@ class Prism::UntilNode < Prism::Node
   sig { returns(String) }
   def keyword; end
 
+  sig { returns(T.nilable(String)) }
+  def do_keyword; end
+
   sig { returns(T.nilable(String)) }
   def closing; end
 
@@ -8366,6 +8372,9 @@ class Prism::WhileNode < Prism::Node
   sig { returns(Prism::Location) }
   def keyword_loc; end
 
+  sig { returns(T.nilable(Prism::Location)) }
+  def do_keyword_loc; end
+
   sig { returns(T.nilable(Prism::Location)) }
   def closing_loc; end
 
@@ -8375,8 +8384,8 @@ class Prism::WhileNode < Prism::Node
   sig { returns(T.nilable(Prism::StatementsNode)) }
   def statements; end
 
-  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).void }
-  def initialize(source, node_id, location, flags, keyword_loc, closing_loc, predicate, statements); end
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, do_keyword_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).void }
+  def initialize(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -8393,8 +8402,8 @@ class Prism::WhileNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::WhileNode) }
-  def copy(node_id: self.node_id, location: self.location, flags: self.flags, keyword_loc: self.keyword_loc, closing_loc: self.closing_loc, predicate: self.predicate, statements: self.statements); end
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, keyword_loc: Prism::Location, do_keyword_loc: T.nilable(Prism::Location), closing_loc: T.nilable(Prism::Location), predicate: Prism::Node, statements: T.nilable(Prism::StatementsNode)).returns(Prism::WhileNode) }
+  def copy(node_id: self.node_id, location: self.location, flags: self.flags, keyword_loc: self.keyword_loc, do_keyword_loc: self.do_keyword_loc, closing_loc: self.closing_loc, predicate: self.predicate, statements: self.statements); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -8402,6 +8411,9 @@ class Prism::WhileNode < Prism::Node
   sig { returns(String) }
   def keyword; end
 
+  sig { returns(T.nilable(String)) }
+  def do_keyword; end
+
   sig { returns(T.nilable(String)) }
   def closing; end
 

data/rbi/prism/string_query.rbi

@@ -0,0 +1,12 @@
+# typed: strict
+
+class Prism::StringQuery
+  sig { params(string: String).returns(T::Boolean) }
+  def self.local?(string); end
+
+  sig { params(string: String).returns(T::Boolean) }
+  def self.constant?(string); end
+
+  sig { params(string: String).returns(T::Boolean) }
+  def self.method_name?(string); end
+end

data/sig/prism/dsl.rbs

@@ -300,11 +300,11 @@ module Prism
 
     def unless_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode
 
-    def until_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode
+    def until_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode
 
     def when_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode
 
-    def while_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode
+    def while_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode
 
     def x_string_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> XStringNode
 

data/sig/prism/node.rbs

@@ -184,8 +184,8 @@ module Prism
   #     foo in [1, 2]
   #     ^^^^^^^^^^^^^
   #
-  #     foo in *1
-  #     ^^^^^^^^^
+  #     foo in *bar
+  #     ^^^^^^^^^^^
   #
   #     foo in Bar[]
   #     ^^^^^^^^^^^^
@@ -3336,14 +3336,16 @@ module Prism
     def begin_modifier?: () -> bool
 
     attr_reader keyword_loc: Location
+    attr_reader do_keyword_loc: Location?
     attr_reader closing_loc: Location?
     attr_reader predicate: Prism::node
     attr_reader statements: StatementsNode?
 
-    def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void
-    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
+    def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void
+    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
     def keyword: () -> String
+    def do_keyword: () -> String?
     def closing: () -> String?
     def type: () -> :until_node
             | ...
@@ -3387,14 +3389,16 @@ module Prism
     def begin_modifier?: () -> bool
 
     attr_reader keyword_loc: Location
+    attr_reader do_keyword_loc: Location?
     attr_reader closing_loc: Location?
     attr_reader predicate: Prism::node
     attr_reader statements: StatementsNode?
 
-    def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void
-    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode
-    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
+    def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void
+    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
     def keyword: () -> String
+    def do_keyword: () -> String?
     def closing: () -> String?
     def type: () -> :while_node
             | ...

data/sig/prism/relocation.rbs

@@ -0,0 +1,185 @@
+module Prism
+  module Relocation
+    interface _Value
+      def start_line: () -> Integer
+      def end_line: () -> Integer
+      def start_offset: () -> Integer
+      def end_offset: () -> Integer
+      def start_character_offset: () -> Integer
+      def end_character_offset: () -> Integer
+      def cached_start_code_units_offset: (_CodeUnitsCache cache) -> Integer
+      def cached_end_code_units_offset: (_CodeUnitsCache cache) -> Integer
+      def start_column: () -> Integer
+      def end_column: () -> Integer
+      def start_character_column: () -> Integer
+      def end_character_column: () -> Integer
+      def cached_start_code_units_column: (_CodeUnitsCache cache) -> Integer
+      def cached_end_code_units_column: (_CodeUnitsCache cache) -> Integer
+      def leading_comments: () -> Array[Comment]
+      def trailing_comments: () -> Array[Comment]
+    end
+
+    interface _Field
+      def fields: (_Value value) -> entry_values
+    end
+
+    type entry_value = untyped
+    type entry_values = Hash[Symbol, entry_value]
+
+    class Entry
+      class MissingValueError < StandardError
+      end
+
+      def initialize: (Repository repository) -> void
+
+      def filepath: () -> String
+
+      def start_line: () -> Integer
+      def end_line: () -> Integer
+
+      def start_offset: () -> Integer
+      def end_offset: () -> Integer
+      def start_character_offset: () -> Integer
+      def end_character_offset: () -> Integer
+      def start_code_units_offset: () -> Integer
+      def end_code_units_offset: () -> Integer
+
+      def start_column: () -> Integer
+      def end_column: () -> Integer
+      def start_character_column: () -> Integer
+      def end_character_column: () -> Integer
+      def start_code_units_column: () -> Integer
+      def end_code_units_column: () -> Integer
+
+      def leading_comments: () -> Array[CommentsField::Comment]
+      def trailing_comments: () -> Array[CommentsField::Comment]
+      def comments: () -> Array[CommentsField::Comment]
+
+      private
+
+      def fetch_value: (Symbol name) -> entry_value
+      def values: () -> entry_values
+    end
+
+    class Source
+      attr_reader value: untyped
+
+      def initialize: (untyped value) -> void
+
+      def result: () -> ParseResult
+      def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
+    end
+
+    class SourceFilepath < Source
+      def result: () -> ParseResult
+    end
+
+    class SourceString < Source
+      def result: () -> ParseResult
+    end
+
+    class FilepathField
+      attr_reader value: String
+
+      def initialize: (String value) -> void
+
+      def fields: (_Value value) -> entry_values
+    end
+
+    class LinesField
+      def fields: (_Value value) -> entry_values
+    end
+
+    class OffsetsField
+      def fields: (_Value value) -> entry_values
+    end
+
+    class CharacterOffsetsField
+      def fields: (_Value value) -> entry_values
+    end
+
+    class CodeUnitOffsetsField
+      attr_reader repository: Repository
+      attr_reader encoding: Encoding
+
+      def initialize: (Repository repository, Encoding encoding) -> void
+      def fields: (_Value value) -> entry_values
+
+      private
+
+      def cache: () -> _CodeUnitsCache
+    end
+
+    class ColumnsField
+      def fields: (_Value value) -> entry_values
+    end
+
+    class CharacterColumnsField
+      def fields: (_Value value) -> entry_values
+    end
+
+    class CodeUnitColumnsField
+      attr_reader repository: Repository
+      attr_reader encoding: Encoding
+
+      def initialize: (Repository repository, Encoding encoding) -> void
+      def fields: (_Value value) -> entry_values
+
+      private
+
+      def cache: () -> _CodeUnitsCache
+    end
+
+    class CommentsField
+      class Comment
+        attr_reader slice: String
+
+        def initialize: (String slice) -> void
+      end
+
+      private
+
+      def comments: (entry_value value) -> Array[Comment]
+    end
+
+    class LeadingCommentsField < CommentsField
+      def fields: (_Value value) -> entry_values
+    end
+
+    class TrailingCommentsField < CommentsField
+      def fields: (_Value value) -> entry_values
+    end
+
+    class Repository
+      class ConfigurationError < StandardError
+      end
+
+      attr_reader source: Source
+      attr_reader fields: Hash[Symbol, _Field]
+      attr_reader entries: Hash[Integer, Hash[Symbol, Entry]]
+
+      def initialize: (Source source) -> void
+
+      def code_units_cache: (Encoding encoding) -> _CodeUnitsCache
+
+      def filepath: () -> self
+      def lines: () -> self
+      def offsets: () -> self
+      def character_offsets: () -> self
+      def code_unit_offsets: (Encoding encoding) -> self
+      def columns: () -> self
+      def character_columns: () -> self
+      def code_unit_columns: (Encoding encoding) -> self
+      def leading_comments: () -> self
+      def trailing_comments: () -> self
+      def comments: () -> self
+
+      private
+
+      def field: (Symbol name, _Field) -> self
+    end
+
+    def self.filepath: (String value) -> Repository
+    def self.string: (String value) -> Repository
+  end
+end

data/sig/prism/string_query.rbs

@@ -0,0 +1,11 @@
+module Prism
+  class StringQuery
+    attr_reader string: String
+
+    def initialize: (String string) -> void
+
+    def local?: () -> bool
+    def constant?: () -> bool
+    def method_name?: () -> bool
+  end
+end