prism 0.26.0 → 0.27.0

data/lib/prism/translation/ruby_parser.rb

@@ -805,17 +805,29 @@ module Prism
         # if /foo #{bar}/ then end
         #    ^^^^^^^^^^^^
         def visit_interpolated_match_last_line_node(node)
-          s(node, :match, s(node, :dregx).concat(visit_interpolated_parts(node.parts)))
+          parts = visit_interpolated_parts(node.parts)
+          regexp =
+            if parts.length == 1
+              s(node, :lit, Regexp.new(parts.first, node.options))
+            else
+              s(node, :dregx).concat(parts).tap do |result|
+                options = node.options
+                result << options if options != 0
+              end
+            end
+
+          s(node, :match, regexp)
         end
 
         # /foo #{bar}/
         # ^^^^^^^^^^^^
         def visit_interpolated_regular_expression_node(node)
-          if node.parts.all? { |part| part.is_a?(StringNode) || (part.is_a?(EmbeddedStatementsNode) && part.statements&.body&.length == 1 && part.statements.body.first.is_a?(StringNode)) }
-            unescaped = node.parts.map { |part| part.is_a?(StringNode) ? part.unescaped : part.statements.body.first.unescaped }.join
-            s(node, :lit, Regexp.new(unescaped, node.options))
+          parts = visit_interpolated_parts(node.parts)
+
+          if parts.length == 1
+            s(node, :lit, Regexp.new(parts.first, node.options))
           else
-            s(node, :dregx).concat(visit_interpolated_parts(node.parts)).tap do |result|
+            s(node, :dregx).concat(parts).tap do |result|
               options = node.options
               result << options if options != 0
             end
@@ -825,45 +837,71 @@ module Prism
         # "foo #{bar}"
         # ^^^^^^^^^^^^
         def visit_interpolated_string_node(node)
-          if (node.parts.all? { |part| part.is_a?(StringNode) || (part.is_a?(EmbeddedStatementsNode) && part.statements&.body&.length == 1 && part.statements.body.first.is_a?(StringNode)) }) ||
-             (node.opening.nil? && node.parts.all? { |part| part.is_a?(StringNode) && !part.opening_loc.nil? })
-             unescaped = node.parts.map { |part| part.is_a?(StringNode) ? part.unescaped : part.statements.body.first.unescaped }.join
-            s(node, :str, unescaped)
-          else
-            s(node, :dstr).concat(visit_interpolated_parts(node.parts))
-          end
+          parts = visit_interpolated_parts(node.parts)
+          parts.length == 1 ? s(node, :str, parts.first) : s(node, :dstr).concat(parts)
         end
 
         # :"foo #{bar}"
         # ^^^^^^^^^^^^^
         def visit_interpolated_symbol_node(node)
-          if node.parts.all? { |part| part.is_a?(StringNode) || (part.is_a?(EmbeddedStatementsNode) && part.statements&.body&.length == 1 && part.statements.body.first.is_a?(StringNode)) }
-            unescaped = node.parts.map { |part| part.is_a?(StringNode) ? part.unescaped : part.statements.body.first.unescaped }.join
-            s(node, :lit, unescaped.to_sym)
-          else
-            s(node, :dsym).concat(visit_interpolated_parts(node.parts))
-          end
+          parts = visit_interpolated_parts(node.parts)
+          parts.length == 1 ? s(node, :lit, parts.first.to_sym) : s(node, :dsym).concat(parts)
         end
 
         # `foo #{bar}`
         # ^^^^^^^^^^^^
         def visit_interpolated_x_string_node(node)
-          children = visit_interpolated_parts(node.parts)
-          s(node.heredoc? ? node.parts.first : node, :dxstr).concat(children)
+          source = node.heredoc? ? node.parts.first : node
+          parts = visit_interpolated_parts(node.parts)
+          parts.length == 1 ? s(source, :xstr, parts.first) : s(source, :dxstr).concat(parts)
         end
 
         # Visit the interpolated content of the string-like node.
         private def visit_interpolated_parts(parts)
