prism 0.29.0 → 1.1.0

data/lib/prism/translation/ripper.rb

@@ -1273,8 +1273,8 @@ module Prism
       def visit_case_node(node)
         predicate = visit(node.predicate)
         clauses =
-          node.conditions.reverse_each.inject(visit(node.consequent)) do |consequent, condition|
-            on_when(*visit(condition), consequent)
+          node.conditions.reverse_each.inject(visit(node.else_clause)) do |current, condition|
+            on_when(*visit(condition), current)
           end
 
         bounds(node.location)
@@ -1286,8 +1286,8 @@ module Prism
       def visit_case_match_node(node)
         predicate = visit(node.predicate)
         clauses =
-          node.conditions.reverse_each.inject(visit(node.consequent)) do |consequent, condition|
-            on_in(*visit(condition), consequent)
+          node.conditions.reverse_each.inject(visit(node.else_clause)) do |current, condition|
+            on_in(*visit(condition), current)
           end
 
         bounds(node.location)
@@ -1908,7 +1908,7 @@ module Prism
         if node.then_keyword == "?"
           predicate = visit(node.predicate)
           truthy = visit(node.statements.body.first)
-          falsy = visit(node.consequent.statements.body.first)
+          falsy = visit(node.subsequent.statements.body.first)
 
           bounds(node.location)
           on_ifop(predicate, truthy, falsy)
@@ -1921,13 +1921,13 @@ module Prism
             else
               visit(node.statements)
             end
-          consequent = visit(node.consequent)
+          subsequent = visit(node.subsequent)
 
           bounds(node.location)
           if node.if_keyword == "if"
-            on_if(predicate, statements, consequent)
+            on_if(predicate, statements, subsequent)
           else
-            on_elsif(predicate, statements, consequent)
+            on_elsif(predicate, statements, subsequent)
           end
         else
           statements = visit(node.statements.body.first)
@@ -1960,7 +1960,7 @@ module Prism
       # ^^^^^^^^^^^^^^^^^^^^^
       def visit_in_node(node)
         # This is a special case where we're not going to call on_in directly
-        # because we don't have access to the consequent. Instead, we'll return
+        # because we don't have access to the subsequent. Instead, we'll return
         # the component parts and let the parent node handle it.
         pattern = visit_pattern_node(node.pattern)
         statements =
@@ -2217,6 +2217,13 @@ module Prism
         end
       end
 
+      # -> { it }
+      #      ^^
+      def visit_it_local_variable_read_node(node)
+        bounds(node.location)
+        on_vcall(on_ident(node.slice))
+      end
+
       # -> { it }
       # ^^^^^^^^^
       def visit_it_parameters_node(node)
@@ -2312,12 +2319,7 @@ module Prism
       # ^^^
       def visit_local_variable_read_node(node)
         bounds(node.location)
-
-        if node.name == :"0it"
-          on_vcall(on_ident(node.slice))
-        else
-          on_var_ref(on_ident(node.slice))
-        end
+        on_var_ref(on_ident(node.slice))
       end
 
       # foo = 1
@@ -2806,10 +2808,10 @@ module Prism
             visit(node.statements)
           end
 
-        consequent = visit(node.consequent)
+        subsequent = visit(node.subsequent)
 
         bounds(node.location)
-        on_rescue(exceptions, reference, statements, consequent)
+        on_rescue(exceptions, reference, statements, subsequent)
       end
 
       # def foo(*bar); end
@@ -3130,10 +3132,10 @@ module Prism
             else
               visit(node.statements)
             end
-          consequent = visit(node.consequent)
+          else_clause = visit(node.else_clause)
 
           bounds(node.location)
-          on_unless(predicate, statements, consequent)
+          on_unless(predicate, statements, else_clause)
         else
           statements = visit(node.statements.body.first)
           predicate = visit(node.predicate)
@@ -3174,7 +3176,7 @@ module Prism
       #           ^^^^^^^^^^^^^
       def visit_when_node(node)
         # This is a special case where we're not going to call on_when directly
-        # because we don't have access to the consequent. Instead, we'll return
+        # because we don't have access to the subsequent. Instead, we'll return
         # the component parts and let the parent node handle it.
         conditions = visit_arguments(node.conditions)
         statements =

data/lib/prism/translation/ruby_parser.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require "ruby_parser"
+begin
+  require "ruby_parser"
+rescue LoadError
+  warn(%q{Error: Unable to load ruby_parser. Add `gem "ruby_parser"` to your Gemfile.})
+  exit(1)
+end
 
 module Prism
   module Translation
