syntax_tree 5.1.0 → 5.3.0

data/lib/syntax_tree/yarv/instructions.rb

@@ -91,6 +91,14 @@ module SyntaxTree
         [:adjuststack, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(AdjustStack) && other.number == number
+      end
+
       def length
         2
       end
@@ -139,6 +147,14 @@ module SyntaxTree
         [:anytostring]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(AnyToString)
+      end
+
       def length
         1
       end
@@ -197,6 +213,14 @@ module SyntaxTree
         [:branchif, label.name]
       end
 
+      def deconstruct_keys(_keys)
+        { label: label }
+      end
+
+      def ==(other)
+        other.is_a?(BranchIf) && other.label == label
+      end
+
       def length
         2
       end
@@ -250,6 +274,14 @@ module SyntaxTree
         [:branchnil, label.name]
       end
 
+      def deconstruct_keys(_keys)
+        { label: label }
+      end
+
+      def ==(other)
+        other.is_a?(BranchNil) && other.label == label
+      end
+
       def length
         2
       end
@@ -302,6 +334,14 @@ module SyntaxTree
         [:branchunless, label.name]
       end
 
+      def deconstruct_keys(_keys)
+        { label: label }
+      end
+
+      def ==(other)
+        other.is_a?(BranchUnless) && other.label == label
+      end
+
       def length
         2
       end
@@ -365,6 +405,16 @@ module SyntaxTree
         ]
       end
 
+      def deconstruct_keys(_keys)
+        { keyword_bits_index: keyword_bits_index, keyword_index: keyword_index }
+      end
+
+      def ==(other)
+        other.is_a?(CheckKeyword) &&
+          other.keyword_bits_index == keyword_bits_index &&
+          other.keyword_index == keyword_index
+      end
+
       def length
         3
       end
@@ -399,9 +449,11 @@ module SyntaxTree
     # ~~~
     #
     class CheckMatch
-      TYPE_WHEN = 1
-      TYPE_CASE = 2
-      TYPE_RESCUE = 3
+      VM_CHECKMATCH_TYPE_WHEN = 1
+      VM_CHECKMATCH_TYPE_CASE = 2
+      VM_CHECKMATCH_TYPE_RESCUE = 3
+      VM_CHECKMATCH_TYPE_MASK = 0x03
+      VM_CHECKMATCH_ARRAY = 0x04
 
       attr_reader :type
 
@@ -417,6 +469,14 @@ module SyntaxTree
         [:checkmatch, type]
       end
 
+      def deconstruct_keys(_keys)
+        { type: type }
+      end
+
+      def ==(other)
+        other.is_a?(CheckMatch) && other.type == type
+      end
+
       def length
         2
       end
@@ -434,7 +494,32 @@ module SyntaxTree
       end
 
       def call(vm)
-        raise NotImplementedError, "checkmatch"
+        target, pattern = vm.pop(2)
+
+        vm.push(
+          if type & VM_CHECKMATCH_ARRAY > 0
+            pattern.any? { |item| check?(item, target) }
+          else
+            check?(pattern, target)
+          end
+        )
+      end
+
+      private
+
+      def check?(pattern, target)
+        case type & VM_CHECKMATCH_TYPE_MASK
+        when VM_CHECKMATCH_TYPE_WHEN
+          pattern
+        when VM_CHECKMATCH_TYPE_CASE
+          pattern === target
+        when VM_CHECKMATCH_TYPE_RESCUE
+          unless pattern.is_a?(Module)
+            raise TypeError, "class or module required for rescue clause"
+          end
+
+          pattern === target
+        end
       end
     end
 
@@ -534,6 +619,14 @@ module SyntaxTree
         [:checktype, type]
       end
 
+      def deconstruct_keys(_keys)
+        { type: type }
+      end
+
+      def ==(other)
+        other.is_a?(CheckType) && other.type == type
+      end
+
       def length
         2
       end
@@ -629,6 +722,14 @@ module SyntaxTree
         [:concatarray]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(ConcatArray)
+      end
+
       def length
         1
       end
@@ -681,6 +782,14 @@ module SyntaxTree
         [:concatstrings, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(ConcatStrings) && other.number == number
+      end
+
       def length
         2
       end
@@ -744,6 +853,15 @@ module SyntaxTree
         [:defineclass, name, class_iseq.to_a, flags]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name, class_iseq: class_iseq, flags: flags }