-          parts.each_with_object([]).with_index do |(part, results), index|
-            if index == 0
-              if part.is_a?(StringNode)
-                results << part.unescaped
+          visited = []
+          parts.each do |part|
+            result = visit(part)
+
+            if result[0] == :evstr && result[1]
+              if result[1][0] == :str
+                visited << result[1]
+              elsif result[1][0] == :dstr
+                visited.concat(result[1][1..-1])
+              else
+                visited << result
+              end
+            else
+              visited << result
+            end
+          end
+
+          state = :beginning #: :beginning | :string_content | :interpolated_content
+
+          visited.each_with_object([]) do |result, results|
+            case state
+            when :beginning
+              if result.is_a?(String)
+                results << result
+                state = :string_content
+              elsif result.is_a?(Array) && result[0] == :str
+                results << result[1]
+                state = :string_content
               else
                 results << ""
-                results << visit(part)
+                results << result
+                state = :interpolated_content
+              end
+            when :string_content
+              if result.is_a?(String)
+                results[0] << result
+              elsif result.is_a?(Array) && result[0] == :str
+                results[0] << result[1]
+              else
+                results << result
+                state = :interpolated_content
               end
             else
-              results << visit(part)
+              results << result
             end
           end
         end
@@ -1297,7 +1335,7 @@ module Prism
         # __FILE__
         # ^^^^^^^^
         def visit_source_file_node(node)
-          s(node, :str, file)
+          s(node, :str, node.filepath)
         end
 
         # __LINE__
@@ -1498,7 +1536,7 @@ module Prism
       # Parse the given source and translate it into the seattlerb/ruby_parser
       # gem's Sexp format.
       def parse(source, filepath = "(string)")
-        translate(Prism.parse(source), filepath)
+        translate(Prism.parse(source, filepath: filepath), filepath)
       end
 
       # Parse the given file and translate it into the seattlerb/ruby_parser

data/lib/prism.rb

@@ -37,7 +37,7 @@ module Prism
   private_constant :LexRipper
 
   # :call-seq:
-  #   Prism::lex_compat(source, **options) -> ParseResult
+  #   Prism::lex_compat(source, **options) -> LexCompat::Result
   #
   # Returns a parse result whose value is an array of tokens that closely
   # resembles the return value of Ripper::lex. The main difference is that the

data/prism.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "prism"
-  spec.version = "0.26.0"
+  spec.version = "0.27.0"
   spec.authors = ["Shopify"]
   spec.email = ["ruby@shopify.com"]
 

data/rbi/prism/node.rbi

@@ -10,7 +10,7 @@ class Prism::Node
   abstract!
 
   sig { returns(Prism::Source) }
-  attr_reader :source
+  def source; end
 
   sig { returns(Prism::Location) }
   def location; end
@@ -3754,13 +3754,16 @@ class Prism::HashPatternNode < Prism::Node
   def type; end
 end
 
-# Represents the use of the `if` keyword, either in the block form or the modifier form.
+# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
 #
 #     bar if foo
 #     ^^^^^^^^^^
 #
 #     if foo then bar end
 #     ^^^^^^^^^^^^^^^^^^^
+#
+#     foo ? bar : baz
+#     ^^^^^^^^^^^^^^^
 class Prism::IfNode < Prism::Node
   sig { returns(T.nilable(Prism::Location)) }
   def if_keyword_loc; end

data/rbi/prism/parse_result.rbi

@@ -2,13 +2,13 @@
 
 class Prism::Source
   sig { returns(String) }
-  attr_reader :source
+  def source; end
 
   sig { returns(Integer) }
-  attr_reader :start_line
+  def start_line; end
 
   sig { returns(T::Array[Integer]) }
-  attr_reader :offsets
+  def offsets; end
 
   sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
   def initialize(source, start_line = 1, offsets = []); end
