Fix #arity and #inspect for Symbol#to_proc Procs

PullRequest: truffleruby/558

Author: eregon

CHANGELOG.md

@@ -15,6 +15,7 @@ Compatibility:
 * Change to a new system for handling Ruby objects in C extensions which
   greatly increases compatibility with MRI.
 * Implemented `BigDecimal#to_r` (#1521).
+* `Symbol#to_proc` now returns `-1` like on MRI (#1462).
 
 # 1.0 RC 11, 15 January 2019
 

spec/ruby/core/proc/shared/to_s.rb

@@ -32,14 +32,24 @@
   describe "for a proc created with UnboundMethod#to_proc" do
     it "returns a description including '(lambda)' and optionally including file and line number" do
       def hello; end
-
       method("hello").to_proc.send(@method).should =~ /^#<Proc:([^ ]*?)(@([^ ]*)\/to_s\.rb:22)? \(lambda\)>$/
     end
 
     it "has an ASCII-8BIT encoding" do
       def hello; end
-
       method("hello").to_proc.send(@method).encoding.should == Encoding::ASCII_8BIT
     end
   end
+
+  describe "for a proc created with Symbol#to_proc" do
+    it "returns a description including '(&:symbol)'" do
+      proc = :foobar.to_proc
+      proc.send(@method).should =~ /^#<Proc:0x\h+\(&:foobar\)>$/
+    end
+
+    it "has an ASCII-8BIT encoding" do
+      proc = :foobar.to_proc
+      proc.send(@method).encoding.should == Encoding::ASCII_8BIT
+    end
+  end
 end

spec/ruby/core/symbol/to_proc_spec.rb

@@ -12,19 +12,22 @@
     :to_s.to_proc.call(obj).should == "Received #to_s"
   end
 
+  it "produces a proc with arity -1" do
+    pr = :to_s.to_proc
+    pr.arity.should == -1
+  end
+
   it "raises an ArgumentError when calling #call on the Proc without receiver" do
-    lambda { :object_id.to_proc.call }.should raise_error(ArgumentError)
+    lambda { :object_id.to_proc.call }.should raise_error(ArgumentError, "no receiver given")
   end
 
   it "produces a proc that always returns [[:rest]] for #parameters" do
     pr = :to_s.to_proc
     pr.parameters.should == [[:rest]]
   end
-end
 
-describe "Symbol#to_proc" do
-  before :all do
-    @klass = Class.new do
+  it "passes along the block passed to Proc#call" do
+    klass = Class.new do
       def m
         yield
       end
@@ -33,9 +36,6 @@ def to_proc
         :m.to_proc.call(self) { :value }
       end
     end
-  end
-
-  it "passes along the block passed to Proc#call" do
-    @klass.new.to_proc.should == :value
+    klass.new.to_proc.should == :value
   end
 end

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

@@ -14,10 +14,13 @@
 import org.truffleruby.builtins.CoreClass;
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
+import org.truffleruby.builtins.Primitive;
+import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
 import org.truffleruby.builtins.UnaryCoreMethodNode;
 import org.truffleruby.core.binding.BindingNodes;
 import org.truffleruby.core.rope.CodeRange;
 import org.truffleruby.core.string.StringNodes;
+import org.truffleruby.core.symbol.SymbolNodes;
 import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.ArgumentDescriptorUtils;
@@ -280,4 +283,18 @@ public Object sourceLocation(DynamicObject proc) {
 
     }
 
+    @Primitive(name = "proc_symbol_to_proc_symbol")
+    public abstract static class ProcSymbolToProcSymbolNode extends PrimitiveArrayArgumentsNode {
+
+        @Specialization
+        public DynamicObject symbolToProcSymbol(DynamicObject proc) {
+            if (Layouts.PROC.getSharedMethodInfo(proc).getArity() == SymbolNodes.ToProcNode.ARITY) {
+                return getSymbol(Layouts.PROC.getSharedMethodInfo(proc).getName());
+            } else {
+                return nil();
+            }
+        }
+
+    }
+
 }

src/main/java/org/truffleruby/core/symbol/SymbolNodes.java

@@ -28,7 +28,6 @@
 import org.truffleruby.core.proc.ProcType;
 import org.truffleruby.core.string.StringNodes;
 import org.truffleruby.language.RubyRootNode;
-import org.truffleruby.language.SourceIndexLength;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.arguments.ReadCallerFrameNode;
 import org.truffleruby.language.arguments.RubyArguments;
@@ -39,9 +38,6 @@
 import org.truffleruby.language.methods.SharedMethodInfo;
 import org.truffleruby.language.methods.SymbolProcNode;
 import org.truffleruby.parser.ArgumentDescriptor;
-import org.truffleruby.parser.Translator;
-
-import java.util.Arrays;
 
 @CoreClass("Symbol")
 public abstract class SymbolNodes {
@@ -99,6 +95,8 @@ protected boolean isPreInitializing() {
     @CoreMethod(names = "to_proc")
     public abstract static class ToProcNode extends CoreMethodArrayArgumentsNode {
 
+        public static final Arity ARITY = new Arity(0, 0, true);
+
         @Child private ReadCallerFrameNode readCallerFrame = ReadCallerFrameNode.create();
 
         @Specialization(guards = { "cachedSymbol == symbol", "getDeclarationContext(frame) == cachedDeclarationContext" }, limit = "getCacheLimit()")
@@ -120,12 +118,11 @@ public DynamicObject toProcUncached(VirtualFrame frame, DynamicObject symbol) {
         protected DynamicObject createProc(DeclarationContext declarationContext, InternalMethod method, DynamicObject symbol) {
             final SourceSection sourceSection = getContext().getCallStack().getCallerFrameIgnoringSend()
                     .getCallNode().getEncapsulatingSourceSection();
-            final SourceIndexLength sourceIndexLength = new SourceIndexLength(sourceSection);
 
             final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(
                     sourceSection,
                     method.getLexicalScope(),
-                    Arity.AT_LEAST_ONE,
+                    ARITY,
                     null,
                     Layouts.SYMBOL.getString(symbol),
                     0,
@@ -138,15 +135,17 @@ protected DynamicObject createProc(DeclarationContext declarationContext, Intern
             // binding as this simplifies the logic elsewhere in the runtime.
             final MaterializedFrame declarationFrame = Truffle.getRuntime().createMaterializedFrame(args, coreLibrary().getEmptyDescriptor());
             final RubyRootNode rootNode = new RubyRootNode(getContext(), sourceSection, new FrameDescriptor(nil()), sharedMethodInfo,
-                    Translator.sequence(sourceIndexLength, Arrays.asList(Translator.createCheckArityNode(Arity.AT_LEAST_ONE), new SymbolProcNode(Layouts.SYMBOL.getString(symbol)))));
+                    new SymbolProcNode(Layouts.SYMBOL.getString(symbol)));
 
             final CallTarget callTarget = Truffle.getRuntime().createCallTarget(rootNode);
 
             return ProcOperations.createRubyProc(
                     coreLibrary().getProcFactory(),
                     ProcType.PROC,
                     sharedMethodInfo,
-                    callTarget, callTarget, declarationFrame,
+                    callTarget,
+                    callTarget,
+                    declarationFrame,
                     method,
                     null,
                     null,
@@ -168,6 +167,7 @@ protected DeclarationContext getDeclarationContext(VirtualFrame frame) {
         protected FrameDescriptor getDescriptor(VirtualFrame frame) {
             return frame.getFrameDescriptor();
         }
+
     }
 
     @CoreMethod(names = "to_s")

src/main/java/org/truffleruby/language/methods/Arity.java

@@ -21,7 +21,6 @@ public class Arity {
     public static final String[] NO_KEYWORDS = new String[]{};
     public static final Arity NO_ARGUMENTS = new Arity(0, 0, false);
     public static final Arity ONE_REQUIRED = new Arity(1, 0, false);
-    public static final Arity AT_LEAST_ONE = new Arity(1, 0, true);
 
     private final int preRequired;
     private final int optional;

src/main/java/org/truffleruby/language/methods/SymbolProcNode.java

@@ -12,14 +12,18 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.profiles.BranchProfile;
+
 import org.truffleruby.core.array.ArrayUtils;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.arguments.RubyArguments;
+import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.dispatch.CallDispatchHeadNode;
 
 public class SymbolProcNode extends RubyNode {
 
     private final String symbol;
+    private final BranchProfile noReceiverProfile = BranchProfile.create();
 
     @Child private CallDispatchHeadNode callNode;
 
@@ -29,15 +33,17 @@ public SymbolProcNode(String symbol) {
 
     @Override
     public Object execute(VirtualFrame frame) {
-        final Object receiver = RubyArguments.getArgument(frame, 0);
+        // Not using CheckArityNode as the message is different and arity is reported as -1
+        final int given = RubyArguments.getArgumentsCount(frame);
+        if (given == 0) {
+            noReceiverProfile.enter();
+            throw new RaiseException(getContext(), coreExceptions().argumentError("no receiver given", this));
+        }
 
+        final Object receiver = RubyArguments.getArgument(frame, 0);
+        final Object[] arguments = ArrayUtils.extractRange(RubyArguments.getArguments(frame), 1, given);
         final DynamicObject block = RubyArguments.getBlock(frame);
 
-        final Object[] arguments = ArrayUtils.extractRange(
-                RubyArguments.getArguments(frame),
-                1,
-                RubyArguments.getArgumentsCount(frame));
-
         return getCallNode().dispatch(frame, receiver, symbol, block, arguments);
     }
 

src/main/ruby/core/proc.rb

@@ -86,18 +86,18 @@ def f.binding
   end
 
   def to_s
-    sl = source_location
-    return super if sl.nil?
-    file, line = sl
-
-    l = ' (lambda)' if lambda?
-    if file and line
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}@#{file}:#{line}#{l}>".force_encoding('ASCII-8BIT')
-    else
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{l}>".force_encoding('ASCII-8BIT')
+    base = super()
+    file, line = source_location
+
+    suffix = ''.b
+    if sym = Truffle.invoke_primitive(:proc_symbol_to_proc_symbol, self)
+      suffix << "(&#{sym.inspect})"
+    elsif file and line
+      suffix << "@#{file}:#{line}"
     end
+    suffix << ' (lambda)' if lambda?
+    base.b.insert(-2, suffix)
   end
-
   alias_method :inspect, :to_s
 
   def to_proc