+      end
+
+      def ==(other)
+        other.is_a?(DefineClass) && other.name == name &&
+          other.class_iseq == class_iseq && other.flags == flags
+      end
+
       def length
         4
       end
@@ -762,12 +880,26 @@ module SyntaxTree
 
       def call(vm)
         object, superclass = vm.pop(2)
-        iseq = class_iseq
 
-        clazz = Class.new(superclass || Object)
-        vm.push(vm.run_class_frame(iseq, clazz))
+        if name == :singletonclass
+          vm.push(vm.run_class_frame(class_iseq, object.singleton_class))
+        elsif object.const_defined?(name)
+          vm.push(vm.run_class_frame(class_iseq, object.const_get(name)))
+        elsif flags & TYPE_MODULE > 0
+          clazz = Module.new
+          object.const_set(name, clazz)
+          vm.push(vm.run_class_frame(class_iseq, clazz))
+        else
+          clazz =
+            if flags & FLAG_HAS_SUPERCLASS > 0
+              Class.new(superclass)
+            else
+              Class.new
+            end
 
-        object.const_set(name, clazz)
+          object.const_set(name, clazz)
+          vm.push(vm.run_class_frame(class_iseq, clazz))
+        end
       end
     end
 
@@ -858,6 +990,15 @@ module SyntaxTree
         [:defined, type, name, message]
       end
 
+      def deconstruct_keys(_keys)
+        { type: type, name: name, message: message }
+      end
+
+      def ==(other)
+        other.is_a?(Defined) && other.type == type && other.name == name &&
+          other.message == message
+      end
+
       def length
         4
       end
@@ -882,17 +1023,19 @@ module SyntaxTree
           when TYPE_NIL, TYPE_SELF, TYPE_TRUE, TYPE_FALSE, TYPE_ASGN, TYPE_EXPR
             message
           when TYPE_IVAR
-            message if vm._self.instance_variable_defined?(name)
+            message if vm.frame._self.instance_variable_defined?(name)
           when TYPE_LVAR
             raise NotImplementedError, "defined TYPE_LVAR"
           when TYPE_GVAR
             message if global_variables.include?(name)
           when TYPE_CVAR
-            clazz = vm._self
+            clazz = vm.frame._self
             clazz = clazz.singleton_class unless clazz.is_a?(Module)
             message if clazz.class_variable_defined?(name)
           when TYPE_CONST
-            raise NotImplementedError, "defined TYPE_CONST"
+            clazz = vm.frame._self
+            clazz = clazz.singleton_class unless clazz.is_a?(Module)
+            message if clazz.const_defined?(name)
           when TYPE_METHOD
             raise NotImplementedError, "defined TYPE_METHOD"
           when TYPE_YIELD
@@ -904,7 +1047,9 @@ module SyntaxTree
           when TYPE_FUNC
             message if object.respond_to?(name, true)
           when TYPE_CONST_FROM
-            raise NotImplementedError, "defined TYPE_CONST_FROM"
+            defined =
+              vm.frame.nesting.any? { |scope| scope.const_defined?(name, true) }
+            message if defined
           end
 
         vm.push(result)
@@ -944,6 +1089,15 @@ module SyntaxTree
         [:definemethod, method_name, method_iseq.to_a]
       end
 
+      def deconstruct_keys(_keys)
+        { method_name: method_name, method_iseq: method_iseq }
+      end
+
+      def ==(other)
+        other.is_a?(DefineMethod) && other.method_name == method_name &&
+          other.method_iseq == method_iseq
+      end
+
       def length
         3
       end
@@ -962,12 +1116,22 @@ module SyntaxTree
 
       def call(vm)
         name = method_name
+        nesting = vm.frame.nesting
         iseq = method_iseq
 
         vm
+          .frame
           ._self
           .__send__(:define_method, name) do |*args, **kwargs, &block|
-            vm.run_method_frame(name, iseq, self, *args, **kwargs, &block)
+            vm.run_method_frame(
+              name,
+              nesting,
+              iseq,
+              self,
+              *args,
+              **kwargs,
+              &block
+            )
           end
       end
     end
@@ -1006,6 +1170,15 @@ module SyntaxTree
         [:definesmethod, method_name, method_iseq.to_a]
       end
 
+      def deconstruct_keys(_keys)
+        { method_name: method_name, method_iseq: method_iseq }
+      end
+
+      def ==(other)
+        other.is_a?(DefineSMethod) && other.method_name == method_name &&
+          other.method_iseq == method_iseq
+      end
+
       def length
         3
       end
