Allow the super keyword calling a function to be used to instantiate public fields.

Before, when assigning a public field through the `super` keyword calling a function, we would throw `JSC_INVALID_SUPER_ACCESS`. We now check to see if we are in the context of a `MEMBER_FIELD_DEF` to allow the `super` keyword to call a function. A new class called `SuperPropertyAccessAllowedContext`, is now used to create a new context for static blocks and fields given their same behavior.

PiperOrigin-RevId: 552580668

Author: Closure Team

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

@@ -111,14 +111,14 @@ public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
           }
         }
         break;
-
+      case MEMBER_FIELD_DEF:
+        Context fieldContext = createMemberFieldDefContext(n);
+        this.contextStack.push(fieldContext);
+        break;
       case BLOCK: // For class static blocks
         if (NodeUtil.isClassStaticBlock(n)) {
-          Context currentContext = contextStack.peek();
-          Context newContext = new StaticBlockContext(n);
-          if (newContext != currentContext) {
-            this.contextStack.push(newContext);
-          }
+          Context newContext = createStaticBlockContext(n);
+          this.contextStack.push(newContext);
         }
         break;
 
@@ -241,6 +241,36 @@ void visitContextNode(NodeTraversal t) {
     }
   }
 
+  private static class SuperPropertyAccessAllowedContext extends Context {
+    SuperPropertyAccessAllowedContext(Node contextNode) {
+      super(contextNode);
+    }
+
+    @Override
+    void visitSuperPropertyAccess(NodeTraversal t, Node superNode) {
+      // Super property should be allowed on a public field and inside static blocks.
+    }
+
+    @Override
+    void visitSuperConstructorCall(NodeTraversal t, Node superNode) {
+      // Super constructor calls are only allowed in constructor() methods.
+      t.report(superNode, INVALID_SUPER_CALL);
+    }
+
+    @Override
+    Context getContextForArrowFunctionNode(Node arrowFn) {
+      return this;
+    }
+  }
+
+  private Context createMemberFieldDefContext(Node fieldNode) {
+    return new SuperPropertyAccessAllowedContext(fieldNode);
+  }
+
+  private Context createStaticBlockContext(Node staticBlock) {
+    return new SuperPropertyAccessAllowedContext(staticBlock);
+  }
+
   /** Lexical context when not within a method, class, or object literal. */
   private static class SuperNotAllowedContext extends Context {
     SuperNotAllowedContext(Node contextNode) {
@@ -458,30 +488,4 @@ void visitSuperPropertyAccess(NodeTraversal t, Node superNode) {
       constructorContext.visitSuperPropertyAccess(t, superNode);
     }
   }
-
-  /** Lexical context within a static initialization block in a class. */
-  private static class StaticBlockContext extends Context {
-
-    StaticBlockContext(Node contextNode) {
-      super(contextNode);
-      checkArgument(NodeUtil.isClassStaticBlock(contextNode), contextNode);
-    }
-
-    @Override
-    Context getContextForArrowFunctionNode(Node arrowFn) {
-      // Arrow functions still use the same context as the class static block
-      return this;
-    }
-
-    @Override
-    void visitSuperConstructorCall(NodeTraversal t, Node superNode) {
-      // We're not inside a constructor.
-      t.report(superNode, INVALID_SUPER_CALL);
-    }
-
-    @Override
-    void visitSuperPropertyAccess(NodeTraversal t, Node superNode) {
-      // perfectly valid, nothing to do here
-    }
-  }
 }

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

@@ -62,6 +62,51 @@ public void testMissingSuper() {
         error(SUPER_ACCESS_BEFORE_SUPER_CONSTRUCTOR));
   }
 
+  @Test
+  public void testFieldSuperCall() {
+    testSame(
+        lines(
+            "class Foo {",
+            "  x() {",
+            "    return 5;",
+            "  }",
+            "}",
+            "class Bar extends Foo {",
+            "  y = () => super.x()",
+            "}"));
+
+    testError(
+        lines(
+            "class A {}", //
+            "class B extends A { ",
+            "  x = super();",
+            "}"),
+        INVALID_SUPER_CALL);
+  }
+
+  @Test
+  public void testComputedSuperFields() {
+    testError(
+        lines(
+            "class A {", //
+            "  x = 'fieldOne'",
+            "}",
+            "class B extends A { ",
+            "  [super.x] = 2;",
+            "}"),
+        INVALID_SUPER_ACCESS);
+
+    testError(
+        lines(
+            "class A {", //
+            "  x = 'fieldOne'",
+            "}",
+            "class B extends A { ",
+            "  static [super.x] = 2;",
+            "}"),
+        INVALID_SUPER_ACCESS);
+  }
+
   @Test
   public void testMissingSuper_nestedClass() {
     // Note that super is only called for anonymous class "E", not C.