jruby-prism-parser 0.24.0-java → 1.4.0-java

data/lib/prism/lex_compat.rb

@@ -10,6 +10,23 @@ module Prism
   # generally lines up. However, there are a few cases that require special
   # handling.
   class LexCompat # :nodoc:
+    # A result class specialized for holding tokens produced by the lexer.
+    class Result < Prism::Result
+      # The list of tokens that were produced by the lexer.
+      attr_reader :value
+
+      # Create a new lex compat result object with the given values.
+      def initialize(value, comments, magic_comments, data_loc, errors, warnings, source)
+        @value = value
+        super(comments, magic_comments, data_loc, errors, warnings, source)
+      end
+
+      # Implement the hash pattern matching interface for Result.
+      def deconstruct_keys(keys)
+        super.merge!(value: value)
+      end
+    end
+
     # This is a mapping of prism token types to Ripper token types. This is a
     # many-to-one mapping because we split up our token types, whereas Ripper
     # tends to group them.
@@ -185,6 +202,8 @@ module Prism
     # However, we add a couple of convenience methods onto them to make them a
     # little easier to work with. We delegate all other methods to the array.
     class Token < SimpleDelegator
+      # @dynamic initialize, each, []
+
       # The location of the token in the source.
       def location
         self[0]
@@ -241,10 +260,10 @@ module Prism
       def ==(other) # :nodoc:
         return false unless self[0...-1] == other[0...-1]
 
-        if self[4] == Ripper::EXPR_ARG | Ripper::EXPR_LABELED
-          other[4] & Ripper::EXPR_ARG | Ripper::EXPR_LABELED > 0
+        if self[3] == Ripper::EXPR_ARG | Ripper::EXPR_LABELED
+          other[3] & Ripper::EXPR_ARG | Ripper::EXPR_LABELED != 0
         else
-          self[4] == other[4]
+          self[3] == other[3]
         end
       end
     end
@@ -308,7 +327,7 @@ module Prism
         def to_a
           embexpr_balance = 0
 
-          tokens.each_with_object([]) do |token, results|
+          tokens.each_with_object([]) do |token, results| #$ Array[Token]
             case token.event
             when :on_embexpr_beg
               embexpr_balance += 1
@@ -409,7 +428,7 @@ module Prism
           # If every line in the heredoc is blank, we still need to split up the
           # string content token into multiple tokens.
           if dedent.nil?
-            results = []
+            results = [] #: Array[Token]
             embexpr_balance = 0
 
             tokens.each do |token|
@@ -444,7 +463,7 @@ module Prism
           # If the minimum common whitespace is 0, then we need to concatenate
           # string nodes together that are immediately adjacent.
           if dedent == 0
-            results = []
+            results = [] #: Array[Token]
             embexpr_balance = 0
 
             index = 0
@@ -462,7 +481,7 @@ module Prism
                 embexpr_balance -= 1
               when :on_tstring_content
                 if embexpr_balance == 0
-                  while index < max_index && tokens[index].event == :on_tstring_content
+                  while index < max_index && tokens[index].event == :on_tstring_content && !token.value.match?(/\\\r?\n\z/)
                     token.value << tokens[index].value
                     index += 1
                   end
@@ -477,7 +496,7 @@ module Prism
           # insert on_ignored_sp tokens for the amount of dedent that we need to
           # perform. We also need to remove the dedent from the beginning of
           # each line of plain string content tokens.
-          results = []
+          results = [] #: Array[Token]
           dedent_next = true
           embexpr_balance = 0
 
@@ -526,7 +545,7 @@ module Prism
                   # dedent from the beginning of the line.
                   if (dedent > 0) && (dedent_next || index > 0)
                     deleting = 0
-                    deleted_chars = []
+                    deleted_chars = [] #: Array[String]
 
                     # Gather up all of the characters that we're going to
                     # delete, stopping when you hit a character that would put
@@ -603,15 +622,15 @@ module Prism
     end
 
     def result
-      tokens = []
+      tokens = [] #: Array[LexCompat::Token]
 
       state = :default
-      heredoc_stack = [[]]
+      heredoc_stack = [[]] #: Array[Array[Heredoc::PlainHeredoc | Heredoc::DashHeredoc | Heredoc::DedentingHeredoc]]
 
       result = Prism.lex(source, **options)
       result_value = result.value
-      previous_state = nil
-      last_heredoc_end = nil
+      previous_state = nil #: Ripper::Lexer::State?
+      last_heredoc_end = nil #: Integer?
 
       # In previous versions of Ruby, Ripper wouldn't flush the bom before the
       # first token, so we had to have a hack in place to account for that. This