@@ -43,13 +43,13 @@ end
 
 class Prism::Location
   sig { returns(Prism::Source) }
-  attr_reader :source
+  def source; end
 
   sig { returns(Integer) }
-  attr_reader :start_offset
+  def start_offset; end
 
   sig { returns(Integer) }
-  attr_reader :length
+  def length; end
 
   sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
   def initialize(source, start_offset, length); end
@@ -140,7 +140,7 @@ class Prism::Comment
   abstract!
 
   sig { returns(Prism::Location) }
-  attr_reader :location
+  def location; end
 
   sig { params(location: Prism::Location).void }
   def initialize(location); end
@@ -173,10 +173,10 @@ end
 
 class Prism::MagicComment
   sig { returns(Prism::Location) }
-  attr_reader :key_loc
+  def key_loc; end
 
   sig { returns(Prism::Location) }
-  attr_reader :value_loc
+  def value_loc; end
 
   sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
   def initialize(key_loc, value_loc); end
@@ -196,16 +196,16 @@ end
 
 class Prism::ParseError
   sig { returns(Symbol) }
-  attr_reader :type
+  def type; end
 
   sig { returns(String) }
-  attr_reader :message
+  def message; end
 
   sig { returns(Prism::Location) }
-  attr_reader :location
+  def location; end
 
   sig { returns(Symbol) }
-  attr_reader :level
+  def level; end
 
   sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
   def initialize(type, message, location, level); end
@@ -219,16 +219,16 @@ end
 
 class Prism::ParseWarning
   sig { returns(Symbol) }
-  attr_reader :type
+  def type; end
 
   sig { returns(String) }
-  attr_reader :message
+  def message; end
 
   sig { returns(Prism::Location) }
-  attr_reader :location
+  def location; end
 
   sig { returns(Symbol) }
-  attr_reader :level
+  def level; end
 
   sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
   def initialize(type, message, location, level); end
@@ -240,32 +240,27 @@ class Prism::ParseWarning
   def inspect; end
 end
 
