Introduce Template Literal AST node as a replacement for RuntimeNode.

Author: woess

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

@@ -157,11 +157,11 @@
 import com.oracle.js.parser.ir.PropertyKey;
 import com.oracle.js.parser.ir.PropertyNode;
 import com.oracle.js.parser.ir.ReturnNode;
-import com.oracle.js.parser.ir.RuntimeNode;
 import com.oracle.js.parser.ir.Scope;
 import com.oracle.js.parser.ir.Statement;
 import com.oracle.js.parser.ir.SwitchNode;
 import com.oracle.js.parser.ir.Symbol;
+import com.oracle.js.parser.ir.TemplateLiteralNode;
 import com.oracle.js.parser.ir.TernaryNode;
 import com.oracle.js.parser.ir.ThrowNode;
 import com.oracle.js.parser.ir.TryNode;
@@ -4411,7 +4411,7 @@ private Expression leftHandSideExpression(boolean yield, boolean await) {
 
                     final List<Expression> arguments = templateLiteralArgumentList(yield, await);
 
-                    lhs = CallNode.forCall(callLine, callToken, lhs.getStart(), finish, lhs, arguments, false, optionalChain);
+                    lhs = CallNode.forTaggedTemplateLiteral(callLine, callToken, lhs.getStart(), finish, lhs, arguments);
 
                     break;
                 }
@@ -6189,7 +6189,7 @@ private void endOfLine() {
     private Expression templateLiteral(boolean yield, boolean await) {
         assert type == TEMPLATE || type == TEMPLATE_HEAD;
         final boolean noSubstitutionTemplate = type == TEMPLATE;
-        long lastLiteralToken = token;
+        final long startToken = token;
         boolean previousPauseOnRightBrace = lexer.pauseOnRightBrace;
         try {
             lexer.pauseOnRightBrace = true;
@@ -6198,18 +6198,17 @@ private Expression templateLiteral(boolean yield, boolean await) {
                 return literal;
             }
 
-            Expression concat = literal;
+            List<Expression> expressions = new ArrayList<>();
+            expressions.add(literal);
             TokenType lastLiteralType;
             do {
                 Expression expression = templateLiteralExpression(yield, await);
-                expression = new RuntimeNode(Token.recast(expression.getToken(), VOID), expression.getFinish(), RuntimeNode.Request.TO_STRING, expression);
-                concat = new BinaryNode(Token.recast(lastLiteralToken, TokenType.ADD), concat, expression);
+                expressions.add(expression);
                 lastLiteralType = type;
-                lastLiteralToken = token;
                 literal = getLiteral();
-                concat = new BinaryNode(Token.recast(lastLiteralToken, TokenType.ADD), concat, literal);
+                expressions.add(literal);
             } while (lastLiteralType == TEMPLATE_MIDDLE);
-            return concat;
+            return TemplateLiteralNode.newUntagged(startToken, literal.getFinish(), expressions);
         } finally {
             lexer.pauseOnRightBrace = previousPauseOnRightBrace;
         }
@@ -6260,9 +6259,7 @@ private List<Expression> templateLiteralArgumentList(boolean yield, boolean awai
                 } while (lastLiteralType == TEMPLATE_MIDDLE);
             }
 
-            final LiteralNode<Expression[]> rawStringArray = LiteralNode.newInstance(templateToken, finish, rawStrings);
-            final LiteralNode<Expression[]> cookedStringArray = LiteralNode.newInstance(templateToken, finish, cookedStrings);
-            final RuntimeNode templateObject = new RuntimeNode(templateToken, finish, RuntimeNode.Request.GET_TEMPLATE_OBJECT, rawStringArray, cookedStringArray);
+            final Expression templateObject = TemplateLiteralNode.newTagged(templateToken, rawStrings.get(rawStrings.size() - 1).getFinish(), rawStrings, cookedStrings);
             argumentList.set(0, templateObject);
             return optimizeList(argumentList);
         } finally {

graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ir/CallNode.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
@@ -76,6 +76,9 @@ public final class CallNode extends OptionalExpression {
     /** Is this call part of an optional chain. */
     private static final int IS_OPTIONAL_CHAIN = 1 << 5;
 
+    /** Is this a tagged template literal call. */
+    private static final int IS_TAGGED_TEMPLATE_LITERAL = 1 << 6;
+
     private final int flags;
 
     private final int lineNumber;
@@ -95,8 +98,19 @@ public static Expression forCall(int lineNumber, long token, int start, int fini
 
     public static Expression forCall(int lineNumber, long token, int start, int finish, Expression function, List<Expression> args,
                     boolean optional, boolean optionalChain, boolean isEval, boolean isApplyArguments) {
+        return create(lineNumber, token, start, finish, function, args, optional, optionalChain, isEval, isApplyArguments, false);
+    }
+
+    public static Expression forTaggedTemplateLiteral(int lineNumber, long token, int start, int finish, Expression function, List<Expression> args) {
+        return create(lineNumber, token, start, finish, function, args, false, false, false, false, true);
+    }
+
+    private static Expression create(int lineNumber, long token, int start, int finish, Expression function, List<Expression> args,
+                    boolean optional, boolean optionalChain, boolean isEval, boolean isApplyArguments, boolean isTaggedTemplateLiteral) {
         return new CallNode(lineNumber, token, start, finish, setIsFunction(function), args,
-                        (optional ? IS_OPTIONAL : 0) | (optionalChain ? IS_OPTIONAL_CHAIN : 0) | (isEval ? IS_EVAL : 0) | (isApplyArguments ? IS_APPLY_ARGUMENTS : 0));
+                        (optional ? IS_OPTIONAL : 0) | (optionalChain ? IS_OPTIONAL_CHAIN : 0) |
+                                        (isEval ? IS_EVAL : 0) | (isApplyArguments ? IS_APPLY_ARGUMENTS : 0) |
+                                        (isTaggedTemplateLiteral ? IS_TAGGED_TEMPLATE_LITERAL : 0));
     }
 
     public static Expression forImport(int lineNumber, long token, int start, int finish, IdentNode importIdent, List<Expression> args) {
@@ -266,4 +280,11 @@ public boolean isOptional() {
     public boolean isOptionalChain() {
         return (flags & IS_OPTIONAL_CHAIN) != 0;
     }
+
+    /**
+     * Check if this is a tagged template literal call.
+     */
+    public boolean isTaggedTemplateLiteral() {
+        return (flags & IS_TAGGED_TEMPLATE_LITERAL) != 0;
+    }
 }