@@ -1024,12 +1197,22 @@ module SyntaxTree
 
       def call(vm)
         name = method_name
+        nesting = vm.frame.nesting
         iseq = method_iseq
 
         vm
+          .frame
           ._self
           .__send__(:define_singleton_method, name) do |*args, **kwargs, &block|
-            vm.run_method_frame(name, iseq, self, *args, **kwargs, &block)
+            vm.run_method_frame(
+              name,
+              nesting,
+              iseq,
+              self,
+              *args,
+              **kwargs,
+              &block
+            )
           end
       end
     end
@@ -1053,6 +1236,14 @@ module SyntaxTree
         [:dup]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(Dup)
+      end
+
       def length
         1
       end
@@ -1099,6 +1290,14 @@ module SyntaxTree
         [:duparray, object]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object }
+      end
+
+      def ==(other)
+        other.is_a?(DupArray) && other.object == object
+      end
+
       def length
         2
       end
@@ -1145,6 +1344,14 @@ module SyntaxTree
         [:duphash, object]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object }
+      end
+
+      def ==(other)
+        other.is_a?(DupHash) && other.object == object
+      end
+
       def length
         2
       end
@@ -1191,6 +1398,14 @@ module SyntaxTree
         [:dupn, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(DupN) && other.number == number
+      end
+
       def length
         2
       end
@@ -1242,6 +1457,15 @@ module SyntaxTree
         [:expandarray, number, flags]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number, flags: flags }
+      end
+
+      def ==(other)
+        other.is_a?(ExpandArray) && other.number == number &&
+          other.flags == flags
+      end
+
       def length
         3
       end
@@ -1259,7 +1483,42 @@ module SyntaxTree
       end
 
       def call(vm)
-        raise NotImplementedError, "expandarray"
+        object = vm.pop
+        object =
+          if Array === object
+            object.dup
+          elsif object.respond_to?(:to_ary, true)
+            object.to_ary
+          else
+            [object]
+          end
+
+        splat_flag = flags & 0x01 > 0
+        postarg_flag = flags & 0x02 > 0
+
+        if number == 0 && splat_flag == 0
+          # no space left on stack
+        elsif postarg_flag
+          values = []
+
+          if number > object.size
+            (number - object.size).times { values.push(nil) }
+          end
+          [number, object.size].min.times { values.push(object.pop) }
+          values.push(object.to_a) if splat_flag
+
+          values.each { |item| vm.push(item) }
+        else
+          values = []
+
+          [number, object.size].min.times { values.push(object.shift) }
+          if number > values.size
+            (number - values.size).times { values.push(nil) }
+          end
+          values.push(object.to_a) if splat_flag
+
+          values.reverse_each { |item| vm.push(item) }
+        end
       end
     end
 
@@ -1298,6 +1557,15 @@ module SyntaxTree
         [:getblockparam, current.local_table.offset(index), level]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index, level: level }
+      end
+
+      def ==(other)
+        other.is_a?(GetBlockParam) && other.index == index &&
+          other.level == level
+      end
+
       def length
         3
       end
@@ -1355,6 +1623,15 @@ module SyntaxTree
         [:getblockparamproxy, current.local_table.offset(index), level]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index, level: level }
+      end
+
+      def ==(other)
+        other.is_a?(GetBlockParamProxy) && other.index == index &&
+          other.level == level
+      end
+
       def length
         3
       end
@@ -1407,6 +1684,15 @@ module SyntaxTree
         [:getclassvariable, name, cache]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name, cache: cache }
+      end
+
+      def ==(other)
+        other.is_a?(GetClassVariable) && other.name == name &&
+          other.cache == cache
+      end
+
       def length
         3
       end
@@ -1424,7 +1710,7 @@ module SyntaxTree
       end
 
       def call(vm)
-        clazz = vm._self
+        clazz = vm.frame._self
         clazz = clazz.class unless clazz.is_a?(Class)
         vm.push(clazz.class_variable_get(name))
       end
@@ -1457,6 +1743,14 @@ module SyntaxTree
         [:getconstant, name]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name }
+      end
+
+      def ==(other)
+        other.is_a?(GetConstant) && other.name == name
+      end
+
       def length
         2
       end
@@ -1474,14 +1768,20 @@ module SyntaxTree
       end
 
       def call(vm)
-        # const_base, allow_nil =
-        vm.pop(2)
+        const_base, allow_nil = vm.pop(2)
 
