Remove boundaries & cleanup in RubyCallNode

Author: Nicolas Laurent

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

@@ -1261,14 +1261,14 @@ protected RubyMethod method(VirtualFrame frame, Object self, Object name,
                 @Cached ConditionProfile respondToMissingProfile) {
             final String normalizedName = nameToJavaStringNode.execute(name);
             InternalMethod method = lookupMethodNode
-                    .lookupPrivate(frame, self, normalizedName, dispatchConfig);
+                    .lookup(frame, self, normalizedName, dispatchConfig);
 
             if (notFoundProfile.profile(method == null)) {
                 final Object respondToMissing = respondToMissingNode
                         .call(self, "respond_to_missing?", name, dispatchConfig.ignoreVisibility);
                 if (respondToMissingProfile.profile(booleanCastNode.executeToBoolean(respondToMissing))) {
                     final InternalMethod methodMissing = lookupMethodNode
-                            .lookupPrivate(frame, self, "method_missing", dispatchConfig);
+                            .lookup(frame, self, "method_missing", dispatchConfig);
                     method = createMissingMethod(self, name, normalizedName, methodMissing);
                 } else {
                     throw new RaiseException(

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

@@ -16,23 +16,21 @@
 import org.truffleruby.core.cast.BooleanCastNodeGen;
 import org.truffleruby.core.cast.ProcOrNullNode;
 import org.truffleruby.core.cast.ProcOrNullNodeGen;
-import org.truffleruby.core.module.ModuleOperations;
 import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
 import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.methods.BlockDefinitionNode;
-import org.truffleruby.language.methods.DeclarationContext;
 import org.truffleruby.language.methods.InternalMethod;
 
 import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
+import org.truffleruby.language.methods.LookupMethodOnSelfNode;
 
 import static org.truffleruby.language.dispatch.DispatchConfiguration.PRIVATE;
 import static org.truffleruby.language.dispatch.DispatchConfiguration.PRIVATE_RETURN_MISSING;
@@ -48,7 +46,7 @@ public class RubyCallNode extends RubyContextSourceNode {
     @Children private final RubyNode[] arguments;
 
     private final boolean isSplatted;
-    private final boolean ignoreVisibility;
+    private final DispatchConfiguration dispatchConfig;
     private final boolean isVCall;
     private final boolean isSafeNavigation;
     private final boolean isAttrAssign;
@@ -73,7 +71,7 @@ public RubyCallNode(RubyCallNodeParameters parameters) {
         }
 
         this.isSplatted = parameters.isSplatted();
-        this.ignoreVisibility = parameters.isIgnoreVisibility();
+        this.dispatchConfig = parameters.isIgnoreVisibility() ? PRIVATE : PROTECTED;
         this.isVCall = parameters.isVCall();
         this.isSafeNavigation = parameters.isSafeNavigation();
         this.isAttrAssign = parameters.isAttrAssign();
@@ -114,7 +112,7 @@ public Object executeWithArgumentsEvaluated(VirtualFrame frame, Object receiverO
             Object[] argumentsObjects) {
         if (dispatch == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            dispatch = insert(DispatchNode.create(ignoreVisibility ? PRIVATE : PROTECTED));
+            dispatch = insert(DispatchNode.create(dispatchConfig));
         }
 
         final Object returnValue = dispatch
@@ -183,8 +181,8 @@ private class DefinedNode extends RubyBaseNode {
         @Child private DispatchNode respondToMissing = DispatchNode.create(PRIVATE_RETURN_MISSING);
         @Child private BooleanCastNode respondToMissingCast = BooleanCastNodeGen.create(null);
 
-        // TODO CS-10-Apr-17 see below
-        // @Child private LookupMethodNode lookupMethodNode = LookupMethodNodeGen.create(ignoreVisibility, false, null, null);
+
+        @Child private LookupMethodOnSelfNode lookupMethodNode = LookupMethodOnSelfNode.create();
 
         private final ConditionProfile receiverDefinedProfile = ConditionProfile.create();
         private final BranchProfile argumentNotDefinedProfile = BranchProfile.create();
@@ -218,8 +216,7 @@ public Object isDefined(VirtualFrame frame, RubyContext context) {
                 return nil;
             }
 
-            final DeclarationContext declarationContext = RubyArguments.getDeclarationContext(frame);
-            final InternalMethod method = doLookup(receiverObject, declarationContext);
+            final InternalMethod method = lookupMethodNode.lookup(frame, receiverObject, methodName, dispatchConfig);
             final Object self = RubyArguments.getSelf(frame);
 
             if (methodNotFoundProfile.profile(method == null)) {
@@ -230,32 +227,16 @@ public Object isDefined(VirtualFrame frame, RubyContext context) {
                 }
             } else if (methodUndefinedProfile.profile(method.isUndefined())) {
                 return nil;
-            } else if (methodNotVisibleProfile.profile(!ignoreVisibility && !isVisibleTo(method, self))) {
+            } else if (methodNotVisibleProfile
+                    .profile(!dispatchConfig.ignoreVisibility && !isVisibleTo(method, self))) {
                 return nil;
             }
 
             return coreStrings().METHOD.createInstance();
         }
 
-        // TODO CS-10-Apr-17 remove this boundary
-
-        @TruffleBoundary
-        private InternalMethod doLookup(Object receiverObject, DeclarationContext declarationContext) {
-            // TODO CS-10-Apr-17 I'd like to use this but it doesn't give the same result
-            // lookupMethodNode.executeLookupMethod(frame, coreLibrary().getMetaClass(receiverObject), methodName);
-
-            return ModuleOperations
-                    .lookupMethodUncached(coreLibrary().getMetaClass(receiverObject), methodName, declarationContext);
-        }
-
-        // TODO CS-10-Apr-17 remove this boundary
-
-        @TruffleBoundary
         private boolean isVisibleTo(InternalMethod method, Object self) {
             return method.isVisibleTo(coreLibrary().getMetaClass(self));
         }
-
     }
-
-
 }

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

@@ -26,15 +26,15 @@ public static LookupMethodOnSelfNode create() {
         return LookupMethodOnSelfNodeGen.create();
     }
 
-    public InternalMethod lookupProtected(VirtualFrame frame, Object self, String name) {
-        return execute(frame, self, name, DispatchConfiguration.PROTECTED);
-    }
-
-    public InternalMethod lookupPrivate(
+    public InternalMethod lookup(
             VirtualFrame frame, Object self, String name, DispatchConfiguration config) {
         return execute(frame, self, name, config);
     }
 
+    public InternalMethod lookupProtected(VirtualFrame frame, Object self, String name) {
+        return execute(frame, self, name, DispatchConfiguration.PROTECTED);
+    }
+
     public InternalMethod lookupIgnoringVisibility(VirtualFrame frame, Object self, String name) {
         return execute(frame, self, name, DispatchConfiguration.PRIVATE);
     }