Remove genaral getWrappedNodeRecursive and replace with concrete unwrapping mechanism in order not to cause problems for partial evaluation.

Author: jchalou

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/JSNodeUtil.java

@@ -148,47 +148,27 @@ public static boolean isWrapperNode(JavaScriptNode node) {
     }
 
     /**
-     * Convenience method for {@link JSNodeUtil#getWrappedNodeRecursive(JavaScriptNode, int)} with
-     * maxDepth == 1.
+     * Helper to retrieve the node wrapped by a given JavaScript node.
      *
-     */
-    public static JavaScriptNode getWrappedNode(JavaScriptNode node) {
-        return getWrappedNodeRecursive(node, 1);
-    }
-
-    /**
-     * Helper to retrieve the node wrapped by an instrumentation wrapper and/or JavaScript wrapper
-     * node(s).
-     *
-     * @param node a JavaScript node that is possibly a wrapper or an instrumentation wrapper
-     *            wrapping a JavaScript node.
+     * @param node a JavaScript node that is possibly a wrapper
      * @return the (delegate) node that is wrapped by the parameter <code>node</code>, or
-     *         <code>node</code> itself if it is not a wrapper that can be stripped. This method
-     *         proceeds recursively until a node that is not a wrapper is found or maxDepth is
-     *         reached.
+     *         <code>node</code> itself if it is not a wrapper that can be stripped
      */
