prism 0.29.0 → 1.1.0

data/lib/prism/node_ext.rb

@@ -5,10 +5,13 @@
 module Prism
   class Node
     def deprecated(*replacements) # :nodoc:
+      location = caller_locations(1, 1)
+      location = location[0].label if location
       suggest = replacements.map { |replacement| "#{self.class}##{replacement}" }
+
       warn(<<~MSG, category: :deprecated)
-        [deprecation]: #{self.class}##{caller_locations(1, 1)[0].label} is deprecated \
-        and will be removed in the next major version. Use #{suggest.join("/")} instead.
+        [deprecation]: #{self.class}##{location} is deprecated and will be \
+        removed in the next major version. Use #{suggest.join("/")} instead.
         #{(caller(1, 3) || []).join("\n")}
       MSG
     end
@@ -18,7 +21,10 @@ module Prism
     # Returns a numeric value that represents the flags that were used to create
     # the regular expression.
     def options
-      o = flags & (RegularExpressionFlags::IGNORE_CASE | RegularExpressionFlags::EXTENDED | RegularExpressionFlags::MULTI_LINE)
+      o = 0
+      o |= Regexp::IGNORECASE if flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
+      o |= Regexp::EXTENDED if flags.anybits?(RegularExpressionFlags::EXTENDED)
+      o |= Regexp::MULTILINE if flags.anybits?(RegularExpressionFlags::MULTI_LINE)
       o |= Regexp::FIXEDENCODING if flags.anybits?(RegularExpressionFlags::EUC_JP | RegularExpressionFlags::WINDOWS_31J | RegularExpressionFlags::UTF_8)
       o |= Regexp::NOENCODING if flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
       o
@@ -66,11 +72,12 @@ module Prism
     def to_interpolated
       InterpolatedStringNode.new(
         source,
+        -1,
+        location,
         frozen? ? InterpolatedStringNodeFlags::FROZEN : 0,
         opening_loc,
-        [copy(opening_loc: nil, closing_loc: nil, location: content_loc)],
-        closing_loc,
-        location
+        [copy(location: content_loc, opening_loc: nil, closing_loc: nil)],
+        closing_loc
       )
     end
   end
@@ -83,10 +90,12 @@ module Prism
     def to_interpolated
       InterpolatedXStringNode.new(
         source,
+        -1,
+        location,
+        flags,
         opening_loc,
-        [StringNode.new(source, 0, nil, content_loc, nil, unescaped, content_loc)],
-        closing_loc,
-        location
+        [StringNode.new(source, node_id, content_loc, 0, nil, content_loc, nil, unescaped)],
+        closing_loc
       )
     end
   end
@@ -103,7 +112,19 @@ module Prism
   class RationalNode < Node
     # Returns the value of the node as a Ruby Rational.
     def value
-      Rational(numeric.is_a?(IntegerNode) ? numeric.value : slice.chomp("r"))
+      Rational(numerator, denominator)
+    end
+
+    # Returns the value of the node as an IntegerNode or a FloatNode. This
+    # method is deprecated in favor of #value or #numerator/#denominator.
+    def numeric
+      deprecated("value", "numerator", "denominator")
+
+      if denominator == 1
+        IntegerNode.new(source, -1, location.chop, flags, numerator)
+      else
+        FloatNode.new(source, -1, location.chop, 0, numerator.to_f / denominator)
+      end
     end
   end
 
@@ -180,7 +201,12 @@ module Prism
     # continue to supply that API.
     def child
       deprecated("name", "name_loc")
-      name ? ConstantReadNode.new(source, name, name_loc) : MissingNode.new(source, location)
+
+      if name
+        ConstantReadNode.new(source, -1, name_loc, 0, name)
+      else
+        MissingNode.new(source, -1, location, 0)
+      end
     end
   end
 
@@ -216,7 +242,12 @@ module Prism
     # continue to supply that API.
     def child
       deprecated("name", "name_loc")
-      name ? ConstantReadNode.new(source, name, name_loc) : MissingNode.new(source, location)
+
+      if name
+        ConstantReadNode.new(source, -1, name_loc, 0, name)
+      else
+        MissingNode.new(source, -1, location, 0)
+      end
     end
   end
 