-        vm.frame.nesting.reverse_each do |clazz|
-          if clazz.const_defined?(name)
-            vm.push(clazz.const_get(name))
+        if const_base
+          if const_base.const_defined?(name)
+            vm.push(const_base.const_get(name))
             return
           end
+        elsif const_base.nil? && allow_nil
+          vm.frame.nesting.reverse_each do |clazz|
+            if clazz.const_defined?(name)
+              vm.push(clazz.const_get(name))
+              return
+            end
+          end
         end
 
         raise NameError, "uninitialized constant #{name}"
@@ -1513,6 +1813,14 @@ module SyntaxTree
         [:getglobal, name]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name }
+      end
+
+      def ==(other)
+        other.is_a?(GetGlobal) && other.name == name
+      end
+
       def length
         2
       end
@@ -1572,6 +1880,15 @@ module SyntaxTree
         [:getinstancevariable, name, cache]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name, cache: cache }
+      end
+
+      def ==(other)
+        other.is_a?(GetInstanceVariable) && other.name == name &&
+          other.cache == cache
+      end
+
       def length
         3
       end
@@ -1590,7 +1907,7 @@ module SyntaxTree
 
       def call(vm)
         method = Object.instance_method(:instance_variable_get)
-        vm.push(method.bind(vm._self).call(name))
+        vm.push(method.bind(vm.frame._self).call(name))
       end
     end
 
@@ -1626,6 +1943,14 @@ module SyntaxTree
         [:getlocal, current.local_table.offset(index), level]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index, level: level }
+      end
+
+      def ==(other)
+        other.is_a?(GetLocal) && other.index == index && other.level == level
+      end
+
       def length
         3
       end
@@ -1675,6 +2000,14 @@ module SyntaxTree
         [:getlocal_WC_0, iseq.local_table.offset(index)]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index }
+      end
+
+      def ==(other)
+        other.is_a?(GetLocalWC0) && other.index == index
+      end
+
       def length
         2
       end
@@ -1724,6 +2057,14 @@ module SyntaxTree
         [:getlocal_WC_1, iseq.parent_iseq.local_table.offset(index)]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index }
+      end
+
+      def ==(other)
+        other.is_a?(GetLocalWC1) && other.index == index
+      end
+
       def length
         2
       end
@@ -1775,6 +2116,14 @@ module SyntaxTree
         [:getspecial, key, type]
       end
 
+      def deconstruct_keys(_keys)
+        { key: key, type: type }
+      end
+
+      def ==(other)
+        other.is_a?(GetSpecial) && other.key == key && other.type == type
+      end
+
       def length
         3
       end
@@ -1823,6 +2172,14 @@ module SyntaxTree
         [:intern]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(Intern)
+      end
+
       def length
         1
       end
@@ -1873,6 +2230,14 @@ module SyntaxTree
         [:invokeblock, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(InvokeBlock) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -1928,6 +2293,15 @@ module SyntaxTree
         [:invokesuper, calldata.to_h, block_iseq&.to_a]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata, block_iseq: block_iseq }
+      end
+
+      def ==(other)
+        other.is_a?(InvokeSuper) && other.calldata == calldata &&
+          other.block_iseq == block_iseq
+      end
+
       def length
         1
       end
@@ -1948,8 +2322,9 @@ module SyntaxTree
       def call(vm)
         block =
           if (iseq = block_iseq)
+            frame = vm.frame
             ->(*args, **kwargs, &blk) do
-              vm.run_block_frame(iseq, *args, **kwargs, &blk)
+              vm.run_block_frame(iseq, frame, *args, **kwargs, &blk)
             end
           end
 
@@ -1998,6 +2373,14 @@ module SyntaxTree
         [:jump, label.name]
       end
 
+      def deconstruct_keys(_keys)
+        { label: label }
+      end
+
+      def ==(other)
+        other.is_a?(Jump) && other.label == label
+      end
+
       def length
         2
       end
@@ -2038,6 +2421,14 @@ module SyntaxTree
         [:leave]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(Leave)
+      end
+
       def length
         1
       end
