syntax_tree 6.1.1 → 6.3.0

data/lib/syntax_tree/yarv/calldata.rb

@@ -5,19 +5,26 @@ module SyntaxTree
     # This is an operand to various YARV instructions that represents the
     # information about a specific call site.
     class CallData
-      CALL_ARGS_SPLAT = 1 << 0
-      CALL_ARGS_BLOCKARG = 1 << 1
-      CALL_FCALL = 1 << 2
-      CALL_VCALL = 1 << 3
-      CALL_ARGS_SIMPLE = 1 << 4
-      CALL_BLOCKISEQ = 1 << 5
-      CALL_KWARG = 1 << 6
-      CALL_KW_SPLAT = 1 << 7
-      CALL_TAILCALL = 1 << 8
-      CALL_SUPER = 1 << 9
-      CALL_ZSUPER = 1 << 10
-      CALL_OPT_SEND = 1 << 11
-      CALL_KW_SPLAT_MUT = 1 << 12
+      flags = %i[
+        CALL_ARGS_SPLAT
+        CALL_ARGS_BLOCKARG
+        CALL_FCALL
+        CALL_VCALL
+        CALL_ARGS_SIMPLE
+        CALL_KWARG
+        CALL_KW_SPLAT
+        CALL_TAILCALL
+        CALL_SUPER
+        CALL_ZSUPER
+        CALL_OPT_SEND
+        CALL_KW_SPLAT_MUT
+      ]
+
+      # Insert the legacy CALL_BLOCKISEQ flag for Ruby 3.2 and earlier.
+      flags.insert(5, :CALL_BLOCKISEQ) if RUBY_VERSION < "3.3"
+
+      # Set the flags as constants on the class.
+      flags.each_with_index { |name, index| const_set(name, 1 << index) }
 
       attr_reader :method, :argc, :flags, :kw_arg
 
@@ -34,7 +41,7 @@ module SyntaxTree
       end
 
       def flag?(mask)
-        (flags & mask) > 0
+        flags.anybits?(mask)
       end
 
       def to_h
@@ -50,7 +57,6 @@ module SyntaxTree
         names << :FCALL if flag?(CALL_FCALL)
         names << :VCALL if flag?(CALL_VCALL)
         names << :ARGS_SIMPLE if flag?(CALL_ARGS_SIMPLE)
-        names << :BLOCKISEQ if flag?(CALL_BLOCKISEQ)
         names << :KWARG if flag?(CALL_KWARG)
         names << :KW_SPLAT if flag?(CALL_KW_SPLAT)
         names << :TAILCALL if flag?(CALL_TAILCALL)

data/lib/syntax_tree/yarv/decompiler.rb

@@ -45,7 +45,7 @@ module SyntaxTree
         when Integer
           Int(value.to_s)
         when Symbol
-          SymbolLiteral(Ident(value.to_s))
+          SymbolLiteral(Ident(value.name))
         end
       end
 
@@ -88,10 +88,10 @@ module SyntaxTree
 
             clause << HashLiteral(LBrace("{"), assocs)
           when GetGlobal
-            clause << VarRef(GVar(insn.name.to_s))
+            clause << VarRef(GVar(insn.name.name))
           when GetLocalWC0
             local = iseq.local_table.locals[insn.index]
-            clause << VarRef(Ident(local.name.to_s))
+            clause << VarRef(Ident(local.name.name))
           when Jump
             clause << Assign(block_label.field, node_for(insn.label.name))
             clause << Next(Args([]))
@@ -123,7 +123,7 @@ module SyntaxTree
             left, right = clause.pop(2)
             clause << Binary(left, :"!=", right)
           when OptSendWithoutBlock
-            method = insn.calldata.method.to_s
+            method = insn.calldata.method.name
             argc = insn.calldata.argc
 
             if insn.calldata.flag?(CallData::CALL_FCALL)
@@ -182,7 +182,7 @@ module SyntaxTree
           when PutSelf
             clause << VarRef(Kw("self"))
           when SetGlobal
-            target = GVar(insn.name.to_s)
+            target = GVar(insn.name.name)
             value = clause.pop
 
             clause << if value.is_a?(Binary) && VarRef(target) === value.left