@@ -249,9 +280,10 @@ module Prism
       end
 
       posts.each do |param|
-        if param.is_a?(MultiTargetNode)
+        case param
+        when MultiTargetNode
           names << [:req]
-        elsif param.is_a?(NoKeywordsParameterNode)
+        when NoKeywordsParameterNode, KeywordRestParameterNode, ForwardingParameterNode
           # Invalid syntax, e.g. "def f(**nil, ...)" moves the NoKeywordsParameterNode to posts
           raise "Invalid syntax"
         else
@@ -428,4 +460,49 @@ module Prism
       binary_operator_loc
     end
   end
+
+  class CaseMatchNode < Node
+    # Returns the else clause of the case match node. This method is deprecated
+    # in favor of #else_clause.
+    def consequent
+      deprecated("else_clause")
+      else_clause
+    end
+  end
+
+  class CaseNode < Node
+    # Returns the else clause of the case node. This method is deprecated in
+    # favor of #else_clause.
+    def consequent
+      deprecated("else_clause")
+      else_clause
+    end
+  end
+
+  class IfNode < Node
+    # Returns the subsequent if/elsif/else clause of the if node. This method is
+    # deprecated in favor of #subsequent.
+    def consequent
+      deprecated("subsequent")
+      subsequent
+    end
+  end
+
+  class RescueNode < Node
+    # Returns the subsequent rescue clause of the rescue node. This method is
+    # deprecated in favor of #subsequent.
+    def consequent
+      deprecated("subsequent")
+      subsequent
+    end
+  end
+
+  class UnlessNode < Node
+    # Returns the else clause of the unless node. This method is deprecated in
+    # favor of #else_clause.
+    def consequent
+      deprecated("else_clause")
+      else_clause
+    end
+  end
 end

data/lib/prism/parse_result/comments.rb

@@ -183,12 +183,5 @@ module Prism
         [preceding, NodeTarget.new(node), following]
       end
     end
-
-    private_constant :Comments
-
-    # Attach the list of comments to their respective locations in the tree.
-    def attach_comments!
-      Comments.new(self).attach! # steep:ignore
-    end
   end
 end

data/lib/prism/parse_result/errors.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Prism
+  class ParseResult < Result
+    # An object to represent the set of errors on a parse result. This object
+    # can be used to format the errors in a human-readable way.
+    class Errors
+      # The parse result that contains the errors.
+      attr_reader :parse_result
+
+      # Initialize a new set of errors from the given parse result.
+      def initialize(parse_result)
+        @parse_result = parse_result
+      end
+
+      # Formats the errors in a human-readable way and return them as a string.
+      def format
+        error_lines = {}
+        parse_result.errors.each do |error|
+          location = error.location
+          (location.start_line..location.end_line).each do |line|
+            error_lines[line] ||= []
+            error_lines[line] << error
+          end
+        end
+
+        source_lines = parse_result.source.source.lines
+        source_lines << "" if error_lines.key?(source_lines.size + 1)
+
+        io = StringIO.new
+        source_lines.each.with_index(1) do |line, line_number|
+          io.puts(line)
+
+          (error_lines.delete(line_number) || []).each do |error|
+            location = error.location
+
+            case line_number
+            when location.start_line
+              io.print(" " * location.start_column + "^")
+
+              if location.start_line == location.end_line
+                if location.start_column != location.end_column
+                  io.print("~" * (location.end_column - location.start_column - 1))
+                end
+
+                io.puts(" " + error.message)
+              else
+                io.puts("~" * (line.bytesize - location.start_column))
+              end
+            when location.end_line
+              io.puts("~" * location.end_column + " " + error.message)
+            else
+              io.puts("~" * line.bytesize)
+            end
+          end
+        end
+
+        io.puts
+        io.string
+      end
+    end
+  end
+end

data/lib/prism/parse_result/newlines.rb

@@ -17,21 +17,27 @@ module Prism
     # Note that the logic in this file should be kept in sync with the Java
     # MarkNewlinesVisitor, since that visitor is responsible for marking the
     # newlines for JRuby/TruffleRuby.
