Support the tailcall_optimization flag

Author: kddnewton

lib/syntax_tree/yarv/compiler.rb

@@ -54,20 +54,23 @@ def initialize(
           frozen_string_literal: false,
           inline_const_cache: true,
           operands_unification: true,
-          specialized_instruction: true
+          specialized_instruction: true,
+          tailcall_optimization: false
         )
           @frozen_string_literal = frozen_string_literal
           @inline_const_cache = inline_const_cache
           @operands_unification = operands_unification
           @specialized_instruction = specialized_instruction
+          @tailcall_optimization = tailcall_optimization
         end
 
         def to_hash
           {
             frozen_string_literal: @frozen_string_literal,
             inline_const_cache: @inline_const_cache,
             operands_unification: @operands_unification,
-            specialized_instruction: @specialized_instruction
+            specialized_instruction: @specialized_instruction,
+            tailcall_optimization: @tailcall_optimization
           }
         end
 
@@ -90,6 +93,10 @@ def operands_unification?
         def specialized_instruction?
           @specialized_instruction
         end
+
+        def tailcall_optimization?
+          @tailcall_optimization
+        end
       end
 
       # This visitor is responsible for converting Syntax Tree nodes into their
@@ -716,12 +723,17 @@ def visit_call(node)
           end
         end
 
+        # Track whether or not this is a method call on a block proxy receiver.
+        # If it is, we can potentially do tailcall optimizations on it.
+        block_receiver = false
+
         if node.receiver
           if node.receiver.is_a?(VarRef)
             lookup = iseq.local_variable(node.receiver.value.value.to_sym)
 
             if lookup.local.is_a?(LocalTable::BlockLocal)
               iseq.getblockparamproxy(lookup.index, lookup.level)
+              block_receiver = true
             else
               visit(node.receiver)
             end
@@ -752,6 +764,7 @@ def visit_call(node)
           when ArgsForward
             flag |= CallData::CALL_ARGS_SPLAT
             flag |= CallData::CALL_ARGS_BLOCKARG
+            flag |= CallData::CALL_TAILCALL if options.tailcall_optimization?
 
             lookup = iseq.local_table.find(:*)
             iseq.getlocal(lookup.index, lookup.level)
@@ -768,9 +781,22 @@ def visit_call(node)
         end
 
         block_iseq = visit(node.block) if node.block
+
+        # If there's no block and we don't already have any special flags set,
+        # then we can safely call this simple arguments. Note that has to be the
+        # first flag we set after looking at the arguments to get the flags
+        # correct.
         flag |= CallData::CALL_ARGS_SIMPLE if block_iseq.nil? && flag == 0
+
+        # If there's no receiver, then this is an "fcall".
         flag |= CallData::CALL_FCALL if node.receiver.nil?
 
+        # If we're calling a method on the passed block object and we have
+        # tailcall optimizations turned on, then we can set the tailcall flag.
+        if block_receiver && options.tailcall_optimization?
+          flag |= CallData::CALL_TAILCALL
+        end
+
         iseq.send(
           YARV.calldata(node.message.value.to_sym, argc, flag),
           block_iseq

test/compiler_test.rb

@@ -433,14 +433,14 @@ class CompilerTest < Minitest::Test
       YARV::Compiler::Options.new(operands_unification: false),
       YARV::Compiler::Options.new(specialized_instruction: false),
       YARV::Compiler::Options.new(inline_const_cache: false),
-      YARV::Compiler::Options.new(operands_unification: false, specialized_instruction: false)
+      YARV::Compiler::Options.new(tailcall_optimization: true)
     ]
 
     OPTIONS.each do |options|
-      suffix = options.inspect
+      suffix = options.to_hash.map { |k, v| "#{k}=#{v}" }.join("&")
 
       CASES.each do |source|
-        define_method(:"test_#{source}_#{suffix}") do
+        define_method(:"test_#{source}_(#{suffix})") do
           assert_compiles(source, options)
         end
       end