[GR-30915] Fix NamedEvaluation of anonymous class expressions in class field initializers.

PullRequest: js/1983

Author: woess

graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/Parser.java

@@ -1965,6 +1965,7 @@ private Pair<FunctionNode, Boolean> fieldInitializer(int lineNumber, long fieldT
                 initializer = setAnonymousFunctionName(initializer, ((PropertyKey) propertyName).getPropertyName());
             } else {
                 isAnonymousFunctionDefinition = true;
+                initializer = new UnaryNode(Token.recast(initializer.getToken(), TokenType.NAMEDEVALUATION), initializer);
             }
         }
 

graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/TokenType.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -229,7 +229,8 @@ public enum TokenType {
     SPREAD_ARRAY   (IR,           null),
     SPREAD_OBJECT  (IR,           null),
     YIELD_STAR     (IR,           null),
-    ASSIGN_INIT    (IR,           null);
+    ASSIGN_INIT    (IR,           null),
+    NAMEDEVALUATION(IR,           null);
     //@formatter:on
 
     /** Next token kind in token lookup table. */

graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSTranslator.java

@@ -1971,6 +1971,8 @@ public JavaScriptNode enterUnaryNode(UnaryNode unaryNode) {
                 return tagExpression(createYieldNode(unaryNode), unaryNode);
             case AWAIT:
                 return tagExpression(translateAwaitNode(unaryNode), unaryNode);
+            case NAMEDEVALUATION:
+                return enterNamedEvaluation(unaryNode);
             default:
                 throw new UnsupportedOperationException(unaryNode.tokenType().toString());
         }
@@ -2098,6 +2100,10 @@ private static UnaryOperation tokenTypeToUnaryOperation(TokenType tokenType) {
         }
     }
 
