Fixes so bundle exec rake can run on JRuby and TruffleRuby

Author: eregon

Rakefile

@@ -37,7 +37,14 @@ task build: [:templates, :check_manifest]
 # the C extension
 task "compile:yarp" => ["templates"] # must be before the ExtensionTask is created
 
-if RUBY_ENGINE == 'jruby'
+if RUBY_ENGINE == 'ruby' and ENV["YARP_FIDDLE_BACKEND"] != "true"
+  Rake::ExtensionTask.new(:compile) do |ext|
+    ext.name = "yarp"
+    ext.ext_dir = "ext/yarp"
+    ext.lib_dir = "lib/yarp"
+    ext.gem_spec = Gem::Specification.load("yarp.gemspec")
+  end
+elsif RUBY_ENGINE == 'jruby'
   require 'rake/javaextensiontask'
 
   # This compiles java to make sure any templating changes produces valid code.
@@ -49,13 +56,6 @@ if RUBY_ENGINE == 'jruby'
     ext.target_version = "1.8"
     ext.gem_spec = Gem::Specification.load("yarp.gemspec")
   end
-else
-  Rake::ExtensionTask.new(:compile) do |ext|
-    ext.name = "yarp"
-    ext.ext_dir = "ext/yarp"
-    ext.lib_dir = "lib/yarp"
-    ext.gem_spec = Gem::Specification.load("yarp.gemspec")
-  end
 end
 
 # So `rake clobber` will delete generated files

lib/yarp/ripper_compat.rb

@@ -47,9 +47,9 @@ def _dispatch_event_push(list, item)
       Ripper::PARSER_EVENT_TABLE.each do |event, arity|
         case event
         when /_new\z/
-          alias :"on_#{event}" :_dispatch_event_new if arity == 0
+          alias_method :"on_#{event}", :_dispatch_event_new if arity == 0
         when /_add\z/
-          alias :"on_#{event}" :_dispatch_event_push
+          alias_method :"on_#{event}", :_dispatch_event_push
         end
       end
     end
@@ -168,7 +168,7 @@ def _dispatch5(_, _, _, _, _); end
     def _dispatch7(_, _, _, _, _, _, _); end
 
     (Ripper::SCANNER_EVENT_TABLE.merge(Ripper::PARSER_EVENT_TABLE)).each do |event, arity|
-      alias :"on_#{event}" :"_dispatch#{arity}"
+      alias_method :"on_#{event}", :"_dispatch#{arity}"
     end
   end
 end

templates/include/yarp/ast.h.erb