@@ -842,7 +861,7 @@ module Prism
       # We sort by location to compare against Ripper's output
       tokens.sort_by!(&:location)
 
-      ParseResult.new(tokens, result.comments, result.magic_comments, result.data_loc, result.errors, result.warnings, [])
+      Result.new(tokens, result.comments, result.magic_comments, result.data_loc, result.errors, result.warnings, Source.for(source))
     end
   end
 
@@ -858,8 +877,8 @@ module Prism
     end
 
     def result
-      previous = []
-      results = []
+      previous = [] #: [[Integer, Integer], Symbol, String, untyped] | []
+      results = [] #: Array[[[Integer, Integer], Symbol, String, untyped]]
 
       lex(source).each do |token|
         case token[1]

data/lib/prism/mutation_compiler.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 =begin
 This file is generated by the templates/template.rb script and should not be
 modified manually. See templates/lib/prism/mutation_compiler.rb.erb
@@ -127,12 +128,12 @@ module Prism
 
     # Copy a CaseMatchNode node
     def visit_case_match_node(node)
-      node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), consequent: visit(node.consequent))
+      node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), else_clause: visit(node.else_clause))
     end
 
     # Copy a CaseNode node
     def visit_case_node(node)
-      node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), consequent: visit(node.consequent))
+      node.copy(predicate: visit(node.predicate), conditions: visit_all(node.conditions), else_clause: visit(node.else_clause))
     end
 
     # Copy a ClassNode node
@@ -192,7 +193,7 @@ module Prism
 
     # Copy a ConstantPathNode node
     def visit_constant_path_node(node)
-      node.copy(parent: visit(node.parent), child: visit(node.child))
+      node.copy(parent: visit(node.parent))
     end
 
     # Copy a ConstantPathOperatorWriteNode node
@@ -207,7 +208,7 @@ module Prism
 
     # Copy a ConstantPathTargetNode node
     def visit_constant_path_target_node(node)
-      node.copy(parent: visit(node.parent), child: visit(node.child))
+      node.copy(parent: visit(node.parent))
     end
 
     # Copy a ConstantPathWriteNode node
@@ -342,7 +343,7 @@ module Prism
 
     # Copy a IfNode node
     def visit_if_node(node)
-      node.copy(predicate: visit(node.predicate), statements: visit(node.statements), consequent: visit(node.consequent))
+      node.copy(predicate: visit(node.predicate), statements: visit(node.statements), subsequent: visit(node.subsequent))
     end
 
     # Copy a ImaginaryNode node
@@ -445,6 +446,16 @@ module Prism
       node.copy(parts: visit_all(node.parts))
     end
 
+    # Copy a ItLocalVariableReadNode node
+    def visit_it_local_variable_read_node(node)
+      node.copy
+    end
+
+    # Copy a ItParametersNode node
+    def visit_it_parameters_node(node)
+      node.copy
+    end
+
     # Copy a KeywordHashNode node
     def visit_keyword_hash_node(node)
       node.copy(elements: visit_all(node.elements))
@@ -612,7 +623,7 @@ module Prism
 
     # Copy a RationalNode node
     def visit_rational_node(node)
-      node.copy(numeric: visit(node.numeric))
+      node.copy
     end
 
     # Copy a RedoNode node
@@ -642,7 +653,7 @@ module Prism
 
     # Copy a RescueNode node
     def visit_rescue_node(node)
-      node.copy(exceptions: visit_all(node.exceptions), reference: visit(node.reference), statements: visit(node.statements), consequent: visit(node.consequent))
+      node.copy(exceptions: visit_all(node.exceptions), reference: visit(node.reference), statements: visit(node.statements), subsequent: visit(node.subsequent))
     end
 
     # Copy a RestParameterNode node
@@ -665,6 +676,11 @@ module Prism
       node.copy
     end
 
+    # Copy a ShareableConstantNode node
+    def visit_shareable_constant_node(node)
+      node.copy(write: visit(node.write))
+    end
+
     # Copy a SingletonClassNode node
     def visit_singleton_class_node(node)
       node.copy(expression: visit(node.expression), body: visit(node.body))
@@ -722,7 +738,7 @@ module Prism
 
     # Copy a UnlessNode node
     def visit_unless_node(node)
-      node.copy(predicate: visit(node.predicate), statements: visit(node.statements), consequent: visit(node.consequent))
+      node.copy(predicate: visit(node.predicate), statements: visit(node.statements), else_clause: visit(node.else_clause))
     end
 
     # Copy a UntilNode node