Ruby 2.7: Kernel#lambda with no block in a method called with a block…

… raises an exception.
oracle · Nov 23, 2020 · 35f852d · 35f852d
1 parent 5fd2b6b
commit 35f852d
Show file tree

Hide file tree

Showing 3 changed files with 3 additions and 42 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -25,6 +25,7 @@ Compatibility:
 * Add warning for `proc` without block (#2004, @ssnickolay).
 * Implemented `FrozenError#receiver`.
 * `Proc#<<` and `Proc#>>` raises TypeError if passed not callable object (#2004, @ssnickolay).
+* `Kernel#lambda` with no block in a method called with a block raises an exception (#2004, @ssnickolay).
 
 Performance:
 

diff --git a/spec/tags/language/lambda_tags.txt b/spec/tags/language/lambda_tags.txt
@@ -1,3 +1,2 @@
 fails:A lambda literal -> () { } assigns variables from parameters with circular optional argument reference raises a SyntaxError if using an existing local with the same name as the argument
 fails:A lambda literal -> () { } assigns variables from parameters with circular optional argument reference raises a SyntaxError if there is an existing method with the same name as the argument
-fails:A lambda expression 'lambda { ... }' with an implicit block raises ArgumentError
diff --git a/src/main/java/org/truffleruby/core/kernel/KernelNodes.java b/src/main/java/org/truffleruby/core/kernel/KernelNodes.java
@@ -96,7 +96,6 @@
 import org.truffleruby.language.RubyRootNode;
 import org.truffleruby.language.RubySourceNode;
 import org.truffleruby.language.Visibility;
-import org.truffleruby.language.WarnNode;
 import org.truffleruby.language.WarningNode;
 import org.truffleruby.language.arguments.ReadCallerFrameNode;
 import org.truffleruby.language.arguments.RubyArguments;
@@ -148,7 +147,6 @@
 import com.oracle.truffle.api.dsl.ReportPolymorphism;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.FrameDescriptor;
-import com.oracle.truffle.api.frame.FrameInstance.FrameAccess;
 import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.frame.MaterializedFrame;
 import com.oracle.truffle.api.frame.VirtualFrame;
@@ -1191,33 +1189,9 @@ protected boolean isATypeError(Object self, Object module) {
     @CoreMethod(names = "lambda", isModuleFunction = true, needsBlock = true)
     public abstract static class LambdaNode extends CoreMethodArrayArgumentsNode {
 
-        @Child private WarnNode warnNode;
-
-        @TruffleBoundary
         @Specialization
-        protected RubyProc lambda(NotProvided block,
-                @Cached FindAndReadDeclarationVariableNode readNode) {
-            final MaterializedFrame parentFrame = getContext()
-                    .getCallStack()
-                    .getCallerFrameIgnoringSend(FrameAccess.MATERIALIZE)
-                    .materialize();
-            Object parentBlock = readNode
-                    .execute(parentFrame, TranslatorEnvironment.METHOD_BLOCK_NAME, nil);
-
-            if (parentBlock == nil) {
-                throw new RaiseException(
-                        getContext(),
-                        coreExceptions().argumentError("tried to create Proc object without a block", this));
-            } else {
-                warnProcWithoutBlock();
-            }
-
-            Node callNode = getContext().getCallStack().getCallerNode(2, true);
-            if (isLiteralBlock(callNode)) {
-                return lambdaFromBlock((RubyProc) parentBlock);
-            } else {
-                return (RubyProc) parentBlock;
-            }
+        protected RubyProc lambda(NotProvided block) {
+            throw new RaiseException(getContext(), coreExceptions().argumentErrorProcWithoutBlock(this));
         }
 
         @Specialization(guards = "isLiteralBlock(block)")
@@ -1240,19 +1214,6 @@ private boolean isLiteralBlock(Node callNode) {
             RubyCallNode rubyCallNode = NodeUtil.findParent(callNode, RubyCallNode.class);
             return rubyCallNode != null && rubyCallNode.hasLiteralBlock();
         }
-
-        private void warnProcWithoutBlock() {
-            if (warnNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                warnNode = insert(new WarnNode());
-            }
-
-            if (warnNode.shouldWarn()) {
-                final SourceSection sourceSection = getContext().getCallStack().getTopMostUserSourceSection();
-                warnNode.warningMessage(sourceSection, "tried to create Proc object without a block");
-            }
-        }
-
     }
 
     @CoreMethod(names = "__method__", isModuleFunction = true)