+    #
+    # This file is autoloaded only when `mark_newlines!` is called, so the
+    # re-opening of the various nodes in this file will only be performed in
+    # that case. We do that to avoid storing the extra `@newline` instance
+    # variable on every node if we don't need it.
     class Newlines < Visitor
       # Create a new Newlines visitor with the given newline offsets.
-      def initialize(newline_marked)
-        @newline_marked = newline_marked
+      def initialize(lines)
+        # @type var lines: Integer
+        @lines = Array.new(1 + lines, false)
       end
 
       # Permit block/lambda nodes to mark newlines within themselves.
       def visit_block_node(node)
-        old_newline_marked = @newline_marked
-        @newline_marked = Array.new(old_newline_marked.size, false)
+        old_lines = @lines
+        @lines = Array.new(old_lines.size, false)
 
         begin
           super(node)
         ensure
-          @newline_marked = old_newline_marked
+          @lines = old_lines
         end
       end
 
@@ -39,7 +45,7 @@ module Prism
 
       # Mark if/unless nodes as newlines.
       def visit_if_node(node)
-        node.set_newline_flag(@newline_marked)
+        node.newline_flag!(@lines)
         super(node)
       end
 
@@ -48,17 +54,101 @@ module Prism
       # Permit statements lists to mark newlines within themselves.
       def visit_statements_node(node)
         node.body.each do |child|
-          child.set_newline_flag(@newline_marked)
+          child.newline_flag!(@lines)
         end
         super(node)
       end
     end
+  end
+
+  class Node
+    def newline_flag? # :nodoc:
+      @newline_flag ? true : false
+    end
+
+    def newline_flag!(lines) # :nodoc:
+      line = location.start_line
+      unless lines[line]
+        lines[line] = true
+        @newline_flag = true
+      end
+    end
+  end
+
+  class BeginNode < Node
+    def newline_flag!(lines) # :nodoc:
+      # Never mark BeginNode with a newline flag, mark children instead.
+    end
+  end
+
+  class ParenthesesNode < Node
+    def newline_flag!(lines) # :nodoc:
+      # Never mark ParenthesesNode with a newline flag, mark children instead.
+    end
+  end
+
+  class IfNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class UnlessNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class UntilNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class WhileNode < Node
+    def newline_flag!(lines) # :nodoc:
+      predicate.newline_flag!(lines)
+    end
+  end
+
+  class RescueModifierNode < Node
+    def newline_flag!(lines) # :nodoc:
+      expression.newline_flag!(lines)
+    end
+  end
+
+  class InterpolatedMatchLastLineNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
+
+  class InterpolatedStringNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
 
-    private_constant :Newlines
+  class InterpolatedSymbolNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
+    end
+  end
 
-    # Walk the tree and mark nodes that are on a new line.
-    def mark_newlines!
-      value.accept(Newlines.new(Array.new(1 + source.offsets.size, false))) # steep:ignore
+  class InterpolatedXStringNode < Node
+    def newline_flag!(lines) # :nodoc:
+      first = parts.first
+      first.newline_flag!(lines) if first
     end
   end
 end

data/lib/prism/parse_result.rb

@@ -10,7 +10,11 @@ module Prism
     # specialized and more performant `ASCIISource` if no multibyte characters
     # are present in the source code.
     def self.for(source, start_line = 1, offsets = [])
-      source.ascii_only? ? ASCIISource.new(source, start_line, offsets): new(source, start_line, offsets)
+      if source.ascii_only?
+        ASCIISource.new(source, start_line, offsets)
+      else
+        new(source, start_line, offsets)
+      end
     end
 
     # The source code that this source object represents.
@@ -87,7 +91,12 @@ module Prism
     # encodings, it is not captured here.
     def code_units_offset(byte_offset, encoding)
       byteslice = (source.byteslice(0, byte_offset) or raise).encode(encoding)
