Add a bit of execution

Author: kddnewton

.rubocop.yml

@@ -31,12 +31,18 @@ Lint/InterpolationCheck:
 Lint/MissingSuper:
   Enabled: false
 
+Lint/NonLocalExitFromIterator:
+  Enabled: false
+
 Lint/RedundantRequireStatement:
   Enabled: false
 
 Lint/SuppressedException:
   Enabled: false
 
+Lint/UnderscorePrefixedVariableName:
+  Enabled: false
+
 Lint/UnusedMethodArgument:
   AllowUnusedKeywordArguments: true
 
@@ -55,6 +61,9 @@ Naming/RescuedExceptionsVariableName:
 Naming/VariableNumber:
   Enabled: false
 
+Security/Eval:
+  Enabled: false
+
 Style/AccessorGrouping:
   Enabled: false
 
@@ -64,9 +73,18 @@ Style/CaseEquality:
 Style/CaseLikeIf:
   Enabled: false
 
+Style/ClassVars:
+  Enabled: false
+
+Style/DocumentDynamicEvalDefinition:
+  Enabled: false
+
 Style/Documentation:
   Enabled: false
 
+Style/EndBlock:
+  Enabled: false
+
 Style/ExplicitBlockArgument:
   Enabled: false
 

lib/syntax_tree/yarv.rb

@@ -1,11 +1,288 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module SyntaxTree
   # This module provides an object representation of the YARV bytecode.
   module YARV
+    class VM
+      class Jump
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+      end
+
+      class Leave
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+      end
+
+      class Frame
+        attr_reader :iseq, :parent, :stack_index, :_self, :nesting, :svars
+
+        def initialize(iseq, parent, stack_index, _self, nesting)
+          @iseq = iseq
+          @parent = parent
+          @stack_index = stack_index
+          @_self = _self
+          @nesting = nesting
+          @svars = {}
+        end
+      end
+
+      class TopFrame < Frame
+        def initialize(iseq)
+          super(iseq, nil, 0, TOPLEVEL_BINDING.eval("self"), [Object])
+        end
+      end
+
+      class BlockFrame < Frame
+        def initialize(iseq, parent, stack_index)
+          super(iseq, parent, stack_index, parent._self, parent.nesting)
+        end
+      end
+
+      class MethodFrame < Frame
+        attr_reader :name, :block
+
+        def initialize(iseq, parent, stack_index, _self, name, block)
+          super(iseq, parent, stack_index, _self, parent.nesting)
+          @name = name
+          @block = block
+        end
+      end
+
+      class ClassFrame < Frame
+        def initialize(iseq, parent, stack_index, _self)
+          super(iseq, parent, stack_index, _self, parent.nesting + [_self])
+        end
+      end
+
+      class FrozenCore
+        define_method("core#hash_merge_kwd") { |left, right| left.merge(right) }
+
+        define_method("core#hash_merge_ptr") do |hash, *values|
+          hash.merge(values.each_slice(2).to_h)
+        end
+
+        define_method("core#set_method_alias") do |clazz, new_name, old_name|
+          clazz.alias_method(new_name, old_name)
+        end
+
+        define_method("core#set_variable_alias") do |new_name, old_name|
+          # Using eval here since there isn't a reflection API to be able to
+          # alias global variables.
+          eval("alias #{new_name} #{old_name}", binding, __FILE__, __LINE__)
+        end
+
+        define_method("core#set_postexe") { |&block| END { block.call } }
+
+        define_method("core#undef_method") do |clazz, name|
+          clazz.undef_method(name)
+        end
+      end
+
+      FROZEN_CORE = FrozenCore.new.freeze
+
+      extend Forwardable
+
+      attr_reader :stack
+      def_delegators :stack, :push, :pop
+
+      attr_reader :frame
+      def_delegators :frame, :_self
+
+      def initialize
+        @stack = []
+        @frame = nil
+      end
+
+      ##########################################################################
+      # Helper methods for frames
+      ##########################################################################
+
+      def run_frame(frame)
+        # First, set the current frame to the given value.
+        @frame = frame
+
+        # Next, set up the local table for the frame. This is actually incorrect
+        # as it could use the values already on the stack, but for now we're
+        # just doing this for simplicity.
+        frame.iseq.local_table.size.times { push(nil) }
+
+        # Yield so that some frame-specific setup can be done.
+        yield if block_given?
+
+        # This hash is going to hold a mapping of label names to their
+        # respective indices in our instruction list.
+        labels = {}
+
+        # This array is going to hold our instructions.
+        insns = []
+
+        # Here we're going to preprocess the instruction list from the
+        # instruction sequence to set up the labels hash and the insns array.
+        frame.iseq.insns.each do |insn|
+          case insn
+          when Integer, Symbol
+            # skip
+          when InstructionSequence::Label
+            labels[insn.name] = insns.length
+          else
+            insns << insn
+          end
+        end
+
+        # Finally we can execute the instructions one at a time. If they return
+        # jumps or leaves we will handle those appropriately.
+        pc = 0
+        while pc < insns.length
+          insn = insns[pc]
+          pc += 1
+
+          case (result = insn.call(self))
+          when Jump
+            pc = labels[result.name]
+          when Leave
+            return result.value
+          end
+        end
+      ensure
+        @stack = stack[0...frame.stack_index]
+        @frame = frame.parent
+      end
+
+      def run_top_frame(iseq)
+        run_frame(TopFrame.new(iseq))
+      end
+
+      def run_block_frame(iseq, *args, &block)
+        run_frame(BlockFrame.new(iseq, frame, stack.length)) do
+          locals = [*args, block]
+          iseq.local_table.size.times do |index|
+            local_set(index, 0, locals.shift)
+          end
+        end
+      end
+
+      def run_class_frame(iseq, clazz)
+        run_frame(ClassFrame.new(iseq, frame, stack.length, clazz))
+      end
+
+      def run_method_frame(name, iseq, _self, *args, **kwargs, &block)
+        run_frame(
+          MethodFrame.new(iseq, frame, stack.length, _self, name, block)
+        ) do
+          locals = [*args, block]
+
+          if iseq.argument_options[:keyword]
+            # First, set up the keyword bits array.
+            keyword_bits =
+              iseq.argument_options[:keyword].map do |config|
+                kwargs.key?(config.is_a?(Array) ? config[0] : config)
+              end
+
+            iseq.local_table.locals.each_with_index do |local, index|
+              # If this is the keyword bits local, then set it appropriately.
+              if local.name == 2
+                locals.insert(index, keyword_bits)
+                next
+              end
+
+              # First, find the configuration for this local in the keywords
+              # list if it exists.
+              name = local.name
+              config =
+                iseq.argument_options[:keyword].find do |keyword|
+                  keyword.is_a?(Array) ? keyword[0] == name : keyword == name
+                end
+
+              # If the configuration doesn't exist, then the local is not a
+              # keyword local.
+              next unless config
+
+              if !config.is_a?(Array)
+                # required keyword
+                locals.insert(index, kwargs.fetch(name))
+              elsif !config[1].nil?
+                # optional keyword with embedded default value
+                locals.insert(index, kwargs.fetch(name, config[1]))
+              else
+                # optional keyword with expression default value
+                locals.insert(index, nil)
+              end
+            end
+          end
+
+          iseq.local_table.size.times do |index|
+            local_set(index, 0, locals.shift)
+          end
+        end
+      end
+
+      ##########################################################################
+      # Helper methods for instructions
+      ##########################################################################
+
+      def const_base
+        frame.nesting.last
+      end
+
+      def frame_at(level)
+        current = frame
+        level.times { current = current.parent }
+        current
+      end
+
+      def frame_svar
+        current = frame
+        current = current.parent while current.is_a?(BlockFrame)
+        current
+      end
+
+      def frame_yield
+        current = frame
+        current = current.parent until current.is_a?(MethodFrame)
+        current
+      end
+
+      def frozen_core
+        FROZEN_CORE
+      end
+
+      def jump(label)
+        Jump.new(label.name)
+      end
+
+      def leave
+        Leave.new(pop)
+      end
+
+      def local_get(index, level)
+        stack[frame_at(level).stack_index + index]
+      end
+
+      def local_set(index, level, value)
+        stack[frame_at(level).stack_index + index] = value
+      end
+    end
+
     # Compile the given source into a YARV instruction sequence.
     def self.compile(source, options = Compiler::Options.new)
       SyntaxTree.parse(source).accept(Compiler.new(options))
     end
