Stop throwing JSC_CANNOT_CONVERT_YET: Member references this or super error for public fields.

This includes adding support for transpilation of `this` and `super` in static fields by renaming them with the correct class name when the static field is moved outside of the class it was originally declared in.

PiperOrigin-RevId: 551554332

Author: Closure Team

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

@@ -1292,6 +1292,27 @@ private static boolean isHoistScopeRootNode(Node n) {
     }
   }
 
+  /** Returns the closest scope binding the `this` or `super` keyword */
+  public @Nullable Node getClosestScopeRootNodeBindingThisOrSuper() {
+    for (int i = scopes.size() - 1; i >= 0; i--) {
+      Node rootNode = getNodeRootFromScopeObj(scopes.get(i));
+      switch (rootNode.getToken()) {
+        case FUNCTION:
+          if (rootNode.isArrowFunction()) {
+            continue;
+          }
+          return rootNode;
+        case MEMBER_FIELD_DEF:
+        case CLASS:
+        case MODULE_BODY:
+        case ROOT:
+          return rootNode;
+        default:
+          continue;
+      }
+    }
+    return null;
+  }
 
   public ScopeCreator getScopeCreator() {
     return scopeCreator;
@@ -1360,8 +1381,7 @@ public void reportCodeChange(Node n) {
    *
    * <p>e.g. returns null if {@link #traverseInnerNode(Node, Node, AbstractScope)} was used
    */
-  @Nullable
-  Node getCurrentScript() {
+  @Nullable Node getCurrentScript() {
     return currentScript;
   }
 

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

@@ -95,11 +95,6 @@ public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
         return false;
       case MEMBER_FIELD_DEF:
         checkState(!classStack.isEmpty());
-        if (NodeUtil.referencesEnclosingReceiver(n)) {
-          t.report(n, TranspilationUtil.CANNOT_CONVERT_YET, "Member references this or super");
-          classStack.peek().cannotConvert = true;
-          break;
-        }
         classStack.peek().enterField(n);
         break;
       case BLOCK:
@@ -123,7 +118,7 @@ public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
           //    constructor(x) {}
           // }
           // Either using scopes to be more precise or just doing renaming for all conflicting
-          // constructor declarations would addresss this issue.
+          // constructor declarations would address this issue.
           record.potentiallyRecordNameInRhs(n);
         }
         break;
@@ -153,6 +148,22 @@ public void visit(NodeTraversal t, Node n, Node parent) {
       case MEMBER_FIELD_DEF:
         classStack.peek().exitField();
         return;
+      case THIS:
+        Node rootNode = t.getClosestScopeRootNodeBindingThisOrSuper();
+        if (rootNode.isMemberFieldDef() && rootNode.isStaticMember()) {
+          Node className = rootNode.getGrandparent().getFirstChild().cloneNode();
+          n.replaceWith(className);
+          t.reportCodeChange(className);
+        }
+        return;
+      case SUPER:
+        rootNode = t.getClosestScopeRootNodeBindingThisOrSuper();
+        if (rootNode.isMemberFieldDef() && rootNode.isStaticMember()) {
+          Node superclassName = rootNode.getGrandparent().getChildAtIndex(1).cloneNode();
+          n.replaceWith(superclassName);
+          t.reportCodeChange(superclassName);
+        }
+        return;
       default:
         return;
     }

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

@@ -91,7 +91,7 @@ public void testCannotConvertYet() {
 
     testError(
         lines(
-            "class C extends B{", //
+            "class C extends B {", //
             "  static {",
             "    let x = super.y",
             "  }",
@@ -165,14 +165,6 @@ public void testCannotConvertYet() {
             "}"),
         TranspilationUtil.CANNOT_CONVERT_YET); // `var` in static block
 
-    testError(
-        lines(
-            "class C {", //
-            "  static x = 1;",
-            "  static y = this.x;",
-            "}"),
-        TranspilationUtil.CANNOT_CONVERT_YET); // `this` in static field
-
     testError(
         lines(
             "let c = class C {", //
@@ -196,14 +188,6 @@ public void testCannotConvertYet() {
             "})"),
         TranspilationUtil.CANNOT_CONVERT_YET); // not class decl
 
-    testError(
-        lines(
-            "class C {", //
-            "  x = 1;",
-            "  y = this.x;",
-            "}"),
-        TranspilationUtil.CANNOT_CONVERT_YET); // `this` in public field
-
     testError(
         lines(
             "foo(class C {", //
@@ -288,10 +272,169 @@ public void testCannotConvertYet() {
                 "}" // testing that the correct number of diagnostics are thrown
                 )),
         error(TranspilationUtil.CANNOT_CONVERT_YET),
-        error(TranspilationUtil.CANNOT_CONVERT_YET),
         error(TranspilationUtil.CANNOT_CONVERT_YET));
   }
 
+  @Test
+  public void testThisInNonStaticPublicField() {
+    test(
+        lines(
+            "class A {", //
+            "  b = 'word';",
+            "  c = this.b;",
+            "}"),
+        lines(
+            "class A {",
+            "  constructor() {",
+            "    this.b = 'word';",
+            "    this.c = this.b;",
+            "  }",
+            "}"));
+
+    test(
+        lines(
+            "let obj = { bar() { return 9; } };", //
+            "class D {",
+            "  e = obj;",
+            "  f = this.e.bar() * 4;",
+            "}"),
+        lines(
+            "let obj = { bar() { return 9; } };",
+            "class D {",
+            "  constructor() {",
+            "    this.e = obj;",
+            "    this.f = this.e.bar() * 4;",
+            "  }",
+            "}"));
+
+    test(
+        lines(
+            "class Foo {", //
+            "  y = 'apple';",
+            "  x = () => { return this.y + ' and banana'; };",
+            "}"),
+        lines(
+            "class Foo {",
+            "  constructor() {",
+            "    this.y = 'apple';",
+            "    this.x = () => { return this.y + ' and banana'; };",
+            "  }",
+            "}"));
+
+    test(
+        lines(
+            "class Bar {", //
+            "  x = () => { this.method(); };",
+            "  method() {}",
+            "}"),
+        lines(
+            "class Bar {",
+            "  constructor() {",
+            "    this.x = () => { this.method(); };",
+            "  }",
+            "  method() {}",
+            "}"));
+  }
+
+  @Test
+  public void testSuperInNonStaticPublicField() {
+    test(
+        lines(
+            "class Foo {",
+            "  x() {",
+            "    return 3;",
+            "  }",
+            "}",
+            "class Bar extends Foo {",
+            "  y = 1 + super.x();",
+            "}"),
+        lines(
+            "class Foo {",
+            "  x() {",
+            "    return 3;",
+            "  }",
+            "}",
+            "class Bar extends Foo {",
+            "  constructor() {",
+            "    super(...arguments);",
+            "    this.y = 1 + super.x();",
+            "  }",
+            "}"));
+  }
+
+  @Test
+  public void testThisInStaticField() {
+    test(
+        lines(
+            "class C {", //
+            "  static x = 2;",
+            "  static y = () => this.x;",
+            "}"),
+        lines(
+            "class C {}", //
+            "C.x = 2;",
+            "C.y = () => C.x;"));
+
+    test(
+        lines(
+            "class F {", //
+            "  static a = 'there';",
+            "  static b = this.c() + this.a;",
+            "  static c() { return 'hi'; }",
+            "}"),
+        lines(
+            "class F {", //
+            "  static c() { return 'hi'; }",
+            "}",
+            "F.a = 'there';",
+            "F.b = F.c() + F.a;"));
+  }
+
+  @Test
+  public void testSuperInStaticField() {
+    test(
+        lines(
+            "class Foo {",
+            "  static x() {",
+            "    return 5;",
+            "  }",
+            "  static y() {",
+            "    return 20;",
+            "  }",
+            "}",
+            "class Bar extends Foo {",
+            "  static z = () => super.x() + 12 + super.y();",
+            "}"),
+        lines(
+            "class Foo {",
+            "  static x() {",
+            "    return 5;",
+            "  }",
+            "  static y() {",
+            "    return 20;",
+            "  }",
+            "}",
+            "class Bar extends Foo {}",
+            "Bar.z = () => Foo.x() + 12 + Foo.y();"));
+
+    test(
+        lines(
+            "class Bar {",
+            "  static a = { method1() {} };",
+            "  static b = { method2() { super.method1(); } };",
+            "}",
+            "Object.setPrototypeOf = function(c, d) {}",
+            "Object.setPrototypeOf(Foo.b, Foo.a);",
+            "Foo.b.method2();"),
+        lines(
+            "class Bar {}",
+            "Bar.a = { method1() {} };",
+            "Bar.b = { method2() { super.method1(); } };",
+            "Object.setPrototypeOf = function(c, d) {}",
+            "Object.setPrototypeOf(Foo.b, Foo.a);",
+            "Foo.b.method2();"));
+  }
+
   @Test
   public void testClassStaticBlocksNoFieldAssign() {
     test(
@@ -1243,9 +1386,19 @@ public void testInstanceInitializerDoesntShadowConstructorDeclaration() {
   @Test
   public void testInstanceFieldInitializersDontBleedOut() {
     test(
-        lines("class C {", "  y = z", "  method() { x; }", "  constructor(x) {}", "}"),
         lines(
-            "class C {", "  method() { x; }", "  constructor(x) {", "    this.y = z;", "  }", "}"));
+            "class C {", //
+            "  y = z",
+            "  method() { x; }",
+            "  constructor(x) {}",
+            "}"),
+        lines(
+            "class C {", //
+            "  method() { x; }",
+            "  constructor(x) {",
+            "    this.y = z;",
+            "  }",
+            "}"));
   }
 
   @Test