RewriteClassMembers: correct creation of class name for this

The pass was assuming a CLASS node's first child is always the correct
NAME node to use.

PiperOrigin-RevId: 562878308

Author: brad4d

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

@@ -71,7 +71,7 @@ public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
             n.getFirstChild().isEmpty() || classNameNode.matchesQualifiedName(n.getFirstChild()),
             "Class name shadows variable declaring the class: %s",
             n);
-        classStack.push(new ClassRecord(n, classNameNode.getQualifiedName(), classInsertionPoint));
+        classStack.push(new ClassRecord(n, classNameNode, classInsertionPoint));
         break;
       case COMPUTED_FIELD_DEF:
         checkState(!classStack.isEmpty());
@@ -125,40 +125,56 @@ public void exitScope(NodeTraversal t) {}
   public void visit(NodeTraversal t, Node n, Node parent) {
     switch (n.getToken()) {
       case CLASS:
-        visitClass(t);
-        return;
+        visitClass(t, n);
+        break;
       case THIS:
-        Node rootNode = t.getClosestScopeRootNodeBindingThisOrSuper();
-        if (rootNode.isStaticMember()
-            && (rootNode.isMemberFieldDef() || rootNode.isComputedFieldDef())) {
-          Node className = rootNode.getGrandparent().getFirstChild().cloneNode();
-          n.replaceWith(className);
-          t.reportCodeChange(className);
-        }
-        return;
+        visitThis(t, n);
+        break;
       case SUPER:
-        rootNode = t.getClosestScopeRootNodeBindingThisOrSuper();
-        if (rootNode.isMemberFieldDef() && rootNode.isStaticMember()) {
-          Node superclassName = rootNode.getGrandparent().getChildAtIndex(1).cloneNode();
-          n.replaceWith(superclassName);
-          t.reportCodeChange(superclassName);
-        }
-        return;
+        visitSuper(t, n);
+        break;
       default:
-        return;
+        break;
     }
   }
 
   /** Transpile the actual class members themselves */
-  private void visitClass(NodeTraversal t) {
+  private void visitClass(NodeTraversal t, Node classNode) {
     ClassRecord currClassRecord = classStack.pop();
+    checkState(currClassRecord.classNode == classNode, "unexpected node: %s", classNode);
     if (currClassRecord.cannotConvert) {
       return;
     }
     rewriteInstanceMembers(t, currClassRecord);
     rewriteStaticMembers(t, currClassRecord);
   }
 
+  private void visitThis(NodeTraversal t, Node thisNode) {
+    Node rootNode = t.getClosestScopeRootNodeBindingThisOrSuper();
+    if (rootNode.isStaticMember()
+        && (rootNode.isMemberFieldDef() || rootNode.isComputedFieldDef())) {
+      final Node classNode = rootNode.getGrandparent();
+      final ClassRecord classRecord = classStack.peek();
+      checkState(
+          classRecord.classNode == classNode,
+          "wrong class node: %s != %s",
+          classRecord.classNode,
+          classNode);
+      Node className = classRecord.createNewNameReferenceNode().srcrefTree(thisNode);
+      thisNode.replaceWith(className);
+      t.reportCodeChange(className);
+    }
+  }
+
+  private void visitSuper(NodeTraversal t, Node n) {
+    Node rootNode = t.getClosestScopeRootNodeBindingThisOrSuper();
+    if (rootNode.isMemberFieldDef() && rootNode.isStaticMember()) {
+      Node superclassName = rootNode.getGrandparent().getChildAtIndex(1).cloneNode();
+      n.replaceWith(superclassName);
+      t.reportCodeChange(superclassName);
+    }
+  }
+
   /**
    * Move computed fields with side effects into a computed function (Token is COMPUTED_PROP) to
    * preserve the original behavior of possible side effects such as printing something in the call
@@ -316,8 +332,7 @@ private void rewriteStaticMembers(NodeTraversal t, ClassRecord record) {
       Node staticMember = staticMembers.pop();
       // if the name is a property access, we want the whole chain of accesses, while for other
       // cases we only want the name node
-      Node nameToUse =
-          astFactory.createQNameWithUnknownType(record.classNameString).srcrefTree(staticMember);
+      Node nameToUse = record.createNewNameReferenceNode().srcrefTree(staticMember);
 
       Node transpiledNode;
 
@@ -454,17 +469,17 @@ private static final class ClassRecord {
     ImmutableSet<Var> constructorVars = ImmutableSet.of();
 
     final Node classNode;
-    final String classNameString;
+    final Node classNameNode;
 
     // Keeps track of the statement declaring the class
     final Node insertionPointBeforeClass;
 
     // Keeps track of the last statement inserted after the class
     Node insertionPointAfterClass;
 
-    ClassRecord(Node classNode, String classNameString, Node classInsertionPoint) {
+    ClassRecord(Node classNode, Node classNameNode, Node classInsertionPoint) {
       this.classNode = classNode;
-      this.classNameString = classNameString;
+      this.classNameNode = classNameNode;
       this.insertionPointBeforeClass = classInsertionPoint;
       this.insertionPointAfterClass = classInsertionPoint;
     }
@@ -492,5 +507,15 @@ void recordConstructorScope(Scope s) {
       builder.addAll(argsScope.getAllSymbols());
       constructorVars = builder.build();
     }
+
+    Node createNewNameReferenceNode() {
+      if (classNameNode.isName()) {
+        // Don't cloneTree() here, because the name may have a child node, the class itself.
+        return classNameNode.cloneNode();
+      } else {
+        // Must cloneTree() for a qualified name.
+        return classNameNode.cloneTree();
+      }
+    }
   }
 }

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

@@ -412,6 +412,32 @@ public void testComputedPropInStaticField() {
             "C[1] = 1;",
             "C[2] = C[1];"));
 
+    test(
+        lines(
+            "/** @unrestricted */",
+            "const C = class {", //
+            "  static [1] = 1;",
+            "  static [2] = this[1];",
+            "}"),
+        lines(
+            "const C = class {}", //
+            "C[1] = 1;",
+            "C[2] = C[1];"));
+
+    test(
+        lines(
+            "/** @unrestricted */",
+            "const C = class InnerC {", //
+            "  static [1] = 1;",
+            "  static [2] = this[1];",
+            "}"),
+        lines(
+            "const testcode$classdecl$var0 = class {}", //
+            "testcode$classdecl$var0[1] = 1;",
+            "testcode$classdecl$var0[2] = testcode$classdecl$var0[1];",
+            "/** @constructor */",
+            "const C = testcode$classdecl$var0;"));
+
     test(
         lines(
             "/** @unrestricted */",