@@ -50,7 +55,19 @@ module Prism
         # a and b
         # ^^^^^^^
         def visit_and_node(node)
-          s(node, :and, visit(node.left), visit(node.right))
+          left = visit(node.left)
+
+          if left[0] == :and
+            # ruby_parser has the and keyword as right-associative as opposed to
+            # prism which has it as left-associative. We reverse that
+            # associativity here.
+            nest = left
+            nest = nest[2] while nest[2][0] == :and
+            nest[2] = s(node, :and, nest[2], visit(node.right))
+            left
+          else
+            s(node, :and, left, visit(node.right))
+          end
         end
 
         # []
@@ -130,7 +147,7 @@ module Prism
             end
 
             current = node.rescue_clause
-            until (current = current.consequent).nil?
+            until (current = current.subsequent).nil?
               result << visit(current)
             end
           end
@@ -246,6 +263,11 @@ module Prism
               when RegularExpressionNode, InterpolatedRegularExpressionNode
                 return s(node, :match2, visit(node.receiver), visit(node.arguments.arguments.first))
               end
+
+              case node.arguments.arguments.first
+              when RegularExpressionNode, InterpolatedRegularExpressionNode
+                return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
+              end
             end
           end
 
@@ -325,13 +347,13 @@ module Prism
         # case foo; when bar; end
         # ^^^^^^^^^^^^^^^^^^^^^^^
         def visit_case_node(node)
-          s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.consequent)
+          s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause)
         end
 
         # case foo; in bar; end
         # ^^^^^^^^^^^^^^^^^^^^^
         def visit_case_match_node(node)
-          s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.consequent)
+          s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause)
         end
 
         # class Foo; end
@@ -480,9 +502,9 @@ module Prism
         def visit_constant_path_target_node(node)
           inner =
             if node.parent.nil?
-              s(node, :colon3, node.child.name)
+              s(node, :colon3, node.name)
             else
-              s(node, :colon2, visit(node.parent), node.child.name)
+              s(node, :colon2, visit(node.parent), node.name)
             end
 
           s(node, :const, inner)
@@ -678,7 +700,7 @@ module Prism
         # foo ? bar : baz
         # ^^^^^^^^^^^^^^^
         def visit_if_node(node)
-          s(node, :if, visit(node.predicate), visit(node.statements), visit(node.consequent))
+          s(node, :if, visit(node.predicate), visit(node.statements), visit(node.subsequent))
         end
 
         # 1i
@@ -870,6 +892,15 @@ module Prism
               else
                 visited << result
               end
+            elsif result[0] == :dstr
+              if !visited.empty? && part.parts[0].is_a?(StringNode)
+                # If we are in the middle of an implicitly concatenated string,
+                # we should not have a bare string as the first part. In this
+                # case we need to visit just that first part and then we can
+                # push the rest of the parts onto the visited array.
+                result[1] = visit(part.parts[0])
+              end
+              visited.concat(result[1..-1])
             else
               visited << result
             end
@@ -900,12 +931,23 @@ module Prism
                 results << result
                 state = :interpolated_content
               end
-            else
-              results << result
+            when :interpolated_content
+              if 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
+                results << result
+              end
             end
           end
         end
 
+        # -> { it }
+        #      ^^
+        def visit_it_local_variable_read_node(node)
+          s(node, :call, nil, :it)
+        end
+
         # foo(bar: baz)
         #     ^^^^^^^^
         def visit_keyword_hash_node(node)
@@ -1118,7 +1160,19 @@ module Prism
         # a or b
         # ^^^^^^
         def visit_or_node(node)
-          s(node, :or, visit(node.left), visit(node.right))
+          left = visit(node.left)
+
+          if left[0] == :or
+            # ruby_parser has the or keyword as right-associative as opposed to
+            # prism which has it as left-associative. We reverse that
+            # associativity here.
+            nest = left
+            nest = nest[2] while nest[2][0] == :or
+            nest[2] = s(node, :or, nest[2], visit(node.right))
+            left
+          else
+            s(node, :or, left, visit(node.right))
+          end
         end
 
         # def foo(bar, *baz); end
@@ -1374,7 +1428,13 @@ module Prism
         # "foo"
         # ^^^^^
         def visit_string_node(node)
-          s(node, :str, node.unescaped)
+          unescaped = node.unescaped
+
+          if node.forced_binary_encoding?
+            unescaped.force_encoding(Encoding::BINARY)
+          end
+
+          s(node, :str, unescaped)
         end
 
         # super(foo)