@@ -2088,6 +2479,14 @@ module SyntaxTree
         [:newarray, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(NewArray) && other.number == number
+      end
+
       def length
         2
       end
@@ -2136,6 +2535,14 @@ module SyntaxTree
         [:newarraykwsplat, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(NewArrayKwSplat) && other.number == number
+      end
+
       def length
         2
       end
@@ -2186,6 +2593,14 @@ module SyntaxTree
         [:newhash, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(NewHash) && other.number == number
+      end
+
       def length
         2
       end
@@ -2237,6 +2652,14 @@ module SyntaxTree
         [:newrange, exclude_end]
       end
 
+      def deconstruct_keys(_keys)
+        { exclude_end: exclude_end }
+      end
+
+      def ==(other)
+        other.is_a?(NewRange) && other.exclude_end == exclude_end
+      end
+
       def length
         2
       end
@@ -2278,6 +2701,14 @@ module SyntaxTree
         [:nop]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(Nop)
+      end
+
       def length
         1
       end
@@ -2327,6 +2758,14 @@ module SyntaxTree
         [:objtostring, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(ObjToString) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2378,6 +2817,14 @@ module SyntaxTree
         [:once, iseq.to_a, cache]
       end
 
+      def deconstruct_keys(_keys)
+        { iseq: iseq, cache: cache }
+      end
+
+      def ==(other)
+        other.is_a?(Once) && other.iseq == iseq && other.cache == cache
+      end
+
       def length
         3
       end
@@ -2396,7 +2843,7 @@ module SyntaxTree
 
       def call(vm)
         return if @executed
-        vm.push(vm.run_block_frame(iseq))
+        vm.push(vm.run_block_frame(iseq, vm.frame))
         @executed = true
       end
     end
@@ -2429,6 +2876,14 @@ module SyntaxTree
         [:opt_and, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptAnd) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2477,6 +2932,14 @@ module SyntaxTree
         [:opt_aref, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptAref) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2530,6 +2993,15 @@ module SyntaxTree
         [:opt_aref_with, object, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object, calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptArefWith) && other.object == object &&
+          other.calldata == calldata
+      end
+
       def length
         3
       end
@@ -2579,6 +3051,14 @@ module SyntaxTree
         [:opt_aset, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptAset) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2631,6 +3111,15 @@ module SyntaxTree
         [:opt_aset_with, object, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object, calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptAsetWith) && other.object == object &&
+          other.calldata == calldata
+      end
+
       def length
         3
       end
@@ -2699,6 +3188,16 @@ module SyntaxTree
         ]
       end
 
+      def deconstruct_keys(_keys)
+        { case_dispatch_hash: case_dispatch_hash, else_label: else_label }
+      end
+
+      def ==(other)
+        other.is_a?(OptCaseDispatch) &&
+          other.case_dispatch_hash == case_dispatch_hash &&
+          other.else_label == else_label
+      end
+
       def length
         3
       end
@@ -2748,6 +3247,14 @@ module SyntaxTree
         [:opt_div, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptDiv) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2796,6 +3303,14 @@ module SyntaxTree
         [:opt_empty_p, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptEmptyP) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2845,6 +3360,14 @@ module SyntaxTree
         [:opt_eq, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptEq) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2894,6 +3417,14 @@ module SyntaxTree
         [:opt_ge, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptGE) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -2943,6 +3474,14 @@ module SyntaxTree
         [:opt_getconstant_path, names]
       end
 
+      def deconstruct_keys(_keys)
+        { names: names }
+      end
+
+      def ==(other)
+        other.is_a?(OptGetConstantPath) && other.names == names
+      end
+
       def length
         2
       end
@@ -2960,7 +3499,7 @@ module SyntaxTree
       end
 
       def call(vm)
-        current = vm._self
+        current = vm.frame._self
         current = current.class unless current.is_a?(Class)
 
         names.each do |name|
@@ -2999,6 +3538,14 @@ module SyntaxTree
         [:opt_gt, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptGT) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3048,6 +3595,14 @@ module SyntaxTree
         [:opt_le, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptLE) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3097,6 +3652,14 @@ module SyntaxTree
         [:opt_length, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptLength) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3146,6 +3709,14 @@ module SyntaxTree
         [:opt_lt, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptLT) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3195,6 +3766,14 @@ module SyntaxTree
         [:opt_ltlt, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptLTLT) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3245,6 +3824,14 @@ module SyntaxTree
         [:opt_minus, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptMinus) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3294,6 +3881,14 @@ module SyntaxTree
         [:opt_mod, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptMod) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3343,6 +3938,14 @@ module SyntaxTree
         [:opt_mult, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptMult) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3398,6 +4001,15 @@ module SyntaxTree
         [:opt_neq, eq_calldata.to_h, neq_calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { eq_calldata: eq_calldata, neq_calldata: neq_calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptNEq) && other.eq_calldata == eq_calldata &&
+          other.neq_calldata == neq_calldata
+      end
+
       def length
         3
       end
@@ -3447,6 +4059,14 @@ module SyntaxTree
         [: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
@@ -3495,6 +4115,14 @@ module SyntaxTree
         [: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
@@ -3544,6 +4172,14 @@ module SyntaxTree
         [:opt_nil_p, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptNilP) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3591,6 +4227,14 @@ module SyntaxTree
         [:opt_not, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptNot) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3640,6 +4284,14 @@ module SyntaxTree
         [:opt_or, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptOr) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3689,6 +4341,14 @@ module SyntaxTree
         [:opt_plus, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptPlus) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3737,6 +4397,14 @@ module SyntaxTree
         [:opt_regexpmatch2, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptRegExpMatch2) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3785,6 +4453,14 @@ module SyntaxTree
         [:opt_send_without_block, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptSendWithoutBlock) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3834,6 +4510,14 @@ module SyntaxTree
         [:opt_size, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptSize) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -3886,6 +4570,15 @@ module SyntaxTree
         [:opt_str_freeze, object, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object, calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptStrFreeze) && other.object == object &&
+          other.calldata == calldata
+      end
+
       def length
         3
       end
@@ -3938,6 +4631,15 @@ module SyntaxTree
         [:opt_str_uminus, object, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object, calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptStrUMinus) && other.object == object &&
+          other.calldata == calldata
+      end
+
       def length
         3
       end
@@ -3987,6 +4689,14 @@ module SyntaxTree
         [:opt_succ, calldata.to_h]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata }
+      end
+
+      def ==(other)
+        other.is_a?(OptSucc) && other.calldata == calldata
+      end
+
       def length
         2
       end
@@ -4027,6 +4737,14 @@ module SyntaxTree
         [:pop]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(Pop)
+      end
+
       def length
         1
       end
@@ -4067,6 +4785,14 @@ module SyntaxTree
         [:putnil]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(PutNil)
+      end
+
       def length
         1
       end
@@ -4113,6 +4839,14 @@ module SyntaxTree
         [:putobject, object]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object }
+      end
+
+      def ==(other)
+        other.is_a?(PutObject) && other.object == object
+      end
+
       def length
         2
       end
@@ -4155,6 +4889,14 @@ module SyntaxTree
         [:putobject_INT2FIX_0_]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(PutObjectInt2Fix0)
+      end
+
       def length
         1
       end
@@ -4197,6 +4939,14 @@ module SyntaxTree
         [:putobject_INT2FIX_1_]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(PutObjectInt2Fix1)
+      end
+
       def length
         1
       end
@@ -4237,6 +4987,14 @@ module SyntaxTree
         [:putself]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(PutSelf)
+      end
+
       def length
         1
       end
@@ -4254,7 +5012,7 @@ module SyntaxTree
       end
 
       def call(vm)
-        vm.push(vm._self)
+        vm.push(vm.frame._self)
       end
     end
 
@@ -4289,6 +5047,14 @@ module SyntaxTree
         [:putspecialobject, object]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object }
+      end
+
+      def ==(other)
+        other.is_a?(PutSpecialObject) && other.object == object
+      end
+
       def length
         2
       end
@@ -4310,7 +5076,7 @@ module SyntaxTree
         when OBJECT_VMCORE
           vm.push(vm.frozen_core)
         when OBJECT_CBASE
-          value = vm._self
+          value = vm.frame._self
           value = value.singleton_class unless value.is_a?(Class)
           vm.push(value)
         when OBJECT_CONST_BASE
@@ -4344,6 +5110,14 @@ module SyntaxTree
         [:putstring, object]
       end
 
+      def deconstruct_keys(_keys)
+        { object: object }
+      end
+
+      def ==(other)
+        other.is_a?(PutString) && other.object == object
+      end
+
       def length
         2
       end
@@ -4398,6 +5172,15 @@ module SyntaxTree
         [:send, calldata.to_h, block_iseq&.to_a]
       end
 
+      def deconstruct_keys(_keys)
+        { calldata: calldata, block_iseq: block_iseq }
+      end
+
+      def ==(other)
+        other.is_a?(Send) && other.calldata == calldata &&
+          other.block_iseq == block_iseq
+      end
+
       def length
         3
       end
@@ -4418,9 +5201,12 @@ module SyntaxTree
       def call(vm)
         block =
           if (iseq = block_iseq)
+            frame = vm.frame
             ->(*args, **kwargs, &blk) do
-              vm.run_block_frame(iseq, *args, **kwargs, &blk)
+              vm.run_block_frame(iseq, frame, *args, **kwargs, &blk)
             end
+          elsif calldata.flag?(CallData::CALL_ARGS_BLOCKARG)
+            vm.pop
           end
 
         keywords =
@@ -4472,6 +5258,15 @@ module SyntaxTree
         [:setblockparam, current.local_table.offset(index), level]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index, level: level }
+      end
+
+      def ==(other)
+        other.is_a?(SetBlockParam) && other.index == index &&
+          other.level == level
+      end
+
       def length
         3
       end
@@ -4525,6 +5320,15 @@ module SyntaxTree
         [:setclassvariable, name, cache]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name, cache: cache }
+      end
+
+      def ==(other)
+        other.is_a?(SetClassVariable) && other.name == name &&
+          other.cache == cache
+      end
+
       def length
         3
       end
@@ -4542,7 +5346,7 @@ module SyntaxTree
       end
 
       def call(vm)
-        clazz = vm._self
+        clazz = vm.frame._self
         clazz = clazz.class unless clazz.is_a?(Class)
         clazz.class_variable_set(name, vm.pop)
       end
@@ -4574,6 +5378,14 @@ module SyntaxTree
         [:setconstant, name]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name }
