Proc.new takes the block from the surrounding method.

Author: aardvark179

spec/ruby/core/proc/new_spec.rb

@@ -190,6 +190,17 @@ def some_method
 
       prc.call.should == "hello"
     end
+
+    it "uses the implicit block from an enclosing method when called inside a block" do
+      def some_method
+        proc do |&block|
+          Proc.new
+        end.call
+      end
+      prc = some_method { "hello" }
+
+      prc.call.should == "hello"
+    end
   end
 
   ruby_version_is "2.7" do

src/main/java/org/truffleruby/core/proc/ProcNodes.java

@@ -24,15 +24,19 @@
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.ArgumentDescriptorUtils;
+import org.truffleruby.language.arguments.ReadBlockNode;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.dispatch.CallDispatchHeadNode;
+import org.truffleruby.language.locals.FindDeclarationVariableNodes.FindAndReadDeclarationVariableNode;
 import org.truffleruby.language.objects.AllocateObjectNode;
 import org.truffleruby.language.yield.CallBlockNode;
 import org.truffleruby.parser.ArgumentDescriptor;
+import org.truffleruby.parser.TranslatorEnvironment;
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.frame.FrameInstance.FrameAccess;
@@ -68,32 +72,42 @@ public abstract DynamicObject executeProcNew(
                 Object block);
 
         @Specialization
-        public DynamicObject proc(VirtualFrame frame, DynamicObject procClass, Object[] args, NotProvided block) {
-            final Frame parentFrame = getContext().getCallStack().getCallerFrameIgnoringSend()
-                    .getFrame(FrameAccess.READ_ONLY);
+        public DynamicObject proc(VirtualFrame frame, DynamicObject procClass, Object[] args, NotProvided block,
+                                  @Cached("create(nil())") FindAndReadDeclarationVariableNode readNode) {
+            final MaterializedFrame parentFrame = getContext().getCallStack().getCallerFrameIgnoringSend()
+                    .getFrame(FrameAccess.MATERIALIZE).materialize();
 
-            DynamicObject parentBlock = RubyArguments.getBlock(parentFrame);
+            DynamicObject parentBlock = (DynamicObject) readNode.execute(parentFrame, TranslatorEnvironment.TEMP_PREFIX + "__unnamed_block_arg__");
 
-            if (parentBlock == null) {
+            if (parentBlock == nil()) {
                 parentBlock = tryParentBlockForCExts();
             }
 
-            if (parentBlock == null) {
+            if (parentBlock == nil()) {
                 throw new RaiseException(getContext(), coreExceptions().argumentErrorProcWithoutBlock(this));
             }
 
             return executeProcNew(frame, procClass, args, parentBlock);
         }
 
         @TruffleBoundary
-        private static DynamicObject tryParentBlockForCExts() {
+        protected static void debug(String str) {
+            System.err.println(str);
+        }
+
+        protected static ReadBlockNode createReadBlock() {
+            return new ReadBlockNode(null);
+        }
+
+        @TruffleBoundary
+        protected DynamicObject tryParentBlockForCExts() {
             /*
              * TODO CS 11-Mar-17 to pass the remaining cext proc specs we need to determine here if Proc.new has been
              * called from a cext from rb_funcall, and then reach down the stack to the Ruby method that originally
              * went into C and get the block from there.
              */
 
-            return null;
+            return nil();
         }
 
         @Specialization(guards = { "procClass == getProcClass()", "block.getShape() == getProcShape()" })