Make tagged template literal transpilation work in @closureUnaware mode

PiperOrigin-RevId: 851365723

Author: lauraharker

src/com/google/javascript/jscomp/LateEs6ToEs3Converter.java

@@ -76,12 +76,24 @@ public void process(Node externs, Node root) {
   @Override
   public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
     if (n.isScript()) {
-      // For all scripts, initialize the injection point to be top of the script
-      templateLitInsertionPoint = n.getFirstChild();
+      templateLitInsertionPoint = findTemplateLitInsertionPoint(n);
     }
     return true;
   }
 
+  private static Node findTemplateLitInsertionPoint(Node script) {
+    if (script.getIsInClosureUnawareSubtree()) {
+      // For all closure-unaware scripts, initialize the injection point within the closure
+      // aware function.
+      Node closureUnawareBlock = NodeUtil.findClosureUnawareScriptRoot(script);
+      return NodeUtil.getInsertionPointAfterAllInnerFunctionDeclarations(closureUnawareBlock);
+    }
+    // For all other scripts, initialize the injection point to be top of the script. The spec
+    // requires a single unique array per template literal, so for a template literal in a function
+    // e.g. it would be incorrect to initialize a new array per every function call.
+    return script.getFirstChild();
+  }
+
   @Override
   public void visit(NodeTraversal t, Node n, Node parent) {
     switch (n.getToken()) {

src/com/google/javascript/jscomp/NodeUtil.java

@@ -821,6 +821,22 @@ public static boolean isLiteralValue(Node n, boolean includeFunctions) {
     }
   }
 
+  /**
+   * Returns the closureUnaware function body within a script modelling a shadow AST
+   *
+   * <p>TranspileAndOptimizeClosureUnaware pass models each @closureUnaware block as a function
+   * body, and will throw a runtime exception if any pass inserts new code outside that function
+   * body. So we sometimes need to map from an actual script node to the
+   * corresponding @closureUnaware script-esque block.
+   *
+   * <p>TODO: lharker - if we end up needing this special logic often, consider instead making
+   * TranspileAndOptimizeclosureUnaware support inserting code at the script level.
+   */
+  static Node findClosureUnawareScriptRoot(Node script) {
+    checkArgument(script.isScript() && script.getIsInClosureUnawareSubtree(), script);
+    return NodeUtil.findPreorder(script, Node::isBlock, (c) -> true);
+  }
+
   /**
    * Returns the node within the given block at which something can be inserted such that it's after
    * all inner function declarations in that block. We want this because normalization expects all

test/com/google/javascript/jscomp/TranspileAndOptimizeClosureUnawareTest.java

@@ -455,6 +455,46 @@ public void doesNotAutomaticallyInjectPolyfills() {
             """));
   }
 
+  @Test
+  public void taggedTemplateLitTranspilation() {
+    extraOptions = (options) -> options.setGeneratePseudoNames(true);
+    setLanguageOut(CompilerOptions.LanguageMode.ECMASCRIPT5);
+
+    test(
+        srcs(
+            closureUnaware(
+                """
+                function tag(strings, ...values) {
+                  return {strings, values};
+                }
+                tag`a${42}b`;
+                tag`a${42}b`; // identical template lit
+                tag`a${-42}b`; // identical template strings, different substitution content
+                """)),
+        expected(
+            """
+            /** @fileoverview @closureUnaware */
+            goog.module('test0');
+            /** @closureUnaware */
+            (function($$jscomp_getRestArguments$$, $$jscomp_createTemplateTagFirstArg$$) {
+              function $tag$$($strings$$) {
+                var $values$$ = $$jscomp_getRestArguments$$.apply(1, arguments);
+                return {strings:$strings$$, values:$values$$};
+              }
+              /** @noinline */
+              var $$jscomp$templatelit$m854121055$0$$ =
+                      $$jscomp_createTemplateTagFirstArg$$(["a", "b"]),
+                  $$jscomp$templatelit$m854121055$1$$ =
+                      $$jscomp_createTemplateTagFirstArg$$(["a", "b"]),
+                  $$jscomp$templatelit$m854121055$2$$ =
+                      $$jscomp_createTemplateTagFirstArg$$(["a", "b"]);
+              $tag$$($$jscomp$templatelit$m854121055$0$$, 42);
+              $tag$$($$jscomp$templatelit$m854121055$1$$, 42);
+              $tag$$($$jscomp$templatelit$m854121055$2$$, -42);
+            }).call(undefined, $jscomp.getRestArguments, $jscomp.createTemplateTagFirstArg);
+            """));
+  }
+
   private static String loadFile(Path path) {
     try (Stream<String> lines = Files.lines(path)) {
       return lines.collect(joining("\n"));