+      end
+
+      def ==(other)
+        other.is_a?(SetConstant) && other.name == name
+      end
+
       def length
         2
       end
@@ -4622,6 +5434,14 @@ module SyntaxTree
         [:setglobal, name]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name }
+      end
+
+      def ==(other)
+        other.is_a?(SetGlobal) && other.name == name
+      end
+
       def length
         2
       end
@@ -4680,6 +5500,15 @@ module SyntaxTree
         [:setinstancevariable, name, cache]
       end
 
+      def deconstruct_keys(_keys)
+        { name: name, cache: cache }
+      end
+
+      def ==(other)
+        other.is_a?(SetInstanceVariable) && other.name == name &&
+          other.cache == cache
+      end
+
       def length
         3
       end
@@ -4698,7 +5527,7 @@ module SyntaxTree
 
       def call(vm)
         method = Object.instance_method(:instance_variable_set)
-        method.bind(vm._self).call(name, vm.pop)
+        method.bind(vm.frame._self).call(name, vm.pop)
       end
     end
 
@@ -4734,6 +5563,14 @@ module SyntaxTree
         [:setlocal, current.local_table.offset(index), level]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index, level: level }
+      end
+
+      def ==(other)
+        other.is_a?(SetLocal) && other.index == index && other.level == level
+      end
+
       def length
         3
       end
