prism 0.29.0 → 0.30.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
@@ -103,7 +106,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, flags, numerator, location.chop)
+      else
+        FloatNode.new(source, numerator.to_f / denominator, location.chop)
+      end
     end
   end
 
@@ -249,9 +264,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

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/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!(@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!(@lines)
         end
         super(node)
       end
     end
+  end
+
+  class Node
+    def newline? # :nodoc:
+      @newline ? true : false
+    end
+
+    def newline!(lines) # :nodoc:
+      line = location.start_line
+      unless lines[line]
+        lines[line] = true
+        @newline = true
+      end
+    end
+  end
+
+  class BeginNode < Node
+    def newline!(lines) # :nodoc:
+      # Never mark BeginNode with a newline flag, mark children instead.
+    end
+  end
+
+  class ParenthesesNode < Node
+    def newline!(lines) # :nodoc:
+      # Never mark ParenthesesNode with a newline flag, mark children instead.
+    end
+  end
+
+  class IfNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class UnlessNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class UntilNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class WhileNode < Node
+    def newline!(lines) # :nodoc:
+      predicate.newline!(lines)
+    end
+  end
+
+  class RescueModifierNode < Node
+    def newline!(lines) # :nodoc:
+      expression.newline!(lines)
+    end
+  end
+
+  class InterpolatedMatchLastLineNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
+    end
+  end
+
+  class InterpolatedRegularExpressionNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
+    end
+  end
+
+  class InterpolatedStringNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
+    end
+  end
 
-    private_constant :Newlines
+  class InterpolatedSymbolNode < Node
+    def newline!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(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!(lines) # :nodoc:
+      first = parts.first
+      first.newline!(lines) if first
     end
   end
 end

data/lib/prism/parse_result.rb

@@ -574,6 +574,12 @@ module Prism
 
   # This is a result specific to the `parse` and `parse_file` methods.
   class ParseResult < Result
+    autoload :Comments, "prism/parse_result/comments"
+    autoload :Newlines, "prism/parse_result/newlines"
+
+    private_constant :Comments
+    private_constant :Newlines
+
     # The syntax tree that was parsed from the source code.
     attr_reader :value
 
@@ -587,6 +593,17 @@ 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
   end
 
   # This is a result specific to the `lex` and `lex_file` methods.

data/lib/prism/reflection.rb

@@ -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

data/lib/prism/serialize.rb

@@ -18,7 +18,7 @@ module Prism
 
     # The minor version of prism that we are expecting to find in the serialized
     # strings.
-    MINOR_VERSION = 29
+    MINOR_VERSION = 30
 
     # The patch version of prism that we are expecting to find in the serialized
     # strings.
@@ -240,6 +240,7 @@ module Prism
         :expression_not_writable_file,
         :expression_not_writable_line,
         :expression_not_writable_nil,
+        :expression_not_writable_numbered,
         :expression_not_writable_self,
         :expression_not_writable_true,
         :float_parse,
@@ -279,6 +280,7 @@ module Prism
         :invalid_number_underscore_inner,
         :invalid_number_underscore_trailing,
         :invalid_percent,
+        :invalid_percent_eof,
         :invalid_printable_character,
         :invalid_retry_after_else,
         :invalid_retry_after_ensure,
@@ -310,9 +312,10 @@ module Prism
         :no_local_variable,
         :not_expression,
         :number_literal_underscore,
+        :numbered_parameter_inner_block,
         :numbered_parameter_it,
         :numbered_parameter_ordinary,
-        :numbered_parameter_outer_scope,
+        :numbered_parameter_outer_block,
         :operator_multi_assign,
         :operator_write_arguments,
         :operator_write_block,
@@ -329,8 +332,8 @@ module Prism
         :parameter_splat_multi,
         :parameter_star,
         :parameter_unexpected_fwd,
-        :parameter_wild_loose_comma,
         :parameter_unexpected_no_kw,
+        :parameter_wild_loose_comma,
         :pattern_capture_duplicate,
         :pattern_expression_after_bracket,
         :pattern_expression_after_comma,
@@ -359,6 +362,7 @@ module Prism
         :regexp_incompat_char_encoding,
         :regexp_invalid_unicode_range,
         :regexp_non_escaped_mbc,
+        :regexp_parse_error,
         :regexp_term,
         :regexp_unknown_options,
         :regexp_utf8_char_non_utf8_regexp,
@@ -398,6 +402,7 @@ module Prism
         :write_target_readonly,
         :write_target_unexpected,
         :xstring_term,
+        :ambiguous_binary_operator,
         :ambiguous_first_argument_minus,
         :ambiguous_first_argument_plus,
         :ambiguous_prefix_ampersand,
@@ -891,192 +896,195 @@ module Prism
             InterpolatedXStringNode.new(
               source, load_location, Array.new(load_varuint) { load_node }, load_location, location)
           when 88 then
-            ItParametersNode.new(
+            ItLocalVariableReadNode.new(
               source, location)
           when 89 then
+            ItParametersNode.new(
+              source, location)
+          when 90 then
             KeywordHashNode.new(
               source, load_varuint, Array.new(load_varuint) { load_node }, location)
-          when 90 then
+          when 91 then
             KeywordRestParameterNode.new(
               source, load_varuint, load_optional_constant, load_optional_location, load_location, location)
-          when 91 then
+          when 92 then
             LambdaNode.new(
               source, Array.new(load_varuint) { load_required_constant }, load_location, load_location, load_location, load_optional_node, load_optional_node, location)
-          when 92 then
+          when 93 then
             LocalVariableAndWriteNode.new(
               source, load_location, load_location, load_node, load_required_constant, load_varuint, location)
-          when 93 then
+          when 94 then
             LocalVariableOperatorWriteNode.new(
               source, load_location, load_location, load_node, load_required_constant, load_required_constant, load_varuint, location)
-          when 94 then
+          when 95 then
             LocalVariableOrWriteNode.new(
               source, load_location, load_location, load_node, load_required_constant, load_varuint, location)
-          when 95 then
+          when 96 then
             LocalVariableReadNode.new(
               source, load_required_constant, load_varuint, location)
-          when 96 then
+          when 97 then
             LocalVariableTargetNode.new(
               source, load_required_constant, load_varuint, location)
-          when 97 then
+          when 98 then
             LocalVariableWriteNode.new(
               source, load_required_constant, load_varuint, load_location, load_node, load_location, location)
-          when 98 then
+          when 99 then
             MatchLastLineNode.new(
               source, load_varuint, load_location, load_location, load_location, load_string, location)
-          when 99 then
+          when 100 then
             MatchPredicateNode.new(
               source, load_node, load_node, load_location, location)
-          when 100 then
+          when 101 then
             MatchRequiredNode.new(
               source, load_node, load_node, load_location, location)
-          when 101 then
+          when 102 then
             MatchWriteNode.new(
               source, load_node, Array.new(load_varuint) { load_node }, location)
-          when 102 then
+          when 103 then
             MissingNode.new(
               source, location)
-          when 103 then
+          when 104 then
             ModuleNode.new(
               source, Array.new(load_varuint) { load_required_constant }, load_location, load_node, load_optional_node, load_location, load_required_constant, location)
-          when 104 then
+          when 105 then
             MultiTargetNode.new(
               source, Array.new(load_varuint) { load_node }, load_optional_node, Array.new(load_varuint) { load_node }, load_optional_location, load_optional_location, location)
-          when 105 then
+          when 106 then
             MultiWriteNode.new(
               source, Array.new(load_varuint) { load_node }, load_optional_node, Array.new(load_varuint) { load_node }, load_optional_location, load_optional_location, load_location, load_node, location)
-          when 106 then
+          when 107 then
             NextNode.new(
               source, load_optional_node, load_location, location)
-          when 107 then
+          when 108 then
             NilNode.new(
               source, location)
-          when 108 then
+          when 109 then
             NoKeywordsParameterNode.new(
               source, load_location, load_location, location)
-          when 109 then
+          when 110 then
             NumberedParametersNode.new(
               source, io.getbyte, location)
-          when 110 then
+          when 111 then
             NumberedReferenceReadNode.new(
               source, load_varuint, location)
-          when 111 then
+          when 112 then
             OptionalKeywordParameterNode.new(
               source, load_varuint, load_required_constant, load_location, load_node, location)
-          when 112 then
+          when 113 then
             OptionalParameterNode.new(
               source, load_varuint, load_required_constant, load_location, load_location, load_node, location)
-          when 113 then
+          when 114 then
             OrNode.new(
               source, load_node, load_node, load_location, location)
-          when 114 then
+          when 115 then
             ParametersNode.new(
               source, Array.new(load_varuint) { load_node }, Array.new(load_varuint) { load_node }, load_optional_node, Array.new(load_varuint) { load_node }, Array.new(load_varuint) { load_node }, load_optional_node, load_optional_node, location)
-          when 115 then
+          when 116 then
             ParenthesesNode.new(
               source, load_optional_node, load_location, load_location, location)
-          when 116 then
+          when 117 then
             PinnedExpressionNode.new(
               source, load_node, load_location, load_location, load_location, location)
-          when 117 then
+          when 118 then
             PinnedVariableNode.new(
               source, load_node, load_location, location)
-          when 118 then
+          when 119 then
             PostExecutionNode.new(
               source, load_optional_node, load_location, load_location, load_location, location)
-          when 119 then
+          when 120 then
             PreExecutionNode.new(
               source, load_optional_node, load_location, load_location, load_location, location)
-          when 120 then
+          when 121 then
             ProgramNode.new(
               source, Array.new(load_varuint) { load_required_constant }, load_node, location)
-          when 121 then
+          when 122 then
             RangeNode.new(
               source, load_varuint, load_optional_node, load_optional_node, load_location, location)
-          when 122 then
-            RationalNode.new(
-              source, load_node, location)
           when 123 then
+            RationalNode.new(
+              source, load_varuint, load_integer, load_integer, location)
+          when 124 then
             RedoNode.new(
               source, location)
-          when 124 then
+          when 125 then
             RegularExpressionNode.new(
               source, load_varuint, load_location, load_location, load_location, load_string, location)
-          when 125 then
+          when 126 then
             RequiredKeywordParameterNode.new(
               source, load_varuint, load_required_constant, load_location, location)
-          when 126 then
+          when 127 then
             RequiredParameterNode.new(
               source, load_varuint, load_required_constant, location)
-          when 127 then
+          when 128 then
             RescueModifierNode.new(
               source, load_node, load_location, load_node, location)
-          when 128 then
+          when 129 then
             RescueNode.new(
               source, load_location, Array.new(load_varuint) { load_node }, load_optional_location, load_optional_node, load_optional_node, load_optional_node, location)
-          when 129 then
+          when 130 then
             RestParameterNode.new(
               source, load_varuint, load_optional_constant, load_optional_location, load_location, location)
-          when 130 then
+          when 131 then
             RetryNode.new(
               source, location)
-          when 131 then
+          when 132 then
             ReturnNode.new(
               source, load_varuint, load_location, load_optional_node, location)
-          when 132 then
+          when 133 then
             SelfNode.new(
               source, location)
-          when 133 then
+          when 134 then
             ShareableConstantNode.new(
               source, load_varuint, load_node, location)
-          when 134 then
+          when 135 then
             SingletonClassNode.new(
               source, Array.new(load_varuint) { load_required_constant }, load_location, load_location, load_node, load_optional_node, load_location, location)
-          when 135 then
+          when 136 then
             SourceEncodingNode.new(
               source, location)
-          when 136 then
+          when 137 then
             SourceFileNode.new(
               source, load_varuint, load_string, location)
-          when 137 then
+          when 138 then
             SourceLineNode.new(
               source, location)
-          when 138 then
+          when 139 then
             SplatNode.new(
               source, load_location, load_optional_node, location)
-          when 139 then
+          when 140 then
             StatementsNode.new(
               source, Array.new(load_varuint) { load_node }, location)
-          when 140 then
+          when 141 then
             StringNode.new(
               source, load_varuint, load_optional_location, load_location, load_optional_location, load_string, location)
-          when 141 then
+          when 142 then
             SuperNode.new(
               source, load_location, load_optional_location, load_optional_node, load_optional_location, load_optional_node, location)
-          when 142 then
+          when 143 then
             SymbolNode.new(
               source, load_varuint, load_optional_location, load_optional_location, load_optional_location, load_string, location)
-          when 143 then
+          when 144 then
             TrueNode.new(
               source, location)
-          when 144 then
+          when 145 then
             UndefNode.new(
               source, Array.new(load_varuint) { load_node }, load_location, location)
-          when 145 then
+          when 146 then
             UnlessNode.new(
               source, load_location, load_node, load_optional_location, load_optional_node, load_optional_node, load_optional_location, location)
-          when 146 then
+          when 147 then
             UntilNode.new(
               source, load_varuint, load_location, load_optional_location, load_node, load_optional_node, location)
-          when 147 then
+          when 148 then
             WhenNode.new(
               source, load_location, Array.new(load_varuint) { load_node }, load_optional_location, load_optional_node, location)
-          when 148 then
+          when 149 then
             WhileNode.new(
               source, load_varuint, load_location, load_optional_location, load_node, load_optional_node, location)
-          when 149 then
+          when 150 then
             XStringNode.new(
               source, load_varuint, load_location, load_location, load_location, load_string, location)
-          when 150 then
+          when 151 then
             YieldNode.new(
               source, load_location, load_optional_location, load_optional_node, load_optional_location, location)
           end
@@ -1526,6 +1534,11 @@ module Prism
               InterpolatedXStringNode.new(
                 source, load_location, Array.new(load_varuint) { load_node }, load_location, location)
             },
+            -> {
+              location = load_location
+              ItLocalVariableReadNode.new(
+                source, location)
+            },
             -> {
               location = load_location
               ItParametersNode.new(
@@ -1699,7 +1712,7 @@ module Prism
             -> {
               location = load_location
               RationalNode.new(
-                source, load_node, location)
+                source, load_varuint, load_integer, load_integer, location)
             },
             -> {
               location = load_location