eliminate DispatchAction

Author: Nicolas Laurent

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -11,7 +11,6 @@
 
 import static org.truffleruby.language.dispatch.DispatchConfiguration.PRIVATE;
 import static org.truffleruby.language.dispatch.DispatchConfiguration.PUBLIC;
-import static org.truffleruby.language.dispatch.DispatchConfiguration.PUBLIC_DOES_RESPOND;
 
 import java.io.File;
 import java.io.PrintStream;
@@ -1555,7 +1554,7 @@ public abstract static class RespondToNode extends CoreMethodNode {
         private final ConditionProfile respondToMissingProfile = ConditionProfile.create();
 
         public RespondToNode() {
-            dispatch = DispatchRespondToNode.create(PUBLIC_DOES_RESPOND);
+            dispatch = DispatchRespondToNode.create(PUBLIC);
             dispatchIgnoreVisibility = DispatchRespondToNode.create();
             dispatchRespondToMissing = DispatchRespondToNode.create();
         }

src/main/java/org/truffleruby/language/ImmutableRubyObject.java

@@ -156,7 +156,7 @@ public Object invokeMember(String name, Object[] arguments,
     @ExportMessage
     public boolean isMemberInternal(String name,
             @Cached @Shared("definedNode") DispatchRespondToNode definedNode,
-            @Exclusive @Cached(parameters = "PUBLIC_DOES_RESPOND") DispatchRespondToNode definedPublicNode) {
+            @Exclusive @Cached(parameters = "PUBLIC") DispatchRespondToNode definedPublicNode) {
         // defined but not publicly
         return definedNode.doesRespondTo(null, name, this) &&
                 !definedPublicNode.doesRespondTo(null, name, this);

src/main/java/org/truffleruby/language/RubyDynamicObject.java

@@ -629,7 +629,7 @@ public boolean isMemberInvocable(String name,
     public boolean isMemberInternal(String name,
             @CachedLibrary("this") DynamicObjectLibrary objectLibrary,
             @Cached @Shared("definedNode") DispatchRespondToNode definedNode,
-            @Exclusive @Cached(parameters = "PUBLIC_DOES_RESPOND") DispatchRespondToNode definedPublicNode,
+            @Exclusive @Cached(parameters = "PUBLIC") DispatchRespondToNode definedPublicNode,
             @Exclusive @Cached(parameters = "PRIVATE_RETURN_MISSING") DispatchNode dispatchNode,
             @Cached @Shared("nameToRubyNode") ForeignToRubyNode nameToRubyNode,
             @Exclusive @Cached BooleanCastNode booleanCastNode,
@@ -685,7 +685,7 @@ public boolean hasMemberWriteSideEffects(String name,
     // region Instantiable
     @ExportMessage
     public boolean isInstantiable(
-            @Exclusive @Cached(parameters = "PUBLIC_DOES_RESPOND") DispatchRespondToNode doesRespond) {
+            @Exclusive @Cached(parameters = "PUBLIC") DispatchRespondToNode doesRespond) {
         return doesRespond.doesRespondTo(null, "new", this);
     }
 

src/main/java/org/truffleruby/language/dispatch/DispatchAction.java

@@ -11,27 +11,22 @@
 
 
 public enum DispatchConfiguration {
-    PUBLIC(false, true, MissingBehavior.CALL_METHOD_MISSING, DispatchAction.CALL_METHOD),
-    PRIVATE(true, false, MissingBehavior.CALL_METHOD_MISSING, DispatchAction.CALL_METHOD),
-    PROTECTED(false, false, MissingBehavior.CALL_METHOD_MISSING, DispatchAction.CALL_METHOD),
-    PUBLIC_RETURN_MISSING(false, true, MissingBehavior.RETURN_MISSING, DispatchAction.CALL_METHOD),
-    PRIVATE_RETURN_MISSING(true, false, MissingBehavior.RETURN_MISSING, DispatchAction.CALL_METHOD),
-    PUBLIC_DOES_RESPOND(false, true, MissingBehavior.RETURN_MISSING, DispatchAction.RESPOND_TO_METHOD),
-    PRIVATE_DOES_RESPOND(true, false, MissingBehavior.RETURN_MISSING, DispatchAction.RESPOND_TO_METHOD);
+    PUBLIC(false, true, MissingBehavior.CALL_METHOD_MISSING),
+    PRIVATE(true, false, MissingBehavior.CALL_METHOD_MISSING),
+    PROTECTED(false, false, MissingBehavior.CALL_METHOD_MISSING),
+    PUBLIC_RETURN_MISSING(false, true, MissingBehavior.RETURN_MISSING),
+    PRIVATE_RETURN_MISSING(true, false, MissingBehavior.RETURN_MISSING);
 
     public final boolean ignoreVisibility;
     public final boolean onlyLookupPublic;
     public final MissingBehavior missingBehavior;
-    public final DispatchAction dispatchAction;
 
     DispatchConfiguration(
             boolean ignoreVisibility,
             boolean onlyLookupPublic,
-            MissingBehavior missingBehavior,
-            DispatchAction dispatchAction) {
+            MissingBehavior missingBehavior) {
         this.ignoreVisibility = ignoreVisibility;
         this.onlyLookupPublic = onlyLookupPublic;
         this.missingBehavior = missingBehavior;
-        this.dispatchAction = dispatchAction;
     }
 }

src/main/java/org/truffleruby/language/dispatch/DispatchConfiguration.java

@@ -123,12 +123,9 @@ public Object dispatch(VirtualFrame frame, Object receiver, String methodName, R
 
     public Object execute(VirtualFrame frame, Object receiver, String methodName, RubyProc block, Object[] arguments) {
 
-        assert config.dispatchAction == DispatchAction.CALL_METHOD;
-
         final RubyClass metaclass = metaclassNode.execute(receiver);
 
         if (isForeignCall.profile(metaclass == getContext().getCoreLibrary().truffleInteropForeignClass)) {
-            assert config.dispatchAction == DispatchAction.CALL_METHOD;
             return callForeign(receiver, methodName, block, arguments);
         }
 

src/main/java/org/truffleruby/language/dispatch/DispatchNode.java

@@ -23,22 +23,22 @@
 public class DispatchRespondToNode extends RubyBaseNode {
 
     // NOTE(norswap): cf. comment above static fields in DispatchNode to see why we need this field
-    public static final DispatchConfiguration PUBLIC_DOES_RESPOND = DispatchConfiguration.PUBLIC_DOES_RESPOND;
+    public static final DispatchConfiguration PUBLIC = DispatchConfiguration.PUBLIC;
 
     public static DispatchRespondToNode create(DispatchConfiguration config) {
         return new DispatchRespondToNode(config);
     }
 
     public static DispatchRespondToNode create() {
-        return new DispatchRespondToNode(DispatchConfiguration.PRIVATE_DOES_RESPOND);
+        return new DispatchRespondToNode(DispatchConfiguration.PRIVATE);
     }
 
     public static DispatchRespondToNode getUncached(DispatchConfiguration config) {
         return Uncached.UNCACHED_NODES[config.ordinal()];
     }
 
     public static DispatchRespondToNode getUncached() {
-        return getUncached(DispatchConfiguration.PRIVATE_DOES_RESPOND);
+        return getUncached(DispatchConfiguration.PRIVATE);
     }
 
     public final DispatchConfiguration config;
@@ -63,7 +63,6 @@ public boolean doesRespondTo(VirtualFrame frame, String methodName, Object recei
     }
 
     public Object execute(VirtualFrame frame, Object receiver, String methodName, RubyProc block, Object[] arguments) {
-        assert config.dispatchAction == DispatchAction.RESPOND_TO_METHOD;
         final RubyClass metaclass = metaclassNode.execute(receiver);
         final InternalMethod method = methodLookup.execute(frame, metaclass, methodName, config);
         return method != null && method.isDefined() && method.isImplemented();