@@ -4783,6 +5620,14 @@ module SyntaxTree
         [:setlocal_WC_0, iseq.local_table.offset(index)]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index }
+      end
+
+      def ==(other)
+        other.is_a?(SetLocalWC0) && other.index == index
+      end
+
       def length
         2
       end
@@ -4832,6 +5677,14 @@ module SyntaxTree
         [:setlocal_WC_1, iseq.parent_iseq.local_table.offset(index)]
       end
 
+      def deconstruct_keys(_keys)
+        { index: index }
+      end
+
+      def ==(other)
+        other.is_a?(SetLocalWC1) && other.index == index
+      end
+
       def length
         2
       end
@@ -4879,6 +5732,14 @@ module SyntaxTree
         [:setn, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(SetN) && other.number == number
+      end
+
       def length
         2
       end
@@ -4927,6 +5788,14 @@ module SyntaxTree
         [:setspecial, key]
       end
 
+      def deconstruct_keys(_keys)
+        { key: key }
+      end
+
+      def ==(other)
+        other.is_a?(SetSpecial) && other.key == key
+      end
+
       def length
         2
       end
@@ -4946,7 +5815,7 @@ module SyntaxTree
       def call(vm)
         case key
         when GetSpecial::SVAR_LASTLINE
-          raise NotImplementedError, "svar SVAR_LASTLINE"
+          raise NotImplementedError, "setspecial SVAR_LASTLINE"
         when GetSpecial::SVAR_BACKREF
           raise NotImplementedError, "setspecial SVAR_BACKREF"
         when GetSpecial::SVAR_FLIPFLOP_START
@@ -4982,6 +5851,14 @@ module SyntaxTree
         [:splatarray, flag]
       end
 
+      def deconstruct_keys(_keys)
+        { flag: flag }
+      end
+
+      def ==(other)
+        other.is_a?(SplatArray) && other.flag == flag
+      end
+
       def length
         2
       end
@@ -4999,7 +5876,27 @@ module SyntaxTree
       end
 
       def call(vm)
-        vm.push(*vm.pop)
+        value = vm.pop
+
+        vm.push(
+          if Array === value
+            value.instance_of?(Array) ? value.dup : Array[*value]
+          elsif value.nil?
+            value.to_a
+          else
+            if value.respond_to?(:to_a, true)
+              result = value.to_a
+
+              if result.nil?
+                [value]
+              elsif !result.is_a?(Array)
+                raise TypeError, "expected to_a to return an Array"
+              end
+            else
+              [value]
+            end
+          end
+        )
       end
     end
 
@@ -5026,6 +5923,14 @@ module SyntaxTree
         [:swap]
       end
 
+      def deconstruct_keys(_keys)
+        {}
+      end
+
+      def ==(other)
+        other.is_a?(Swap)
+      end
+
       def length
         1
       end
@@ -5061,15 +5966,18 @@ module SyntaxTree
     # ~~~
     #
     class Throw
-      TAG_NONE = 0x0
-      TAG_RETURN = 0x1
-      TAG_BREAK = 0x2
-      TAG_NEXT = 0x3
-      TAG_RETRY = 0x4
-      TAG_REDO = 0x5
-      TAG_RAISE = 0x6
-      TAG_THROW = 0x7
-      TAG_FATAL = 0x8
+      RUBY_TAG_NONE = 0x0
+      RUBY_TAG_RETURN = 0x1
+      RUBY_TAG_BREAK = 0x2
+      RUBY_TAG_NEXT = 0x3
+      RUBY_TAG_RETRY = 0x4
+      RUBY_TAG_REDO = 0x5
+      RUBY_TAG_RAISE = 0x6
+      RUBY_TAG_THROW = 0x7
+      RUBY_TAG_FATAL = 0x8
+
+      VM_THROW_NO_ESCAPE_FLAG = 0x8000
+      VM_THROW_STATE_MASK = 0xff
 
       attr_reader :type
 
@@ -5085,6 +5993,14 @@ module SyntaxTree
         [:throw, type]
       end
 
+      def deconstruct_keys(_keys)
+        { type: type }
+      end
+
+      def ==(other)
+        other.is_a?(Throw) && other.type == type
+      end
+
       def length
         2
       end
@@ -5102,7 +6018,43 @@ module SyntaxTree
       end
 
       def call(vm)
-        raise NotImplementedError, "throw"
+        state = type & VM_THROW_STATE_MASK
+        value = vm.pop
+
+        case state
+        when RUBY_TAG_NONE
+          case value
+          when nil
+            # do nothing
+          when Exception
+            raise value
+          else
+            raise NotImplementedError
+          end
+        when RUBY_TAG_RETURN
+          raise VM::ReturnError.new(value, error_backtrace(vm))
+        when RUBY_TAG_BREAK
+          raise VM::BreakError.new(value, error_backtrace(vm))
+        when RUBY_TAG_NEXT
+          raise VM::NextError.new(value, error_backtrace(vm))
+        else
+          raise NotImplementedError, "Unknown throw kind #{state}"
+        end
+      end
+
+      private
+
+      def error_backtrace(vm)
+        backtrace = []
+        current = vm.frame
+
+        while current
+          backtrace << "#{current.iseq.file}:#{current.line}:in" \
+            "`#{current.iseq.name}'"
+          current = current.parent
+        end
+
+        [*backtrace, *caller]
       end
     end
 
@@ -5135,6 +6087,14 @@ module SyntaxTree
         [:topn, number]
       end
 
+      def deconstruct_keys(_keys)
+        { number: number }
+      end
+
+      def ==(other)
+        other.is_a?(TopN) && other.number == number
+      end
+
       def length
         2
       end
@@ -5183,6 +6143,15 @@ module SyntaxTree
         [:toregexp, options, length]
       end
 
+      def deconstruct_keys(_keys)
+        { options: options, length: length }
+      end
+
+      def ==(other)
+        other.is_a?(ToRegExp) && other.options == options &&
+          other.length == length
+      end
+
       def pops
         length
       end