semantic: discrepancies in super diagnostics compared to TypeScript

[ulrichstark]

In following code, OXC reports super 2, 3, and 4 and TypeScript reports super 1, 2, 3.

class C {
   public fn() {
      super.superFn(); // 1, only TypeScript

      function sub() {
        super.superFn(); // 2, both
      }

      const obj = {
          fn1: function () {
            super.superFn(); // 3, both
          },
          fn2() {
            super.superFn(); // 4, only OXC
          },
      };
   }
}

OXC Playground

TypeScript Playground

[Boshen]

These results are actually correct.

Oxc conforms to ECMA262, the ones reported by tsc but not present in Oxc are TypeScript specific errors.

[overlookmotel]

I believe one of the problems raised above is a genuine bug. Here's a reduced reproduction which is JS (not TS):

Parser says super is not legal in this position, but I believe it's wrong:

class C {
  foo() {
    return {
      bar() {
        super.bar();
      },
    };
  }
}

Playground

No errors if the object literal isn't inside a class method, so I assume there's some state about what context we're in which is getting confused. e.g. no errors for this:

let _obj = {
  bar() {
    super.bar();
  },
};

Playground

[overlookmotel]

Sorry to open this again, but I still don't think we've got it quite right.

1. super in object method

This is legal in both JS and TS:

class C {
  foo() {
    return {
      bar() {
        super.bar();
      },
    };
  }
}

TS Playground

2. super in class method

This is legal in JS, but TS have made it illegal:

class C {
  foo() {
    super.foo();
  }
}

TS Playground

But it's only an error if the class doesn't extend a super-class. This does not produce an error in TS:

class S {}

class C extends S {
  foo() {
    super.toString();
  }
}

TS Playground

In TS, I'm not sure if it should be considered an "early" syntax error, or a type-check error. TS produces no error with noCheck: true.

I think we can probably make it legal in both JS and TS.

Where we're at

#13318 made (1) illegal in TS, but (2) legal. It should be the other way around.

Edge cases

We probably also need to handle the cases which are fixed for object expressions in #13325 (but not fixed for classes).

[overlookmotel]

I feel ridiculous re-opening this again, but... #13323 did not fix this.

Semantic is currently flagging this use of super as illegal:

class C {
  foo() {
    return {
      bar() {
        super.bar();
      },
    };
  }
}

Oxc playground

It is not illegal in either JS (AST explorer) or TS (TS Playground).

#13323 fixed the behavior when not inside a class, but super in an object literal method inside a class is still broken.