syntax_tree 5.0.1 → 5.2.0

data/lib/syntax_tree/yarv/legacy.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module YARV
+    # This module contains the instructions that used to be a part of YARV but
+    # have been replaced or removed in more recent versions.
+    module Legacy
+      # ### Summary
+      #
+      # `getclassvariable` looks for a class variable in the current class and
+      # pushes its value onto the stack.
+      #
+      # This version of the `getclassvariable` instruction is no longer used
+      # since in Ruby 3.0 it gained an inline cache.`
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # @@class_variable
+      # ~~~
+      #
+      class GetClassVariable
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def disasm(fmt)
+          fmt.instruction("getclassvariable", [fmt.object(name)])
+        end
+
+        def to_a(_iseq)
+          [:getclassvariable, name]
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          0
+        end
+
+        def pushes
+          1
+        end
+
+        def canonical
+          YARV::GetClassVariable.new(name, nil)
+        end
+
+        def call(vm)
+          canonical.call(vm)
+        end
+      end
+
+      # ### Summary
+      #
+      # `opt_getinlinecache` is a wrapper around a series of `putobject` and
+      # `getconstant` instructions that allows skipping past them if the inline
+      # cache is currently set. It pushes the value of the cache onto the stack
+      # if it is set, otherwise it pushes `nil`.
+      #
+      # This instruction is no longer used since in Ruby 3.2 it was replaced by
+      # the consolidated `opt_getconstant_path` instruction.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # Constant
+      # ~~~
+      #
+      class OptGetInlineCache
+        attr_reader :label, :cache
+
+        def initialize(label, cache)
+          @label = label
+          @cache = cache
+        end
+
+        def disasm(fmt)
+          fmt.instruction(
+            "opt_getinlinecache",
+            [fmt.label(label), fmt.inline_storage(cache)]
+          )
+        end
+
+        def to_a(_iseq)
+          [:opt_getinlinecache, label.name, cache]
+        end
+
+        def length
+          3
+        end
+
+        def pops
+          0
+        end
+
+        def pushes
+          1
+        end
+
+        def canonical
+          self
+        end
+
+        def call(vm)
+          vm.push(nil)
+        end
+      end
+
+      # ### Summary
+      #
+      # `opt_setinlinecache` sets an inline cache for a constant lookup. It pops
+      # the value it should set off the top of the stack. It uses this value to
+      # set the cache. It then pushes that value back onto the top of the stack.
+      #
+      # This instruction is no longer used since in Ruby 3.2 it was replaced by
+      # the consolidated `opt_getconstant_path` instruction.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # Constant
+      # ~~~
+      #
+      class OptSetInlineCache
+        attr_reader :cache
+
+        def initialize(cache)
+          @cache = cache
+        end
+
+        def disasm(fmt)
+          fmt.instruction("opt_setinlinecache", [fmt.inline_storage(cache)])
+        end
+
+        def to_a(_iseq)
+          [:opt_setinlinecache, cache]
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          1
+        end
+
+        def pushes
+          1
+        end
+
+        def canonical
+          self
+        end
+
+        def call(vm)
+        end
+      end
+
+      # ### Summary
+      #
+      # `setclassvariable` looks for a class variable in the current class and
+      # sets its value to the value it pops off the top of the stack.
+      #
+      # This version of the `setclassvariable` instruction is no longer used
+      # since in Ruby 3.0 it gained an inline cache.
+      #
+      # ### Usage
+      #
+      # ~~~ruby
+      # @@class_variable = 1
+      # ~~~
+      #
+      class SetClassVariable
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def disasm(fmt)
+          fmt.instruction("setclassvariable", [fmt.object(name)])
+        end
+
+        def to_a(_iseq)
+          [:setclassvariable, name]
+        end
+
+        def length
+          2
+        end
+
+        def pops
+          1
+        end
+
+        def pushes
+          0
+        end
+
+        def canonical
+          YARV::SetClassVariable.new(name, nil)
+        end
+
+        def call(vm)
+          canonical.call(vm)
+        end
+      end
+    end
+  end
+end

data/lib/syntax_tree/yarv/local_table.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module YARV
+    # This represents every local variable associated with an instruction
+    # sequence. There are two kinds of locals: plain locals that are what you
+    # expect, and block proxy locals, which represent local variables
+    # associated with blocks that were passed into the current instruction
+    # sequence.
+    class LocalTable
+      # A local representing a block passed into the current instruction
+      # sequence.
+      class BlockLocal
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+      end
+
+      # A regular local variable.
+      class PlainLocal
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+      end
+
+      # The result of looking up a local variable in the current local table.
+      class Lookup
+        attr_reader :local, :index, :level
+
+        def initialize(local, index, level)
+          @local = local
+          @index = index
+          @level = level
+        end
+      end
+
+      attr_reader :locals
+
+      def initialize
+        @locals = []
+      end
+
+      def empty?
+        locals.empty?
+      end
+
+      def find(name, level = 0)
+        index = locals.index { |local| local.name == name }
+        Lookup.new(locals[index], index, level) if index
+      end
+
+      def has?(name)
+        locals.any? { |local| local.name == name }
+      end
+
+      def names
+        locals.map(&:name)
+      end
+
+      def name_at(index)
+        locals[index].name
+      end
+
+      def size
+        locals.length
+      end
+
+      # Add a BlockLocal to the local table.
+      def block(name)
+        locals << BlockLocal.new(name) unless has?(name)
+      end
+
+      # Add a PlainLocal to the local table.
+      def plain(name)
+        locals << PlainLocal.new(name) unless has?(name)
+      end
+
+      # This is the offset from the top of the stack where this local variable
+      # lives.
+      def offset(index)
+        size - (index - 3) - 1
+      end
+    end
+  end
+end