@@ -84,14 +84,15 @@ typedef struct yp_<%= node.human %> {
     yp_node_t base;
 <%- node.params.grep_v(FlagsParam).each do |param| -%>
     <%= case param
-    in NodeParam | OptionalNodeParam then "struct #{param.c_type} *#{param.name}"
-    in NodeListParam then "struct yp_node_list #{param.name}"
-    in LocationListParam then "yp_location_list_t #{param.name}"
-    in ConstantParam then "yp_constant_id_t #{param.name}"
-    in ConstantListParam then "yp_constant_id_list_t #{param.name}"
-    in StringParam then "yp_string_t #{param.name}"
-    in LocationParam | OptionalLocationParam then "yp_location_t #{param.name}"
-    in UInt32Param then "uint32_t #{param.name}"
+    when NodeParam, OptionalNodeParam then "struct #{param.c_type} *#{param.name}"
+    when NodeListParam then "struct yp_node_list #{param.name}"
+    when LocationListParam then "yp_location_list_t #{param.name}"
+    when ConstantParam then "yp_constant_id_t #{param.name}"
+    when ConstantListParam then "yp_constant_id_list_t #{param.name}"
+    when StringParam then "yp_string_t #{param.name}"
+    when LocationParam, OptionalLocationParam then "yp_location_t #{param.name}"
+    when UInt32Param then "uint32_t #{param.name}"
+    else raise param.class.name
     end
     %>;
 <%- end -%>

templates/java/org/yarp/Nodes.java.erb

@@ -231,13 +231,14 @@ public abstract class Nodes {
         public void setNewLineFlag(Source source, boolean[] newlineMarked) {
           <%- param = node.params.find { |p| p.name == node.newline } or raise node.newline -%>
           <%- case param -%>
-          <%- in SingleNodeParam -%>
+          <%- when SingleNodeParam -%>
             this.<%= param.name %>.setNewLineFlag(source, newlineMarked);
-          <%- in NodeListParam -%>
+          <%- when NodeListParam -%>
             Node first = this.<%= param.name %>.length > 0 ? this.<%= param.name %>[0] : null;
             if (first != null) {
                 first.setNewLineFlag(source, newlineMarked);
             }
+          <%- else raise param.class.name -%>
           <%- end -%>
         }
         <%- end -%>

templates/lib/yarp/node.rb.erb

@@ -29,11 +29,12 @@ module YARP
     def set_newline_flag(newline_marked)
       <%- param = node.params.find { |p| p.name == node.newline } or raise node.newline -%>
       <%- case param -%>
-      <%- in SingleNodeParam -%>
+      <%- when SingleNodeParam -%>
       <%= param.name %>.set_newline_flag(newline_marked)
-      <%- in NodeListParam -%>
+      <%- when NodeListParam -%>
       first = <%= param.name %>.first
       first.set_newline_flag(newline_marked) if first
+      <%- else raise param.class.name -%>
       <%- end -%>
     end
     <%- end -%>

templates/template.rb

@@ -23,7 +23,9 @@ def c_type
     end
   end
 
-  def java_type = options[:kind] || "Node"
+  def java_type
+    options[:kind] || "Node"
+  end
 
   def java_cast
     if options[:kind]
@@ -39,77 +41,119 @@ def java_cast
 class NodeParam < Param
   include KindTypes
 
-  def rbs_class = "Node"
+  def rbs_class
+    "Node"
+  end
 end
 
 # This represents a parameter to a node that is itself a node and can be
 # optionally null. We pass them as references and store them as references.
 class OptionalNodeParam < Param
   include KindTypes
 
-  def rbs_class = "Node?"
+  def rbs_class
+    "Node?"
+  end
 end
 
 SingleNodeParam = -> (node) { NodeParam === node or OptionalNodeParam === node }
 
 # This represents a parameter to a node that is a list of nodes. We pass them as
 # references and store them as references.
 class NodeListParam < Param
-  def rbs_class = "Array[Node]"
-  def java_type = "Node[]"
+  def rbs_class
+    "Array[Node]"
+  end
+  def java_type
+    "Node[]"
+  end
 end
 
 # This represents a parameter to a node that is a list of locations.
 class LocationListParam < Param
-  def rbs_class = "Array[Location]"
-  def java_type = "Location[]"
+  def rbs_class
+    "Array[Location]"
+  end
+  def java_type
+    "Location[]"
+  end
 end
 
 # This represents a parameter to a node that is the ID of a string interned
 # through the parser's constant pool.
 class ConstantParam < Param
-  def rbs_class = "Symbol"
-  def java_type = "byte[]"
+  def rbs_class
+    "Symbol"
+  end
+  def java_type
+    "byte[]"
+  end
 end
 
 # This represents a parameter to a node that is a list of IDs that are
 # associated with strings interned through the parser's constant pool.
 class ConstantListParam < Param
-  def rbs_class = "Array[Symbol]"
-  def java_type = "byte[][]"
+  def rbs_class
+    "Array[Symbol]"
+  end
+  def java_type
+    "byte[][]"
+  end
 end
 
 # This represents a parameter to a node that is a string.
 class StringParam < Param
-  def rbs_class = "String"
-  def java_type = "byte[]"
+  def rbs_class
+    "String"
+  end
+  def java_type
+    "byte[]"
+  end
 end
 
 # This represents a parameter to a node that is a location.
 class LocationParam < Param
-  def rbs_class = "Location"
-  def java_type = "Location"
+  def rbs_class
+    "Location"
+  end
+  def java_type
+    "Location"
+  end
 end
 
 # This represents a parameter to a node that is a location that is optional.
 class OptionalLocationParam < Param
-  def rbs_class = "Location?"
-  def java_type = "Location"
+  def rbs_class
+    "Location?"
+  end
+  def java_type
+    "Location"
+  end
 end
 
 # This represents an integer parameter.
 class UInt32Param < Param
-  def rbs_class = "Integer"
-  def java_type = "int"
+  def rbs_class
+    "Integer"
+  end
+  def java_type
+    "int"
+  end
 end
 
 # This represents a set of flags. It is very similar to the UInt32Param, but can
 # be directly embedded into the flags field on the struct and provides
 # convenient methods for checking if a flag is set.
 class FlagsParam < Param
-  def rbs_class = "Integer"
-  def java_type = "short"
-  def kind = options.fetch(:kind)
+  def rbs_class
+    "Integer"
+  end
+  def java_type
+    "short"
+  end
+  def kind
+    options.fetch(:kind)
+  end
 end
 
 PARAM_TYPES = {

test/comments_test.rb

@@ -52,7 +52,7 @@ def test_comment_embedded_document_with_content_on_same_line
   def assert_comment(source, type, location)
     result = YARP.parse(source)
     assert result.errors.empty?, result.errors.map(&:message).join("\n")
-    result => YARP::ParseResult[comments: [YARP::Comment[type: type]]]
+    assert_equal result.comments.first.type, type
     assert_equal result.comments.first.location.start_offset, location.begin
     assert_equal result.comments.first.location.end_offset, location.end
   end

test/errors_test.rb

@@ -1080,10 +1080,11 @@ def test_duplicated_parameter_names
   private
 
   def assert_errors(expected, source, errors)
-    assert_nil Ripper.sexp_raw(source)
+    # Ripper behaves differently on JRuby/TruffleRuby, so only check this on CRuby
+    assert_nil Ripper.sexp_raw(source) if RUBY_ENGINE == "ruby"
 
     result = YARP.parse(source)
-    result => YARP::ParseResult[value: YARP::ProgramNode[statements: YARP::StatementsNode[body: [*, node]]]]
+    node = result.value.statements.body.last
 
     assert_equal_nodes(expected, node, compare_location: false)
     assert_equal(errors, result.errors.map { |e| [e.message, e.location.start_offset..e.location.end_offset] })
@@ -1096,7 +1097,6 @@ def assert_error_messages(source, errors)
   end
 
   def expression(source)
-    YARP.parse(source) => YARP::ParseResult[value: YARP::ProgramNode[statements: YARP::StatementsNode[body: [*, node]]]]
-    node
+    YARP.parse(source).value.statements.body.last
   end
 end

test/location_test.rb

@@ -753,9 +753,11 @@ def test_YieldNode
     private
 
     def assert_location(kind, source, expected = 0...source.length)
-      YARP.parse(source) => ParseResult[comments: [], errors: [], value: node]
+      result = YARP.parse(source)
+      assert_equal [], result.comments
+      assert_equal [], result.errors
 
-      node => ProgramNode[statements: [*, node]]
+      node = result.value.statements.body.last
       node = yield node if block_given?
 
       assert_kind_of kind, node

test/parse_test.rb

@@ -30,7 +30,8 @@ def teardown
   end
 
   def test_empty_string
-    YARP.parse("") => YARP::ParseResult[value: YARP::ProgramNode[statements: YARP::StatementsNode[body: []]]]
+    result = YARP.parse("")
+    assert_equal [], result.value.statements.body
   end
 
   known_failures = %w[seattlerb/heredoc_nested.txt]
@@ -98,7 +99,9 @@ def test_parse_takes_file_path
 
       # Finally, assert that we can lex the source and get the same tokens as
       # Ripper.
-      YARP.lex_compat(source) => { errors: [], value: tokens }
+      lex_result = YARP.lex_compat(source)
+      assert_equal [], lex_result.errors
+      tokens = lex_result.value
 
       begin
         YARP.lex_ripper(source).zip(tokens).each do |(ripper, yarp)|