+    private JavaScriptNode enterNamedEvaluation(UnaryNode unaryNode) {
+        return factory.createNamedEvaluation(transform(unaryNode.getExpression()), factory.createAccessArgument(0));
+    }
+
     private JavaScriptNode enterDelete(UnaryNode unaryNode) {
         Expression rhs = unaryNode.getExpression();
         if (rhs instanceof AccessNode || rhs instanceof IndexNode) {

graal-js/src/com.oracle.truffle.js.test/js/class_field_named_evaluation.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Licensed under the Universal Permissive License v 1.0 as shown at http://oss.oracle.com/licenses/upl.
+ */
+
+/**
+ * Tests NamedEvaluation of anonymous function definitions in class field initializers.
+ *
+ * @option ecmascript-version=2021
+ */
+
+load('assert.js');
+
+let C;
+C = class { x = class { static y = this.name; } };            assertSame("x", new C().x.y);
+C = class { ['x'] = class { static y = this.name; } };        assertSame("x", new C().x.y);
+C = class { static x = class { static y = this.name; } };     assertSame("x", C.x.y);
+C = class { static ['x'] = class { static y = this.name; } }; assertSame("x", C.x.y);

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

@@ -199,6 +199,7 @@
 import com.oracle.truffle.js.nodes.function.JSFunctionCallNode;
 import com.oracle.truffle.js.nodes.function.JSFunctionExpressionNode;
 import com.oracle.truffle.js.nodes.function.JSNewNode;
+import com.oracle.truffle.js.nodes.function.NamedEvaluationNode;
 import com.oracle.truffle.js.nodes.function.NewTargetRootNode;
 import com.oracle.truffle.js.nodes.function.SpreadArgumentNode;
 import com.oracle.truffle.js.nodes.module.ImportMetaNode;
@@ -1166,6 +1167,10 @@ public JavaScriptNode createOptionalChainShortCircuit(JavaScriptNode valueNode)
         return OptionalChainNode.createShortCircuit(valueNode);
     }
 
+    public JavaScriptNode createNamedEvaluation(JavaScriptNode expressionNode, JavaScriptNode nameNode) {
+        return NamedEvaluationNode.create(expressionNode, nameNode);
+    }
+
     public IfNode copyIfWithCondition(IfNode origIfNode, JavaScriptNode condition) {
         return IfNode.create(condition, origIfNode.getThenPart(), origIfNode.getElsePart());
     }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -40,6 +40,8 @@
  */
 package com.oracle.truffle.js.nodes.access;
 
+import java.util.Set;
+
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Cached.Shared;
@@ -52,15 +54,12 @@
 import com.oracle.truffle.js.nodes.JavaScriptBaseNode;
 import com.oracle.truffle.js.nodes.JavaScriptNode;
 import com.oracle.truffle.js.nodes.function.JSFunctionCallNode;
-import com.oracle.truffle.js.nodes.function.SetFunctionNameNode;
 import com.oracle.truffle.js.runtime.JSArguments;
 import com.oracle.truffle.js.runtime.JSContext;
 import com.oracle.truffle.js.runtime.JSRuntime;
 import com.oracle.truffle.js.runtime.builtins.JSFunction;
 import com.oracle.truffle.js.runtime.objects.Undefined;
 
-import java.util.Set;
-
 /**
  * InitializeInstanceElements (O, constructor).
  *
@@ -175,34 +174,27 @@ static DefineFieldNode[] createFieldNodes(Object[][] fields, JSContext context)
             if (initializer != Undefined.instance) {
                 callNode = JSFunctionCallNode.createCall();
             }
-            SetFunctionNameNode setFunctionNameNode = null;
-            if (isAnonymousFunctionDefinition) {
-                setFunctionNameNode = SetFunctionNameNode.create();
-            }
-            fieldNodes[i] = new DefineFieldNode(writeNode, callNode, setFunctionNameNode);
+            fieldNodes[i] = new DefineFieldNode(writeNode, callNode, isAnonymousFunctionDefinition);
         }
         return fieldNodes;
     }
 
     static final class DefineFieldNode extends JavaScriptBaseNode {
         @Child JavaScriptBaseNode writeNode;
         @Child JSFunctionCallNode callNode;
-        @Child SetFunctionNameNode setFunctionNameNode;
+        private final boolean isAnonymousFunctionDefinition;
 
-        DefineFieldNode(JavaScriptBaseNode writeNode, JSFunctionCallNode callNode, SetFunctionNameNode setFunctionNameNode) {
+        DefineFieldNode(JavaScriptBaseNode writeNode, JSFunctionCallNode callNode, boolean isAnonymousFunctionDefinition) {
             this.writeNode = writeNode;
             this.callNode = callNode;
-            this.setFunctionNameNode = setFunctionNameNode;
+            this.isAnonymousFunctionDefinition = isAnonymousFunctionDefinition;
         }
 
         void defineField(Object target, Object key, Object initializer) {
             assert (callNode != null) == (initializer != Undefined.instance);
             Object value = Undefined.instance;
             if (callNode != null) {
-                value = callNode.executeCall(JSArguments.createZeroArg(target, initializer));
-                if (setFunctionNameNode != null) {
-                    setFunctionNameNode.execute(value, key);
-                }
+                value = callNode.executeCall(isAnonymousFunctionDefinition ? JSArguments.createOneArg(target, initializer, key) : JSArguments.createZeroArg(target, initializer));
             }
             if (writeNode instanceof PrivateFieldAddNode) {
                 assert key instanceof HiddenKey : key;

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

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.truffle.js.nodes.function;
+
+import java.util.Set;
+
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.instrumentation.Tag;
+import com.oracle.truffle.js.nodes.JSNodeUtil;
+import com.oracle.truffle.js.nodes.JavaScriptNode;
+
+/**
+ * Represent a NamedEvaluation with a name that is computed / not already known at parse time.
+ */
+public class NamedEvaluationNode extends JavaScriptNode {
+    @Child protected JavaScriptNode nameNode;
+    @Child protected JavaScriptNode expressionNode;
+    @Child SetFunctionNameNode setFunctionNameNode;
+
+    protected NamedEvaluationNode(JavaScriptNode expressionNode, JavaScriptNode nameNode) {
+        this.nameNode = nameNode;
+        this.expressionNode = expressionNode;
+        this.setFunctionNameNode = JSNodeUtil.getWrappedNode(expressionNode) instanceof ClassDefinitionNode ? null : SetFunctionNameNode.create();
+    }
+
+    public static JavaScriptNode create(JavaScriptNode expressionNode, JavaScriptNode nameNode) {
+        return new NamedEvaluationNode(expressionNode, nameNode);
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        Object name = nameNode.execute(frame);
+        Object function;
+        JavaScriptNode unwrappedExprNode;
+        if ((unwrappedExprNode = JSNodeUtil.getWrappedNode(expressionNode)) instanceof ClassDefinitionNode) {
+            function = ((ClassDefinitionNode) unwrappedExprNode).executeWithClassName(frame, name);
+        } else {
+            function = expressionNode.execute(frame);
+            setFunctionNameNode.execute(function, name);
+        }
+        return function;
+    }
+
+    @Override
+    protected JavaScriptNode copyUninitialized(Set<Class<? extends Tag>> materializedTags) {
+        return create(cloneUninitialized(expressionNode, materializedTags), cloneUninitialized(nameNode, materializedTags));
+    }
+}