@@ -256,7 +256,7 @@ module SyntaxTree
       def local_name(index, level)
         current = iseq
         level.times { current = current.parent_iseq }
-        current.local_table.locals[index].name.to_s
+        current.local_table.locals[index].name.name
       end
     end
   end

data/lib/syntax_tree/yarv/instruction_sequence.rb

@@ -252,19 +252,23 @@ module SyntaxTree
         dumped_options = argument_options.dup
         dumped_options[:opt].map!(&:name) if dumped_options[:opt]
 
+        metadata = {
+          arg_size: argument_size,
+          local_size: local_table.size,
+          stack_max: stack.maximum_size,
+          node_id: -1,
+          node_ids: [-1] * insns.length
+        }
+
+        metadata[:parser] = :prism if RUBY_VERSION >= "3.3"
+
         # Next, return the instruction sequence as an array.
         [
           MAGIC,
           versions[0],
           versions[1],
           1,
-          {
-            arg_size: argument_size,
-            local_size: local_table.size,
-            stack_max: stack.maximum_size,
-            node_id: -1,
-            node_ids: [-1] * insns.length
-          },
+          metadata,
           name,
           file,
           "<compiled>",
@@ -353,11 +357,27 @@ module SyntaxTree
             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
@@ -673,6 +693,10 @@ module SyntaxTree
         push(ConcatStrings.new(number))
       end
 
+      def concattoarray(object)
+        push(ConcatToArray.new(object))
+      end
+
       def defineclass(name, class_iseq, flags)
         push(DefineClass.new(name, class_iseq, flags))
       end
@@ -881,6 +905,14 @@ module SyntaxTree
         push(Pop.new)
       end
 
+      def pushtoarraykwsplat
+        push(PushToArrayKwSplat.new)
+      end
+
+      def putchilledstring(object)
+        push(PutChilledString.new(object))
+      end
+
       def putnil
         push(PutNil.new)
       end
@@ -1063,6 +1095,8 @@ module SyntaxTree
             iseq.concatarray
           when :concatstrings
             iseq.concatstrings(opnds[0])
+          when :concattoarray
+            iseq.concattoarray(opnds[0])
           when :defineclass
             iseq.defineclass(opnds[0], from(opnds[1], options, iseq), opnds[2])
           when :defined
@@ -1174,6 +1208,14 @@ module SyntaxTree
           when :opt_newarray_min
             iseq.newarray(opnds[0])
             iseq.send(YARV.calldata(:min))
+          when :opt_newarray_send
+            mid = opnds[1]
+            if RUBY_VERSION >= "3.4"
+              mid = %i[max min hash pack pack_buffer include?][mid - 1]
+            end
+
+            iseq.newarray(opnds[0])
+            iseq.send(CallData.new(mid))
           when :opt_neq
             iseq.push(
               OptNEq.new(CallData.from(opnds[0]), CallData.from(opnds[1]))
@@ -1188,6 +1230,10 @@ module SyntaxTree
             iseq.send(YARV.calldata(:-@))
           when :pop
             iseq.pop
+          when :pushtoarraykwsplat
+            iseq.pushtoarraykwsplat
+          when :putchilledstring
+            iseq.putchilledstring(opnds[0])
           when :putnil
             iseq.putnil
           when :putobject

data/lib/syntax_tree/yarv/instructions.rb

@@ -757,6 +757,59 @@ module SyntaxTree
       end
     end
 
+    # ### Summary
+    #
+    # `concattoarray` pops a single value off the stack and attempts to concat
+    # it to the Array on top of the stack. If the value is not an Array, it
+    # will be coerced into one.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # [1, *2]
+    # ~~~
+    #
+    class ConcatToArray < Instruction
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def disasm(fmt)
+        fmt.instruction("concattoarray", [fmt.object(object)])
+      end
+
+      def to_a(_iseq)
+        [:concattoarray, object]
+      end
+
+      def deconstruct_keys(_keys)
+        { object: object }
+      end
+
+      def ==(other)
+        other.is_a?(ConcatToArray) && other.object == object
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        1
+      end
+
+      def pushes
+        1
+      end
+
+      def call(vm)
+        array, value = vm.pop(2)
+        vm.push(array.concat(Array(value)))
+      end
+    end
+
     # ### Summary
     #
     # `defineclass` defines a class. First it pops the superclass off the
@@ -3818,9 +3871,10 @@ module SyntaxTree
 
     # ### 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
     #
@@ -3828,83 +3882,36 @@ module SyntaxTree
     # [a, b, c].max
     # ~~~
     #
-    class OptNewArrayMax < Instruction
-      attr_reader :number
+    class OptNewArraySend < Instruction
+      attr_reader :number, :method
 
-      def initialize(number)
+      def initialize(number, method)
         @number = number
+        @method = method
       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)])
