Mark the newly created $jscomp$destructuring$var declarations in Es6RewriteDestructuring pass with IS_CONSTANT_NAME prop

Also special case and mark those names as constants even in ES6RewriteRestAndSpread as that pass transitions to running post-normalization.

PiperOrigin-RevId: 618368483

Author: rishipal

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

@@ -321,7 +321,13 @@ private Node replacePatternParamWithTempVar(
    * (the compiler only assigns $jscomp$destructuring$var[num] once)
    */
   private Node createTempVarNameNode(String name, AstFactory.Type type) {
-    return astFactory.createConstantName(name, type);
+    // NOTE: This does not really create a constant node as this pass runs before normalization. See
+    // b/322009741.
+    Node ret = astFactory.createConstantName(name, type);
+    // TODO(b/197349249): When this pass moves post normalization, stop explictly marking these
+    // names as const, as createConstantName will automatically do that.
+    ret.putBooleanProp(Node.IS_CONSTANT_NAME, true);
+    return ret;
   }
 
   /** Creates a new unique name to use for a pattern we need to rewrite. */

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

@@ -105,6 +105,18 @@ private void visitRestParam(NodeTraversal t, Node restParam, Node paramList) {
                     astFactory.createNumber(restIndex),
                     astFactory.createArgumentsReference()))
             .srcrefTreeIfMissing(functionBody);
+    if (paramName.startsWith("$jscomp$destructuring$var")) {
+      // Currently this pass is before normalization. Hence, the createSingleLetNameDeclaration
+      // creates a non-const names. But the earlier Es6RewriteDesctructuring pass creates these
+      // names as const names.
+      // TODO(b/197349249): When this pass moves post normalization, stop explictly marking these
+      // names as const in this if-block.
+      checkState(
+          nameNode.getBooleanProp(Node.IS_CONSTANT_NAME),
+          "The $jscomp$destructuring$var[num] name must've been marked as const by the"
+              + " Es6RewriteDesctructuring pass");
+      let.getFirstChild().putBooleanProp(Node.IS_CONSTANT_NAME, true);
+    }
     functionBody.addChildToFront(let);
     NodeUtil.addFeatureToScript(t.getCurrentScript(), Feature.LET_DECLARATIONS, compiler);
     compiler.ensureLibraryInjected("es6/util/restarguments", /* force= */ false);

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

@@ -15,6 +15,7 @@
  */
 package com.google.javascript.jscomp;
 
+import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.javascript.rhino.testing.NodeSubject.assertNode;
 
@@ -556,6 +557,30 @@ public void testArrayDestructuring_inVanillaForInitializer_let() {
             "true; c++) {}"));
   }
 
+  @Test
+  public void testSimpleDestructuring_constAnnotationAdded() {
+
+    test(
+        "function foo(...{length}) {}",
+        // pull destructuring out of params first.
+        lines(
+            "function foo(...$jscomp$destructuring$var0) {",
+            "  var $jscomp$destructuring$var1 = $jscomp$destructuring$var0;",
+            "  var length = $jscomp$destructuring$var1.length;",
+            "}"));
+    Node script = getLastCompiler().getJsRoot().getFirstChild();
+    checkState(script.isScript());
+    Node func = script.getFirstChild();
+    checkState(func.isFunction());
+    Node block = func.getLastChild();
+    checkState(block.isBlock());
+    // `var $jscomp$destructuring$var1 =  ...`
+    Node var1 = block.getFirstFirstChild();
+    checkState(var1.isName());
+    assertThat(var1.getString()).isEqualTo("$jscomp$destructuring$var1");
+    assertThat(var1.getBooleanProp(Node.IS_CONSTANT_NAME)).isTrue();
+  }
+
   @Test
   public void testArrayDestructuringRest() {
     test(