+
+    # Compile and interpret the given source.
+    def self.interpret(source, options = Compiler::Options.new)
+      iseq = RubyVM::InstructionSequence.compile(source, **options)
+      iseq = InstructionSequence.from(iseq.to_a)
+      iseq.specialize_instructions!
+      VM.new.run_top_frame(iseq)
+    end
   end
 end

lib/syntax_tree/yarv/compiler.rb

@@ -1987,8 +1987,8 @@ def visit_pattern(node, end_label)
           match_failure_label = iseq.label
           match_error_label = iseq.label
 
-          # If there's a constant, then check if we match against that constant or
-          # not first. Branch to failure if we don't.
+          # If there's a constant, then check if we match against that constant
+          # or not first. Branch to failure if we don't.
           if node.constant
             iseq.dup
             visit(node.constant)
@@ -2007,8 +2007,8 @@ def visit_pattern(node, end_label)
           iseq.topn(2)
           iseq.branchunless(match_failure_label)
 
-          # Since we have a valid cached value, we can skip past the part where we
-          # call #deconstruct on the object.
+          # Since we have a valid cached value, we can skip past the part where
+          # we call #deconstruct on the object.
           iseq.pop
           iseq.topn(1)
           iseq.jump(length_label)
@@ -2064,8 +2064,8 @@ def visit_pattern(node, end_label)
             end
           end
 
-          # Set up the routine here to raise an error to indicate that the type of
-          # the deconstructed array was incorrect.
+          # Set up the routine here to raise an error to indicate that the type
+          # of the deconstructed array was incorrect.
           iseq.push(match_error_label)
           iseq.putspecialobject(PutSpecialObject::OBJECT_VMCORE)
           iseq.putobject(TypeError)