+        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 +3923,7 @@ module SyntaxTree
       end
 
       def call(vm)
-        vm.push(vm.pop(number).min)
+        vm.push(vm.pop(number).__send__(method))
       end
     end
 
@@ -4518,6 +4525,52 @@ module SyntaxTree
       end
     end
 
+    # ### Summary
+    #
+    # `pushtoarraykwsplat` is used to append a hash literal that is being
+    # splatted onto an array.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # ["string", **{ foo: "bar" }]
+    # ~~~
+    #
+    class PushToArrayKwSplat < Instruction
+      def disasm(fmt)
+        fmt.instruction("pushtoarraykwsplat")
+      end
+
+      def to_a(_iseq)
+        [:pushtoarraykwsplat]
+      end
+
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(PushToArrayKwSplat)
+      end
+
+      def length
+        2
+      end
+
+      def pops
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def call(vm)
+        array, hash = vm.pop(2)
+        vm.push(array << hash)
+      end
+    end
+
     # ### Summary
     #
     # `putnil` pushes a global nil object onto the stack.
@@ -4805,6 +4858,54 @@ module SyntaxTree
       end
     end
 
+    # ### Summary
+    #
+    # `putchilledstring` pushes an unfrozen string literal onto the stack that
+    # acts like a frozen string. This is a migration path to frozen string
+    # literals as the default in the future.
+    #
+    # ### Usage
+    #
+    # ~~~ruby
+    # "foo"
+    # ~~~
+    #
+    class PutChilledString < Instruction
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def disasm(fmt)
+        fmt.instruction("putchilledstring", [fmt.object(object)])
+      end
+
+      def to_a(_iseq)
+        [:putchilledstring, object]
+      end
+
+      def deconstruct_keys(_keys)
+        { object: object }
+      end
+
+      def ==(other)
+        other.is_a?(PutChilledString) && other.object == object
+      end
+
+      def length
+        2
+      end
+
+      def pushes
+        1
+      end
+
+      def call(vm)
+        vm.push(object.dup)
+      end
+    end
+
     # ### Summary
     #
     # `putstring` pushes an unfrozen string literal onto the stack.

data/lib/syntax_tree/yarv/legacy.rb

@@ -124,6 +124,110 @@ module SyntaxTree
         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

data/lib/syntax_tree.rb

@@ -21,6 +21,7 @@ module SyntaxTree
   # CLI. Requiring those features takes time, so we autoload as many constants
   # as possible in order to keep the CLI as fast as possible.
 
+  autoload :Database, "syntax_tree/database"
   autoload :DSL, "syntax_tree/dsl"
   autoload :FieldVisitor, "syntax_tree/field_visitor"
   autoload :Index, "syntax_tree/index"

data/tasks/whitequark.rake

@@ -43,8 +43,13 @@ module ParseHelper
     # that we do not support.
     return if (versions & %w[3.1 3.2]).empty?
 
-    entry = caller.find { _1.include?("test_parser.rb") }
-    _, lineno, name = *entry.match(/(\d+):in `(.+)'/)
+    entry =
+      caller.find do |call|
+        call.include?("test_parser.rb") && call.match?(%r{(?<!/)test_})
+      end
+
+    _, lineno, name =
+      *entry.match(/(\d+):in [`'](?:block in )?(?:TestParser#)?(.+)'/)
 
     COLLECTED["#{name}:#{lineno}"] << code
   end