AST-inline Symbol#to_proc in the & node

* This handles cases like `foo(&:bar)` and `sym = :bar; foo(&sym)`, but
  not `var = :bar.to_proc` which seems uncommon.

Author: eregon

src/main/java/org/truffleruby/core/cast/ToProcNode.java

@@ -9,10 +9,14 @@
  */
 package org.truffleruby.core.cast;
 
+import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.core.proc.RubyProc;
+import org.truffleruby.core.symbol.RubySymbol;
+import org.truffleruby.core.symbol.SymbolNodes;
 import org.truffleruby.language.Nil;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
+import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.dispatch.DispatchNode;
 
@@ -22,7 +26,9 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.profiles.BranchProfile;
 
-/** Casts an object to a Ruby Proc object. */
+import java.util.Map;
+
+/** The `&` in `foo(&block)`. Converts the passed block to a RubyProc or nil. */
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class ToProcNode extends RubyContextSourceNode {
 
@@ -36,10 +42,23 @@ protected RubyProc doRubyProc(RubyProc proc) {
         return proc;
     }
 
-    @Specialization(guards = { "!isNil(object)", "!isRubyProc(object)" })
+    // AST-inlined version of Symbol#to_proc
+    // No need to guard the refinements here since refinements are always the same in a given source location
+    @Specialization(
+            guards = "symbol == cachedSymbol",
+            assumptions = "getContext().getCoreMethods().symbolToProcAssumption",
+            limit = "1")
+    protected Object doRubySymbolASTInlined(VirtualFrame frame, RubySymbol symbol,
+            @Cached("symbol") RubySymbol cachedSymbol,
+            @Cached("getProcForSymbol(getRefinements(frame), cachedSymbol)") RubyProc cachedProc) {
+        return cachedProc;
+    }
+
+    @Specialization(guards = { "!isNil(object)", "!isRubyProc(object)" }, replaces = "doRubySymbolASTInlined")
     protected RubyProc doObject(VirtualFrame frame, Object object,
             @Cached DispatchNode toProc,
             @Cached BranchProfile errorProfile) {
+        // The semantics are to call #method_missing here
         final Object coerced;
         try {
             coerced = toProc.dispatch(frame, object, "to_proc", null, EMPTY_ARGUMENTS);
@@ -64,4 +83,12 @@ protected RubyProc doObject(VirtualFrame frame, Object object,
         }
     }
 
+    protected RubyProc getProcForSymbol(Map<RubyModule, RubyModule[]> refinements, RubySymbol symbol) {
+        return SymbolNodes.ToProcNode.getOrCreateProc(getContext(), refinements, symbol);
+    }
+
+    protected static Map<RubyModule, RubyModule[]> getRefinements(VirtualFrame frame) {
+        return RubyArguments.getDeclarationContext(frame).getRefinements();
+    }
+
 }

src/main/java/org/truffleruby/core/inlined/CoreMethods.java

@@ -74,6 +74,8 @@ public class CoreMethods {
 
     final Assumption nilClassIsNilAssumption;
 
+    public final Assumption symbolToProcAssumption;
+
     public final InternalMethod EXCEPTION_BACKTRACE;
     public final InternalMethod BLOCK_GIVEN;
     public final InternalMethod LAMBDA;
@@ -134,6 +136,8 @@ public CoreMethods(RubyContext context) {
 
         nilClassIsNilAssumption = registerAssumption(nilClass, "nil?");
 
+        symbolToProcAssumption = registerAssumption(symbolClass, "to_proc");
+
         BLOCK_GIVEN = getMethod(kernelModule, "block_given?");
         LAMBDA = getMethod(kernelModule, "lambda");
         BINDING = getMethod(kernelModule, "binding");

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

@@ -41,7 +41,6 @@
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.dsl.Cached;
-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.MaterializedFrame;
@@ -96,12 +95,17 @@ protected boolean isPreInitializing() {
 
     }
 
-    @ReportPolymorphism
     @CoreMethod(names = "to_proc")
     public abstract static class ToProcNode extends CoreMethodArrayArgumentsNode {
 
         public static final Arity ARITY = new Arity(0, 0, true);
 
+        public static ToProcNode create() {
+            return SymbolNodesFactory.ToProcNodeFactory.create(null);
+        }
+
+        public abstract RubyProc execute(VirtualFrame frame, RubySymbol symbol);
+
         @Child private ReadCallerFrameNode readCallerFrame = ReadCallerFrameNode.create();
 
         @Specialization(
@@ -110,27 +114,29 @@ public abstract static class ToProcNode extends CoreMethodArrayArgumentsNode {
         protected RubyProc toProcCached(VirtualFrame frame, RubySymbol symbol,
                 @Cached("symbol") RubySymbol cachedSymbol,
                 @Cached("getRefinements(frame)") Map<RubyModule, RubyModule[]> cachedRefinements,
-                @Cached("getOrCreateProc(cachedRefinements, symbol)") RubyProc cachedProc) {
+                @Cached("getOrCreateProc(getContext(), cachedRefinements, symbol)") RubyProc cachedProc) {
             return cachedProc;
         }
 
-        @Specialization
+        @Specialization(replaces = "toProcCached")
         protected RubyProc toProcUncached(VirtualFrame frame, RubySymbol symbol) {
             final Map<RubyModule, RubyModule[]> refinements = getRefinements(frame);
-            return getOrCreateProc(refinements, symbol);
+            return getOrCreateProc(getContext(), refinements, symbol);
         }
 
         @TruffleBoundary
-        protected RubyProc getOrCreateProc(Map<RubyModule, RubyModule[]> refinements, RubySymbol symbol) {
+        public static RubyProc getOrCreateProc(RubyContext context,
+                Map<RubyModule, RubyModule[]> refinements,
+                RubySymbol symbol) {
             // TODO (eregon, 23 Sep 2020): this should ideally cache on the refinements by comparing classes, and not by identity.
             return ConcurrentOperations.getOrCompute(
                     symbol.getCachedProcs(),
                     refinements,
-                    key -> createProc(getContext(), key, symbol));
+                    key -> createProc(context, key, symbol));
         }
 
         @TruffleBoundary
-        protected static RubyProc createProc(RubyContext context, Map<RubyModule, RubyModule[]> refinements,
+        private static RubyProc createProc(RubyContext context, Map<RubyModule, RubyModule[]> refinements,
                 RubySymbol symbol) {
             final InternalMethod method = context.getCoreMethods().SYMBOL_TO_PROC;
             final SourceSection sourceSection = CoreLibrary.UNAVAILABLE_SOURCE_SECTION;