introduced EvalFrame

bin/my.rb

@@ -6,6 +6,9 @@
 
 class RubyRb
   REAL_EVAL = Kernel.instance_method(:eval)
+  REAL_INSTANCE_EVAL = BasicObject.instance_method(:instance_eval)
+  REAL_MODULE_EVAL = Module.instance_method(:module_eval)
+  REAL_CLASS_EVAL = Module.instance_method(:class_eval)
   REAL_KERNEL_LAMBDA = Kernel.instance_method(:lambda)
 
   def self.require(file)
@@ -119,10 +122,46 @@ def require_relative(filepath)
     rescue LoadError
       binding.irb
     end
+
+    def eval(code)
+      iseq = RubyVM::InstructionSequence.compile(code).to_a
+      iseq[9] = :eval
+      VM.instance.execute(iseq, _self: self)
+    end
   end
+end
 
-  def eval(code)
-    RubyRb.eval(code)
+class BasicObject
+  def instance_eval(code = nil, &block)
+    if code
+      iseq = ::RubyVM::InstructionSequence.compile(code).to_a
+      iseq[9] = :eval
+      ::VM.instance.execute(iseq, _self: self)
+    else
+      ::RubyRb::REAL_INSTANCE_EVAL.bind(self).call(&block)
+    end
+  end
+end
+
+class Module
+  def module_eval(code = nil, &block)
+    if code
+      iseq = ::RubyVM::InstructionSequence.compile(code).to_a
+      iseq[9] = :eval
+      ::VM.instance.execute(iseq, _self: self)
+    else
+      ::RubyRb::REAL_MODULE_EVAL.bind(self).call(&block)
+    end
+  end
+
+  def class_eval(code = nil, &block)
+    if code
+      iseq = ::RubyVM::InstructionSequence.compile(code).to_a
+      iseq[9] = :eval
+      ::VM.instance.execute(iseq, _self: self)
+    else
+      ::RubyRb::REAL_CLASS_EVAL.bind(self).call(&block)
+    end
   end
 end
 

executor.rb

@@ -61,6 +61,17 @@ def execute_opt_plus(_)
   def execute_opt_send_without_block((options, _flag))
     mid = options[:mid]
 
+    if current_frame.eval? &&
+       (options[:flag] & VM_CALL_VCALL).nonzero? &&
+       (parent = current_frame.parent_frame) &&
+       parent.locals.declared?(name: mid)
+
+      # x = 1; eval("x") - x is a VCALL in eval, so maybe it's a local variable of the parent frame
+      result = parent.locals.find(name: mid).value
+      push(result)
+      return
+    end
+
     if mid == :module_function && options[:orig_argc] == 0
       current_frame.open_module_function_section!
       push(nil)
@@ -636,8 +647,9 @@ def execute_getblockparam((_, level))
     push(frame.block)
   end
 
-  def execute_getblockparamproxy(args)
-    push(current_frame.block)
+  def execute_getblockparamproxy((_, level))
+    frame = level.times.inject(current_frame) { |f| f.parent_frame }
+    push(frame.block)
   end
 
   def execute_nop(*); end

vm.rb

@@ -101,6 +101,12 @@ def push_frame(iseq, **payload)
       @frame_stack.push_top(
         iseq: iseq
       )
+    when :eval
+      @frame_stack.push_eval(
+        iseq: iseq,
+        parent_frame: current_frame,
+        _self: payload[:_self]
+      )
     when :class
       case
       when iseq.name.start_with?('<module')

vm/frame_stack.rb

@@ -52,6 +52,10 @@ def push_ensure(**args)
     push EnsureFrame.new(**args)
   end
 
+  def push_eval(**args)
+    push EvalFrame.new(**args)
+  end
+
   def pop
     @stack.pop
   end

vm/frames.rb

@@ -15,5 +15,6 @@
 require_relative './frames/block_frame'
 require_relative './frames/ensure_frame'
 require_relative './frames/rescue_frame'
+require_relative './frames/eval_frame'
 
 require_relative './frame_stack'

vm/frames/eval_frame.rb

@@ -0,0 +1,18 @@
+EvalFrame = FrameClass.new do
+  attr_reader :parent_frame
+
+  def initialize(parent_frame:, _self:)
+    @parent_frame = parent_frame
+
+    self._self = _self
+    self.nesting = parent_frame.nesting
+  end
+
+  def pretty_name
+    "EVAL"
+  end
+
+  def eval?
+    true
+  end
+end

vm/frames/factory.rb

@@ -32,6 +32,7 @@ def pretty_name
       def can_return?;  false; end
       def can_do_next?; false; end
       def can_yield?;   false; end
+      def eval?;        false; end
 
       def prepare; end