-      (encoding == Encoding::UTF_16LE || encoding == Encoding::UTF_16BE) ? (byteslice.bytesize / 2) : byteslice.length
+
+      if encoding == Encoding::UTF_16LE || encoding == Encoding::UTF_16BE
+        byteslice.bytesize / 2
+      else
+        byteslice.length
+      end
     end
 
     # Returns the column number in code units for the given encoding for the
@@ -146,7 +155,7 @@ module Prism
 
     # Specialized version of `code_units_column` that does not depend on
     # `code_units_offset`, which is a more expensive operation. This is
-    # essentialy the same as `Prism::Source#column`.
+    # essentially the same as `Prism::Source#column`.
     def code_units_column(byte_offset, encoding)
       byte_offset - line_start(byte_offset)
     end
@@ -574,6 +583,14 @@ module Prism
 
   # This is a result specific to the `parse` and `parse_file` methods.
   class ParseResult < Result
+    autoload :Comments, "prism/parse_result/comments"
+    autoload :Errors, "prism/parse_result/errors"
+    autoload :Newlines, "prism/parse_result/newlines"
+
+    private_constant :Comments
+    private_constant :Errors
+    private_constant :Newlines
+
     # The syntax tree that was parsed from the source code.
     attr_reader :value
 
@@ -587,6 +604,23 @@ module Prism
     def deconstruct_keys(keys)
       super.merge!(value: value)
     end
+
+    # Attach the list of comments to their respective locations in the tree.
+    def attach_comments!
+      Comments.new(self).attach! # steep:ignore
+    end
+
+    # Walk the tree and mark nodes that are on a new line, loosely emulating
+    # the behavior of CRuby's `:line` tracepoint event.
+    def mark_newlines!
+      value.accept(Newlines.new(source.offsets.size)) # steep:ignore
+    end
+
+    # Returns a string representation of the syntax tree with the errors
+    # displayed inline.
+    def errors_format
+      Errors.new(self).format
+    end
   end
 
   # This is a result specific to the `lex` and `lex_file` methods.
@@ -677,5 +711,11 @@ module Prism
         other.type == type &&
         other.value == value
     end
+
+    # Returns a string representation of this token.
+    def inspect
+      location
+      super
+    end
   end
 end

data/lib/prism/reflection.rb

@@ -112,7 +112,7 @@ module Prism
       when :and_node
         [NodeField.new(:left), NodeField.new(:right), LocationField.new(:operator_loc)]
       when :arguments_node
-        [FlagsField.new(:flags, [:contains_keywords?, :contains_keyword_splat?]), NodeListField.new(:arguments)]
+        [FlagsField.new(:flags, [:contains_forwarding?, :contains_keywords?, :contains_keyword_splat?, :contains_splat?, :contains_multiple_splats?]), NodeListField.new(:arguments)]
       when :array_node
         [FlagsField.new(:flags, [:contains_splat?]), NodeListField.new(:elements), OptionalLocationField.new(:opening_loc), OptionalLocationField.new(:closing_loc)]
       when :array_pattern_node
@@ -150,9 +150,9 @@ module Prism
       when :capture_pattern_node
         [NodeField.new(:value), NodeField.new(:target), LocationField.new(:operator_loc)]
       when :case_match_node
-        [OptionalNodeField.new(:predicate), NodeListField.new(:conditions), OptionalNodeField.new(:consequent), LocationField.new(:case_keyword_loc), LocationField.new(:end_keyword_loc)]
+        [OptionalNodeField.new(:predicate), NodeListField.new(:conditions), OptionalNodeField.new(:else_clause), LocationField.new(:case_keyword_loc), LocationField.new(:end_keyword_loc)]
       when :case_node
-        [OptionalNodeField.new(:predicate), NodeListField.new(:conditions), OptionalNodeField.new(:consequent), LocationField.new(:case_keyword_loc), LocationField.new(:end_keyword_loc)]
+        [OptionalNodeField.new(:predicate), NodeListField.new(:conditions), OptionalNodeField.new(:else_clause), LocationField.new(:case_keyword_loc), LocationField.new(:end_keyword_loc)]
       when :class_node
         [ConstantListField.new(:locals), LocationField.new(:class_keyword_loc), NodeField.new(:constant_path), OptionalLocationField.new(:inheritance_operator_loc), OptionalNodeField.new(:superclass), OptionalNodeField.new(:body), LocationField.new(:end_keyword_loc), ConstantField.new(:name)]
       when :class_variable_and_write_node