-class Prism::ParseResult
-  Value = type_member
-
-  sig { returns(Value) }
-  attr_reader :value
+class Prism::Result
+  sig { params(comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
 
   sig { returns(T::Array[Prism::Comment]) }
-  attr_reader :comments
+  def comments; end
 
   sig { returns(T::Array[Prism::MagicComment]) }
-  attr_reader :magic_comments
+  def magic_comments; end
 
   sig { returns(T.nilable(Prism::Location)) }
-  attr_reader :data_loc
+  def data_loc; end
 
   sig { returns(T::Array[Prism::ParseError]) }
-  attr_reader :errors
+  def errors; end
 
   sig { returns(T::Array[Prism::ParseWarning]) }
-  attr_reader :warnings
+  def warnings; end
 
   sig { returns(Prism::Source) }
-  attr_reader :source
-
-  sig { params(value: Value, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+  def source; end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -280,15 +275,48 @@ class Prism::ParseResult
   def failure?; end
 end
 
+class Prism::ParseResult < Prism::Result
+  sig { params(value: Prism::ProgramNode, comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  sig { returns(Prism::ProgramNode) }
+  def value; end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+end
+
+class Prism::LexResult < Prism::Result
+  sig { params(value: T::Array[T.untyped], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  sig { returns(T::Array[T.untyped]) }
+  def value; end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+end
+
+class Prism::ParseLexResult < Prism::Result
+  sig { params(value: [Prism::ProgramNode, T::Array[T.untyped]], comments: T::Array[Prism::Comment], magic_comments: T::Array[Prism::MagicComment], data_loc: T.nilable(Prism::Location), errors: T::Array[Prism::ParseError], warnings: T::Array[Prism::ParseWarning], source: Prism::Source).void }
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
+  def value; end
+
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+end
+
 class Prism::Token
   sig { returns(Prism::Source) }
-  attr_reader :source
+  def source; end
 
   sig { returns(Symbol) }
-  attr_reader :type
+  def type; end
 
   sig { returns(String) }
-  attr_reader :value
+  def value; end
 
   sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
   def initialize(source, type, value, location); end

data/rbi/prism/reflection.rbi

@@ -4,11 +4,11 @@ module Prism::Reflection
 end
 
 class Prism::Reflection::Field
-  sig { returns(Symbol) }
-  attr_reader :name
-
   sig { params(name: Symbol).void }
   def initialize(name); end
+
+  sig { returns(Symbol) }
+  def name; end
 end
 
 class Prism::Reflection::NodeField < Prism::Reflection::Field
@@ -38,24 +38,18 @@ end
 class Prism::Reflection::OptionalLocationField < Prism::Reflection::Field
 end
 
-class Prism::Reflection::UInt8Field < Prism::Reflection::Field
+class Prism::Reflection::IntegerField < Prism::Reflection::Field
 end
 
-class Prism::Reflection::UInt32Field < Prism::Reflection::Field
+class Prism::Reflection::FloatField < Prism::Reflection::Field
 end
 
 class Prism::Reflection::FlagsField < Prism::Reflection::Field
-  sig { returns(T::Array[Symbol]) }
-  attr_reader :flags
-
   sig { params(name: Symbol, flags: T::Array[Symbol]).void }
   def initialize(name, flags); end
-end
-
-class Prism::Reflection::IntegerField < Prism::Reflection::Field
-end
 
-class Prism::Reflection::DoubleField < Prism::Reflection::Field
+  sig { returns(T::Array[Symbol]) }
+  def flags; end
 end
 
 module Prism::Reflection

data/rbi/prism.rbi

@@ -7,28 +7,28 @@ module Prism
   sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(String) }
   def self.dump_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[T::Array[T.untyped]]) }
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
   def self.lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[T::Array[T.untyped]]) }
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::LexResult) }
   def self.lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::ParseResult[T::Array[T.untyped]]) }
+  sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
   def self.lex_compat(source, **options); end
 
   sig { params(source: String).returns(T::Array[T.untyped]) }
   def self.lex_ripper(source); end
 
-  sig { params(source: String, serialized: String).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
   def self.load(source, serialized); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
   def self.parse(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
   def self.parse_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[Prism::ProgramNode]) }
+  sig { params(stream: T.any(IO, StringIO), command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult) }
   def self.parse_stream(stream, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
   sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
@@ -37,10 +37,10 @@ module Prism
   sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Array[Prism::Comment]) }
   def self.parse_file_comments(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[[Prism::ProgramNode, T::Array[T.untyped]]]) }
