Handle TSIndexSignature

Author: overlookmotel

crates/oxc_semantic/src/checker/javascript.rs

@@ -921,6 +921,7 @@ pub fn check_super(sup: &Super, ctx: &SemanticBuilder<'_>) {
             // 2. Class accessor value.
             // 3. Computed key of a class method / property / accessor.
             // 4. Decorators on a class method / property / accessor.
+            // 5. `TSIndexSignature`.
             // Find out which.
             //
             // Note: In terms of scopes, we could also be in a class's `super_class`,
@@ -972,13 +973,35 @@ pub fn check_super(sup: &Super, ctx: &SemanticBuilder<'_>) {
                         // If we were in the value, we would have exited loop already,
                         // because `value` is a function - which is handled below.
                     }
+                    AstKind::TSIndexSignature(sig) => {
+                        // I (@overlookmotel) don't think `Super` should appear in a type annotation.
+                        // e.g. `super` is parsed as an `IdentifierReference`, not `Super` in:
+                        // `class C { [keys: typeof super.foo]: typeof super.foo }`
+                        // But I did find one weird case where `super` *is* currently parsed as `Super`:
+                        // `class C { [keys: string]: typeof import('x', { with: super.foo }).y; }`
+                        //
+                        // So probably this branch is unreachable in practice. But handle it just in case,
+                        // to avoid falling through to `unreachable!()` below.
+                        //
+                        // If it *is* possible, I'm also not sure what correct behavior should be.
+                        // As best guess, treating it like class properties:
+                        // Treat `parameters` like computed key, `type_annotation` like initializer value.
+                        if sig.type_annotation.address() == previous_node_address {
+                            // In signature's `type_annotation` - `super.foo` is legal here, `super()` is not
+                            if super_call_span.is_some() {
+                                break 'scopes;
+                            }
+                            return;
+                        }
+                        // In `parameters` - treat like computed key
+                    }
                     _ => {
                         previous_node_address = ancestor_kind.address();
                         continue;
                     }
                 }
 
-                // `super` is in a computed key or decorator.
+                // `super` is in a computed key, decorator, or `TSIndexSignature`'s `parameters`.
                 //
                 // Whether it's legal or not depends on external context
                 // (whether this class is nested in another class or object method).

tasks/coverage/misc/fail/oxc-13284.ts

@@ -0,0 +1,36 @@
+// Not sure this is correct, but adding this test to make sure it doesn't panic at least.
+// See comment in `check_super` in `oxc_semantic`.
+
+// `super()`
+class C extends Super {
+  [keys: string]: typeof import('x', { with: super() }).y;
+}
+
+class D extends Super {
+  [keys: typeof import('x', { with: super() }).y]: string;
+}
+
+class Outer extends Super {
+  constructor() {
+    class Inner {
+      [keys: string]: typeof import('x', { with: super() }).y;
+    }
+  }
+}
+
+class Outer2 {
+  constructor() {
+    class Inner extends Super {
+      [keys: typeof import('x', { with: super() }).y]: string;
+    }
+  }
+}
+
+// `super.foo`
+class E {
+  [keys: typeof super.foo]: string;
+}
+
+class F {
+  [keys: typeof import('x', { with: super.foo }).y]: string;
+}

tasks/coverage/misc/pass/oxc-13284.ts

@@ -0,0 +1,47 @@
+// Not sure this is correct, but adding this test to make sure it doesn't panic at least.
+// See comment in `check_super` in `oxc_semantic`.
+
+class C {
+  [keys: string]: typeof super.foo;
+}
+
+class D {
+  [keys: string]: typeof import('x', { with: super.foo }).y;
+}
+
+class Outer extends Super {
+  constructor() {
+    class Inner {
+      [keys: typeof super.foo]: string;
+    }
+    class Inner2 {
+      [keys: typeof import('x', { with: super.foo }).y]: string;
+    }
+    class Inner3 {
+      [keys: typeof import('x', { with: super() }).y]: string;
+    }
+  }
+
+  prop1 = class Inner {
+    [keys: typeof super.foo]: string;
+  };
+  prop2 = class Inner {
+    [keys: typeof import('x', { with: super.foo }).y]: string;
+  };
+
+  accessor access1 = class Inner {
+    [keys: typeof super.foo]: string;
+  };
+  accessor access2 = class Inner {
+    [keys: typeof import('x', { with: super.foo }).y]: string;
+  };
+
+  method() {
+    class Inner {
+      [keys: typeof super.foo]: string;
+    }
+    class Inner2 {
+      [keys: typeof import('x', { with: super.foo }).y]: string;
+    }
+  }
+}

tasks/coverage/snapshots/codegen_misc.snap

@@ -1,3 +1,3 @@
 codegen_misc Summary:
-AST Parsed     : 48/48 (100.00%)
-Positive Passed: 48/48 (100.00%)
+AST Parsed     : 49/49 (100.00%)
+Positive Passed: 49/49 (100.00%)

tasks/coverage/snapshots/formatter_misc.snap

@@ -1,6 +1,6 @@
 formatter_misc Summary:
-AST Parsed     : 48/48 (100.00%)
-Positive Passed: 45/48 (93.75%)
+AST Parsed     : 49/49 (100.00%)
+Positive Passed: 46/49 (93.88%)
 Expect to Parse: tasks/coverage/misc/pass/oxc-12612.ts
 
 Expect to Parse: tasks/coverage/misc/pass/oxc-2592.ts