@@ -236,7 +236,7 @@ module Prism
       when :hash_pattern_node
         [OptionalNodeField.new(:constant), NodeListField.new(:elements), OptionalNodeField.new(:rest), OptionalLocationField.new(:opening_loc), OptionalLocationField.new(:closing_loc)]
       when :if_node
-        [OptionalLocationField.new(:if_keyword_loc), NodeField.new(:predicate), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements), OptionalNodeField.new(:consequent), OptionalLocationField.new(:end_keyword_loc)]
+        [OptionalLocationField.new(:if_keyword_loc), NodeField.new(:predicate), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements), OptionalNodeField.new(:subsequent), OptionalLocationField.new(:end_keyword_loc)]
       when :imaginary_node
         [NodeField.new(:numeric)]
       when :implicit_node
@@ -277,6 +277,8 @@ module Prism
         [OptionalLocationField.new(:opening_loc), NodeListField.new(:parts), OptionalLocationField.new(:closing_loc)]
       when :interpolated_x_string_node
         [LocationField.new(:opening_loc), NodeListField.new(:parts), LocationField.new(:closing_loc)]
+      when :it_local_variable_read_node
+        []
       when :it_parameters_node
         []
       when :keyword_hash_node
@@ -346,7 +348,7 @@ module Prism
       when :range_node
         [FlagsField.new(:flags, [:exclude_end?]), OptionalNodeField.new(:left), OptionalNodeField.new(:right), LocationField.new(:operator_loc)]
       when :rational_node
-        [NodeField.new(:numeric)]
+        [FlagsField.new(:flags, [:binary?, :decimal?, :octal?, :hexadecimal?]), IntegerField.new(:numerator), IntegerField.new(:denominator)]
       when :redo_node
         []
       when :regular_expression_node
@@ -358,13 +360,13 @@ module Prism
       when :rescue_modifier_node
         [NodeField.new(:expression), LocationField.new(:keyword_loc), NodeField.new(:rescue_expression)]
       when :rescue_node
-        [LocationField.new(:keyword_loc), NodeListField.new(:exceptions), OptionalLocationField.new(:operator_loc), OptionalNodeField.new(:reference), OptionalNodeField.new(:statements), OptionalNodeField.new(:consequent)]
+        [LocationField.new(:keyword_loc), NodeListField.new(:exceptions), OptionalLocationField.new(:operator_loc), OptionalNodeField.new(:reference), OptionalNodeField.new(:statements), OptionalNodeField.new(:subsequent)]
       when :rest_parameter_node
         [FlagsField.new(:flags, [:repeated_parameter?]), OptionalConstantField.new(:name), OptionalLocationField.new(:name_loc), LocationField.new(:operator_loc)]
       when :retry_node
         []
       when :return_node
-        [FlagsField.new(:flags, [:redundant?]), LocationField.new(:keyword_loc), OptionalNodeField.new(:arguments)]
+        [LocationField.new(:keyword_loc), OptionalNodeField.new(:arguments)]
       when :self_node
         []
       when :shareable_constant_node
@@ -392,7 +394,7 @@ module Prism
       when :undef_node
         [NodeListField.new(:names), LocationField.new(:keyword_loc)]
       when :unless_node
-        [LocationField.new(:keyword_loc), NodeField.new(:predicate), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements), OptionalNodeField.new(:consequent), OptionalLocationField.new(:end_keyword_loc)]
+        [LocationField.new(:keyword_loc), NodeField.new(:predicate), OptionalLocationField.new(:then_keyword_loc), OptionalNodeField.new(:statements), OptionalNodeField.new(:else_clause), OptionalLocationField.new(:end_keyword_loc)]
       when :until_node
         [FlagsField.new(:flags, [:begin_modifier?]), LocationField.new(:keyword_loc), OptionalLocationField.new(:closing_loc), NodeField.new(:predicate), OptionalNodeField.new(:statements)]
       when :when_node