+  sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
   def self.parse_lex(source, command_line: nil, encoding: nil, filepath: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
-  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseResult[[Prism::ProgramNode, T::Array[T.untyped]]]) }
+  sig { params(filepath: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(Prism::ParseLexResult) }
   def self.parse_lex_file(filepath, command_line: nil, encoding: nil, frozen_string_literal: nil, line: nil, scopes: nil, version: nil); end
 
   sig { params(source: String, command_line: T.nilable(String), encoding: T.nilable(T.any(String, Encoding)), filepath: T.nilable(String), frozen_string_literal: T.nilable(T::Boolean), line: T.nilable(Integer), scopes: T.nilable(T::Array[T::Array[Symbol]]), version: T.nilable(String)).returns(T::Boolean) }

data/sig/prism/node.rbs

@@ -1515,13 +1515,16 @@ module Prism
     def self.type: () -> :hash_pattern_node
   end
 
-  # Represents the use of the `if` keyword, either in the block form or the modifier form.
+  # Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
   #
   #     bar if foo
   #     ^^^^^^^^^^
   #
   #     if foo then bar end
   #     ^^^^^^^^^^^^^^^^^^^
+  #
+  #     foo ? bar : baz
+  #     ^^^^^^^^^^^^^^^
   class IfNode < Node
     include _Node
 

data/sig/prism/parse_result.rbs

@@ -41,7 +41,7 @@ module Prism
     def start_character_column: () -> Integer
     def end_column: () -> Integer
     def end_character_column: () -> Integer
-    def deconstruct_keys: (Array[Symbol] keys) -> { start_offset: Integer, end_offset: Integer }
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
     def pretty_print: (untyped q) -> untyped
     def join: (Location other) -> Location
   end
@@ -50,7 +50,7 @@ module Prism
     attr_reader location: Location
 
     def initialize: (Location location) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
   end
 
   interface _Comment
@@ -76,7 +76,7 @@ module Prism
     def key: () -> String
     def value: () -> String
 
-    def deconstruct_keys: (Array[Symbol] keys) -> { key_loc: Location, value_loc: Location }
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
   end
 
   class ParseError
@@ -86,7 +86,7 @@ module Prism
     attr_reader level: Symbol
 
     def initialize: (Symbol type, String message, Location location, Symbol level) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { message: String, location: Location, level: Symbol }
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
   end
 
   class ParseWarning
@@ -96,11 +96,10 @@ module Prism
     attr_reader level: Symbol
 
     def initialize: (Symbol type, String message, Location location, Symbol level) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { message: String, location: Location, level: Symbol }
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
   end
 
-  class ParseResult[out T]
-    attr_reader value: T
+  class Result
     attr_reader comments: Array[comment]
     attr_reader magic_comments: Array[MagicComment]
     attr_reader data_loc: Location?
@@ -108,12 +107,33 @@ module Prism
     attr_reader warnings: Array[ParseWarning]
     attr_reader source: Source
 
-    def initialize: (T value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { value: T, comments: Array[comment], magic_comments: Array[MagicComment], data_loc: Location?, errors: Array[ParseError], warnings: Array[ParseWarning] }
+    def initialize: (Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
     def success?: () -> bool
     def failure?: () -> bool
   end
 
+  class ParseResult < Result
+    attr_reader value: ProgramNode
+
+    def initialize: (ProgramNode value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
+  end
+
+  class LexResult < Result
+    attr_reader value: Array[[Token, Integer]]
+
+    def initialize: (Array[[Token, Integer]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
+  end
+
+  class ParseLexResult < Result
+    attr_reader value: [ProgramNode, Array[[Token, Integer]]]
+
+    def initialize: ([ProgramNode, Array[[Token, Integer]]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
+  end
+
   class Token
     attr_reader source: Source
     attr_reader type: Symbol
@@ -121,7 +141,7 @@ module Prism
     attr_reader location: Location
 
     def initialize: (Source source, Symbol type, String value, Location location) -> void
-    def deconstruct_keys: (Array[Symbol] keys) -> { type: Symbol, value: String, location: Location }
+    def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
     def pretty_print: (untyped q) -> untyped
     def ==: (untyped other) -> bool
   end

data/sig/prism/reflection.rbs

@@ -33,10 +33,10 @@ module Prism
     class OptionalLocationField < Field
     end
 
-    class UInt8Field < Field
+    class IntegerField < Field
     end
 
-    class UInt32Field < Field
+    class FloatField < Field
     end
 
     class FlagsField < Field
@@ -45,12 +45,6 @@ module Prism
       def initialize: (Symbol name, Array[Symbol] flags) -> void
     end
 
-    class IntegerField < Field
-    end
-
-    class DoubleField < Field
-    end
-
     def self.fields_for: (node_singleton node) -> Array[Field]
   end
 end

data/sig/prism/serialize.rbs

@@ -1,7 +1,6 @@
 module Prism
   module Serialize
-    def self.load: (String, String) -> ParseResult[ProgramNode]
-
-    def self.load_tokens: (Source, String) -> ParseResult[Array[Token]]   # TODO: check if array[token] is right
+    def self.load: (String, String) -> ParseResult
+    def self.load_tokens: (Source, String) -> LexResult
   end
 end