Support opt_newarray_send

Author: kddnewton

lib/syntax_tree/yarv/instruction_sequence.rb

@@ -353,11 +353,27 @@ def specialize_instructions!
             next unless calldata.argc == 0
 
             case calldata.method
+            when :min
+              node.value =
+                if RUBY_VERSION < "3.3"
+                  Legacy::OptNewArrayMin.new(value.number)
+                else
+                  OptNewArraySend.new(value.number, :min)
+                end
+
+              node.next_node = next_node.next_node
             when :max
-              node.value = OptNewArrayMax.new(value.number)
+              node.value =
+                if RUBY_VERSION < "3.3"
+                  Legacy::OptNewArrayMax.new(value.number)
+                else
+                  OptNewArraySend.new(value.number, :max)
+                end
+
               node.next_node = next_node.next_node
-            when :min
-              node.value = OptNewArrayMin.new(value.number)
+            when :hash
+              next if RUBY_VERSION < "3.3"
+              node.value = OptNewArraySend.new(value.number, :hash)
               node.next_node = next_node.next_node
             end
           when PutObject, PutString
@@ -1174,6 +1190,9 @@ def self.from(source, options = Compiler::Options.new, parent_iseq = nil)
           when :opt_newarray_min
             iseq.newarray(opnds[0])
             iseq.send(YARV.calldata(:min))
+          when :opt_newarray_send
+            iseq.newarray(opnds[0])
+            iseq.send(CallData.new(opnds[1]))
           when :opt_neq
             iseq.push(
               OptNEq.new(CallData.from(opnds[0]), CallData.from(opnds[1]))

lib/syntax_tree/yarv/instructions.rb

@@ -3818,93 +3818,47 @@ def call(vm)
 
     # ### Summary
     #
-    # `opt_newarray_max` is a specialization that occurs when the `max` method
-    # is called on an array literal. It pops the values of the array off the
-    # stack and pushes on the result.
+    # `opt_newarray_send` is a specialization that occurs when a dynamic array
+    # literal is created and immediately sent the `min`, `max`, or `hash`
+    # methods. It pops the values of the array off the stack and pushes on the
+    # result of the method call.
     #
     # ### Usage
     #
     # ~~~ruby
     # [a, b, c].max
     # ~~~
     #
-    class OptNewArrayMax < Instruction
-      attr_reader :number
-
-      def initialize(number)
-        @number = number
-      end
-
-      def disasm(fmt)
-        fmt.instruction("opt_newarray_max", [fmt.object(number)])
-      end
-
-      def to_a(_iseq)
-        [:opt_newarray_max, number]
-      end
-
-      def deconstruct_keys(_keys)
-        { number: number }
-      end
-
-      def ==(other)
-        other.is_a?(OptNewArrayMax) && other.number == number
-      end
-
-      def length
-        2
-      end
-
-      def pops
-        number
-      end
+    class OptNewArraySend < Instruction
+      attr_reader :number, :method
 
-      def pushes
-        1
-      end
-
-      def call(vm)
-        vm.push(vm.pop(number).max)
-      end
-    end
-
-    # ### Summary
-    #
-    # `opt_newarray_min` is a specialization that occurs when the `min` method
-    # is called on an array literal. It pops the values of the array off the
-    # stack and pushes on the result.
-    #
-    # ### Usage
-    #
-    # ~~~ruby
-    # [a, b, c].min
-    # ~~~
-    #
-    class OptNewArrayMin < Instruction
-      attr_reader :number
-
-      def initialize(number)
+      def initialize(number, method)
         @number = number
+        @method = method
       end
 
       def disasm(fmt)
-        fmt.instruction("opt_newarray_min", [fmt.object(number)])
+        fmt.instruction(
+          "opt_newarray_send",
+          [fmt.object(number), fmt.object(method)]
+        )
       end
 
       def to_a(_iseq)
-        [:opt_newarray_min, number]
+        [:opt_newarray_send, number, method]
       end
 
       def deconstruct_keys(_keys)
-        { number: number }
+        { number: number, method: method }
       end
 
       def ==(other)
-        other.is_a?(OptNewArrayMin) && other.number == number
+        other.is_a?(OptNewArraySend) && other.number == number &&
+          other.method == method
       end
 
       def length
-        2
+        3
       end
 
       def pops
@@ -3916,7 +3870,7 @@ def pushes
       end
 
       def call(vm)
-        vm.push(vm.pop(number).min)
+        vm.push(vm.pop(number).__send__(method))
       end
     end
 

lib/syntax_tree/yarv/legacy.rb

@@ -124,6 +124,110 @@ def falls_through?
         end
       end
 
+      # ### Summary
+      #
+      # `opt_newarray_max` is a specialization that occurs when the `max` method
+      # is called on an array literal. It pops the values of the array off the
+      # stack and pushes on the result.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # [a, b, c].max
+      # ~~~
+      #
+      class OptNewArrayMax < Instruction
+        attr_reader :number
+
+        def initialize(number)
+          @number = number
+        end
+
+        def disasm(fmt)
+          fmt.instruction("opt_newarray_max", [fmt.object(number)])
+        end
+
+        def to_a(_iseq)
+          [:opt_newarray_max, number]
+        end
+
+        def deconstruct_keys(_keys)
+          { number: number }
+        end
+
+        def ==(other)
+          other.is_a?(OptNewArrayMax) && other.number == number
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          number
+        end
+
+        def pushes
+          1
+        end
+
+        def call(vm)
+          vm.push(vm.pop(number).max)
+        end
+      end
+
+      # ### Summary
+      #
+      # `opt_newarray_min` is a specialization that occurs when the `min` method
+      # is called on an array literal. It pops the values of the array off the
+      # stack and pushes on the result.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # [a, b, c].min
+      # ~~~
+      #
+      class OptNewArrayMin < Instruction
+        attr_reader :number
+
+        def initialize(number)
+          @number = number
+        end
+
+        def disasm(fmt)
+          fmt.instruction("opt_newarray_min", [fmt.object(number)])
+        end
+
+        def to_a(_iseq)
+          [:opt_newarray_min, number]
+        end
+
+        def deconstruct_keys(_keys)
+          { number: number }
+        end
+
+        def ==(other)
+          other.is_a?(OptNewArrayMin) && other.number == number
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          number
+        end
+
+        def pushes
+          1
+        end
+
+        def call(vm)
+          vm.push(vm.pop(number).min)
+        end
+      end
+
       # ### Summary
       #
       # `opt_setinlinecache` sets an inline cache for a constant lookup. It pops

test/compiler_test.rb

@@ -311,6 +311,12 @@ class CompilerTest < Minitest::Test
       "[1, 2, 3].min",
       "[foo, bar, baz].min",
       "[foo, bar, baz].min(1)",
+      "[1, 2, 3].hash",
+      "[foo, bar, baz].hash",
+      "[foo, bar, baz].hash(1)",
+      "[1, 2, 3].foo",
+      "[foo, bar, baz].foo",
+      "[foo, bar, baz].foo(1)",
       "[**{ x: true }][0][:x]",
       # Core method calls
       "alias foo bar",