@@ -1416,7 +1476,7 @@ module Prism
         # bar unless foo
         # ^^^^^^^^^^^^^^
         def visit_unless_node(node)
-          s(node, :if, visit(node.predicate), visit(node.consequent), visit(node.statements))
+          s(node, :if, visit(node.predicate), visit(node.else_clause), visit(node.statements))
         end
 
         # until foo; bar end

data/lib/prism/visitor.rb

@@ -313,6 +313,9 @@ module Prism
     # Visit a InterpolatedXStringNode node
     alias visit_interpolated_x_string_node visit_child_nodes
 
+    # Visit a ItLocalVariableReadNode node
+    alias visit_it_local_variable_read_node visit_child_nodes
+
     # Visit a ItParametersNode node
     alias visit_it_parameters_node visit_child_nodes
 

data/lib/prism.rb

@@ -13,7 +13,6 @@ module Prism
 
   autoload :BasicVisitor, "prism/visitor"
   autoload :Compiler, "prism/compiler"
-  autoload :Debug, "prism/debug"
   autoload :DesugarCompiler, "prism/desugar_compiler"
   autoload :Dispatcher, "prism/dispatcher"
   autoload :DotVisitor, "prism/dot_visitor"
@@ -32,7 +31,6 @@ module Prism
   # Some of these constants are not meant to be exposed, so marking them as
   # private here.
 
-  private_constant :Debug
   private_constant :LexCompat
   private_constant :LexRipper
 
@@ -71,8 +69,6 @@ require_relative "prism/polyfill/byteindex"
 require_relative "prism/node"
 require_relative "prism/node_ext"
 require_relative "prism/parse_result"
-require_relative "prism/parse_result/comments"
-require_relative "prism/parse_result/newlines"
 
 # This is a Ruby implementation of the prism parser. If we're running on CRuby
 # and we haven't explicitly set the PRISM_FFI_BACKEND environment variable, then

data/prism.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "prism"
-  spec.version = "0.29.0"
+  spec.version = "1.1.0"
   spec.authors = ["Shopify"]
   spec.email = ["ruby@shopify.com"]
 
@@ -65,12 +65,10 @@ Gem::Specification.new do |spec|
     "include/prism/util/pm_newline_list.h",
     "include/prism/util/pm_strncasecmp.h",
     "include/prism/util/pm_string.h",
-    "include/prism/util/pm_string_list.h",
     "include/prism/util/pm_strpbrk.h",
     "include/prism/version.h",
     "lib/prism.rb",
     "lib/prism/compiler.rb",
-    "lib/prism/debug.rb",
     "lib/prism/desugar_compiler.rb",
     "lib/prism/dispatcher.rb",
     "lib/prism/dot_visitor.rb",
@@ -84,6 +82,7 @@ Gem::Specification.new do |spec|
     "lib/prism/pack.rb",
     "lib/prism/parse_result.rb",
     "lib/prism/parse_result/comments.rb",
+    "lib/prism/parse_result/errors.rb",
     "lib/prism/parse_result/newlines.rb",
     "lib/prism/pattern.rb",
     "lib/prism/polyfill/byteindex.rb",
@@ -96,7 +95,6 @@ Gem::Specification.new do |spec|
     "lib/prism/translation/parser34.rb",
     "lib/prism/translation/parser/compiler.rb",
     "lib/prism/translation/parser/lexer.rb",
-    "lib/prism/translation/parser/rubocop.rb",
     "lib/prism/translation/ripper.rb",
     "lib/prism/translation/ripper/sexp.rb",
     "lib/prism/translation/ripper/shim.rb",
@@ -105,6 +103,7 @@ Gem::Specification.new do |spec|
     "prism.gemspec",
     "rbi/prism.rbi",
     "rbi/prism/compiler.rbi",
+    "rbi/prism/dsl.rbi",
     "rbi/prism/inspect_visitor.rbi",
     "rbi/prism/node_ext.rbi",
     "rbi/prism/node.rbi",
@@ -149,7 +148,6 @@ Gem::Specification.new do |spec|
     "src/util/pm_list.c",
     "src/util/pm_memchr.c",
     "src/util/pm_newline_list.c",
-    "src/util/pm_string_list.c",
     "src/util/pm_string.c",
     "src/util/pm_strncasecmp.c",
     "src/util/pm_strpbrk.c"