-    public static JavaScriptNode getWrappedNodeRecursive(JavaScriptNode node, int maxDepth) {
-        assert maxDepth > 0 : "maxDepth for getWrappedNodeRecursive must be at least 1!";
-        JavaScriptNode wrapped;
+    public static JavaScriptNode getWrappedNode(JavaScriptNode node) {
         JavaScriptNode unwrapped = node;
-        int depth = 0;
-        do {
-            wrapped = unwrapped;
-            if (wrapped instanceof WrapperNode) {
-                WrapperNode wrapper = (WrapperNode) wrapped;
-                // JavaScriptNode wrappers have a JavaScriptNode as delegate
-                unwrapped = (JavaScriptNode) wrapper.getDelegateNode();
-            } else if (wrapped instanceof GlobalScopeVarWrapperNode) {
-                unwrapped = ((GlobalScopeVarWrapperNode) wrapped).getDelegateNode();
-            } else if (wrapped instanceof JSInputGeneratingNodeWrapper) {
-                unwrapped = ((JSInputGeneratingNodeWrapper) wrapped).getDelegateNode();
-            } else if (wrapped instanceof JSTaggedExecutionNode) {
-                unwrapped = ((JSTaggedExecutionNode) wrapped).getDelegateNode();
-            } else if (wrapped instanceof JSTargetableWrapperNode) {
-                unwrapped = ((JSTargetableWrapperNode) wrapped).getDelegate();
-            }
-            depth++;
-        } while (unwrapped != wrapped && depth < maxDepth);
+        if (node instanceof WrapperNode) {
+            WrapperNode wrapper = (WrapperNode) node;
+            // JavaScriptNode wrappers have a JavaScriptNode as delegate
+            unwrapped = (JavaScriptNode) wrapper.getDelegateNode();
+        } else if (node instanceof GlobalScopeVarWrapperNode) {
+            unwrapped = ((GlobalScopeVarWrapperNode) node).getDelegateNode();
+        } else if (node instanceof JSInputGeneratingNodeWrapper) {
+            unwrapped = ((JSInputGeneratingNodeWrapper) node).getDelegateNode();
+        } else if (node instanceof JSTaggedExecutionNode) {
+            unwrapped = ((JSTaggedExecutionNode) node).getDelegateNode();
+        } else if (node instanceof JSTargetableWrapperNode) {
+            unwrapped = ((JSTargetableWrapperNode) node).getDelegate();
+        }
         assert !isWrapperNode(unwrapped);
         return unwrapped;
     }

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/access/SuperPropertyReferenceNode.java

@@ -41,14 +41,17 @@
 package com.oracle.truffle.js.nodes.access;
 
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.instrumentation.GenerateWrapper;
+import com.oracle.truffle.api.instrumentation.ProbeNode;
 import com.oracle.truffle.api.instrumentation.Tag;
 import com.oracle.truffle.js.nodes.JavaScriptNode;
 import com.oracle.truffle.js.nodes.RepeatableNode;
 import com.oracle.truffle.js.nodes.access.RequireObjectCoercibleNode.RequireObjectCoercibleWrapperNode;
 
 import java.util.Set;
 
-public final class SuperPropertyReferenceNode extends JSTargetableNode implements RepeatableNode {
+@GenerateWrapper
+public class SuperPropertyReferenceNode extends JSTargetableNode implements RepeatableNode {
 
     @Child private JavaScriptNode baseValueNode;
     @Child private JavaScriptNode thisValueNode;
@@ -58,6 +61,11 @@ private SuperPropertyReferenceNode(JavaScriptNode baseNode, JavaScriptNode thisV
         this.thisValueNode = thisValueNode;
     }
 
+    SuperPropertyReferenceNode(SuperPropertyReferenceNode copy) {
+        this.baseValueNode = copy.baseValueNode;
+        this.thisValueNode = copy.thisValueNode;
+    }
+
     public static JSTargetableNode create(JavaScriptNode baseNode, JavaScriptNode thisValueNode) {
         assert baseNode instanceof RepeatableNode && thisValueNode instanceof RepeatableNode;
         return new SuperPropertyReferenceNode(RequireObjectCoercibleWrapperNode.create(baseNode), thisValueNode);
@@ -93,6 +101,11 @@ public JavaScriptNode getTarget() {
         return thisValueNode;
     }
 
+    @Override
+    public WrapperNode createWrapper(ProbeNode probe) {
+        return new SuperPropertyReferenceNodeWrapper(this, this, probe);
+    }
+
     @Override
     protected JavaScriptNode copyUninitialized(Set<Class<? extends Tag>> materializedTags) {
         return new SuperPropertyReferenceNode(cloneUninitialized(baseValueNode, materializedTags), cloneUninitialized(thisValueNode, materializedTags));

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/function/JSFunctionCallNode.java

@@ -74,7 +74,6 @@
 import com.oracle.truffle.api.profiles.ValueProfile;
 import com.oracle.truffle.js.lang.JavaScriptLanguage;
 import com.oracle.truffle.js.nodes.JSGuards;
-import com.oracle.truffle.js.nodes.JSNodeUtil;
 import com.oracle.truffle.js.nodes.JavaScriptBaseNode;
 import com.oracle.truffle.js.nodes.JavaScriptNode;
 import com.oracle.truffle.js.nodes.access.JSConstantNode.JSConstantUndefinedNode;
@@ -85,6 +84,7 @@
 import com.oracle.truffle.js.nodes.access.SuperPropertyReferenceNode;
 import com.oracle.truffle.js.nodes.instrumentation.JSInputGeneratingNodeWrapper;
 import com.oracle.truffle.js.nodes.instrumentation.JSMaterializedInvokeTargetableNode;
+import com.oracle.truffle.js.nodes.instrumentation.JSTaggedExecutionNode;
 import com.oracle.truffle.js.nodes.instrumentation.JSTags;
 import com.oracle.truffle.js.nodes.instrumentation.JSTags.FunctionCallTag;
 import com.oracle.truffle.js.nodes.instrumentation.JSTags.ReadElementTag;
@@ -446,7 +446,19 @@ public NodeCost getCost() {
     public abstract JavaScriptNode getTarget();
 
     protected final Object evaluateReceiver(VirtualFrame frame, Object target) {
-        JavaScriptNode targetNode = JSNodeUtil.getWrappedNodeRecursive(getTarget(), Integer.MAX_VALUE);
+        Node targetNode = getTarget();
+        /*
+         * SuperPropertyReferenceNode's instrumentation wrapper is an instance of
+         * SuperPropertyReferenceNode. So, normally we wouldn't need to unwrap it. However, it can
+         * be wrapped by JSTaggedExecutionNode and that could be wrapped by an instrumentation
+         * wrapper. If that's the case, we have to unwrap twice.
+         */
+        if (targetNode instanceof WrapperNode) {
+            targetNode = ((WrapperNode) targetNode).getDelegateNode();
+        }
+        if (targetNode instanceof JSTaggedExecutionNode) {
+            targetNode = ((JSTaggedExecutionNode) targetNode).getDelegateNode();
+        }
         if (targetNode instanceof SuperPropertyReferenceNode) {
             return ((SuperPropertyReferenceNode) targetNode).evaluateTarget(frame);
         }