tasks/coverage/snapshots/parser_misc.snap

@@ -1,7 +1,7 @@
 parser_misc Summary:
-AST Parsed     : 48/48 (100.00%)
-Positive Passed: 48/48 (100.00%)
-Negative Passed: 79/79 (100.00%)
+AST Parsed     : 49/49 (100.00%)
+Positive Passed: 49/49 (100.00%)
+Negative Passed: 80/80 (100.00%)
 
   × Cannot assign to 'arguments' in strict mode
    ╭─[misc/fail/arguments-eval.ts:1:10]
@@ -2733,6 +2733,54 @@ Negative Passed: 79/79 (100.00%)
  144 │   },
      ╰────
 
+  × Super calls are not permitted outside constructors or in nested functions inside constructors.
+   ╭─[misc/fail/oxc-13284.ts:6:46]
+ 5 │ class C extends Super {
+ 6 │   [keys: string]: typeof import('x', { with: super() }).y;
+   ·                                              ───────
+ 7 │ }
+   ╰────
+
+  × Super calls are not permitted outside constructors or in nested functions inside constructors.
+    ╭─[misc/fail/oxc-13284.ts:10:37]
+  9 │ class D extends Super {
+ 10 │   [keys: typeof import('x', { with: super() }).y]: string;
+    ·                                     ───────
+ 11 │ }
+    ╰────
+
+  × Super calls are not permitted outside constructors or in nested functions inside constructors.
+    ╭─[misc/fail/oxc-13284.ts:16:50]
+ 15 │     class Inner {
+ 16 │       [keys: string]: typeof import('x', { with: super() }).y;
+    ·                                                  ───────
+ 17 │     }
+    ╰────
+
+  × 'super' can only be referenced in a derived class.
+    ╭─[misc/fail/oxc-13284.ts:21:1]
+ 20 │     
+ 21 │ ╭─▶ class Outer2 {
+ 22 │ │     constructor() {
+ 23 │ │       class Inner extends Super {
+ 24 │ │         [keys: typeof import('x', { with: super() }).y]: string;
+    · │                                           ─────
+ 25 │ │       }
+ 26 │ │     }
+ 27 │ ├─▶ }
+    · ╰──── class does not have `extends`
+ 28 │     
+    ╰────
+  help: either remove this super, or extend the class
+
+  × 'super' can only be referenced in members of derived classes or object literal expressions.
+    ╭─[misc/fail/oxc-13284.ts:35:37]
+ 34 │ class F {
+ 35 │   [keys: typeof import('x', { with: super.foo }).y]: string;
+    ·                                     ─────
+ 36 │ }
+    ╰────
+
   × 'super' can only be referenced in members of derived classes or object literal expressions.
    ╭─[misc/fail/oxc-13323.js:3:5]
  2 │   foo: function() {

tasks/coverage/snapshots/semantic_misc.snap

@@ -1,6 +1,6 @@
 semantic_misc Summary:
-AST Parsed     : 48/48 (100.00%)
-Positive Passed: 31/48 (64.58%)
+AST Parsed     : 49/49 (100.00%)
+Positive Passed: 31/49 (63.27%)
 semantic Error: tasks/coverage/misc/pass/oxc-11593.ts
 Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1)]
@@ -195,6 +195,14 @@ Unresolved reference IDs mismatch for "Function":
 after transform: [ReferenceId(75), ReferenceId(79), ReferenceId(109), ReferenceId(123), ReferenceId(137), ReferenceId(151), ReferenceId(165), ReferenceId(189), ReferenceId(203), ReferenceId(227), ReferenceId(241), ReferenceId(265), ReferenceId(279), ReferenceId(303), ReferenceId(432), ReferenceId(460), ReferenceId(464), ReferenceId(482), ReferenceId(486), ReferenceId(490), ReferenceId(496), ReferenceId(500), ReferenceId(504), ReferenceId(510), ReferenceId(514), ReferenceId(518)]
 rebuilt        : [ReferenceId(80), ReferenceId(86), ReferenceId(130), ReferenceId(162), ReferenceId(194), ReferenceId(315), ReferenceId(394), ReferenceId(422), ReferenceId(428), ReferenceId(435), ReferenceId(441), ReferenceId(448)]
 
+semantic Error: tasks/coverage/misc/pass/oxc-13284.ts
+Symbol reference IDs mismatch for "_super":
+after transform: SymbolId(13): [ReferenceId(8)]
+rebuilt        : SymbolId(4): []
+Unresolved references mismatch:
+after transform: ["Super", "super"]
+rebuilt        : ["Super"]
+
 semantic Error: tasks/coverage/misc/pass/oxc-2087.ts
 Scope children mismatch:
 after transform: ScopeId(0): [ScopeId(1)]

tasks/coverage/snapshots/transformer_misc.snap

@@ -1,5 +1,5 @@
 transformer_misc Summary:
-AST Parsed     : 48/48 (100.00%)
-Positive Passed: 47/48 (97.92%)
+AST Parsed     : 49/49 (100.00%)
+Positive Passed: 48/49 (97.96%)
 Mismatch: tasks/coverage/misc/pass/oxc-13284.js