fix(lint/noUnreachableSuper): handle complex CFG

[Conaclos]

Summary

Fix rome#4616.

I take the opportunity to fix an unnoticed bug: the rule assimilated super calls such as super.method() to a super call super().

I think that the new implementation is simpler and more robust.

i discovered some cases statically undecidable. For instance the following example:

class A {
    constructor(a) {
        if (a) { throw new Error(); }
    }
}

class B extends A {
    constructor() {
        try {
            super(true);
            f();
        } catch { super(false); }
    }
}

As a workaround, I decided to assume that the try block has both a super() call and no super() call when an exception is caught. Thus, the rule reports duplicate super() in the previous example.

We could also ignore catch blocks. Any thought?

EDIT: TypeScript uses the same workaround.

---

Note: I have just noticed that I had a wrong assumption about throw expressions. Biome CFG wrapped every throw expression in a return instruction, including throw in a try catch block. I expected a jump for this special case... Not sure if this should be fixed in the rule implementation or on the CFG?

I think this issue requires more thoughts and should be fixed in another PR.

Test Plan

New tests included.

[Conaclos]

noUnreachableSuper and noInvalidConstructorSuper have covering cases. They both report classes that should call super(). One difference is that noInvalidConstructorSUper also checks that a class which extends a non-constructor should not call super().

To avoid double reports, I suggest removing the common check from noUnreachableSuper. Another solution is merging the two rules into noUnreachableSuper.

[ematipico]

Note: I have just noticed that I had a wrong assumption about throw expressions. Biome CFG wrapped every throw expression in a return instruction, including throw in a try catch block. I expected a jump for this special case... Not sure if this should be fixed in the rule implementation or on the CFG?

It's possible it's a bug

[Conaclos]

@ematipico
Have you some thoughts about my remark

[ematipico]

noUnreachableSuper and noInvalidConstructorSuper have covering cases. They both report classes that should call super(). One difference is that noInvalidConstructorSUper also checks that a class which extends a non-constructor should not call super().

To avoid double reports, I suggest removing the common check from noUnreachableSuper. Another solution is merging the two rules into noUnreachableSuper.

I believe they should be two different rules, they have clearly two different purposes and they don't necessarily overlap. It's totally reasonable to have two rules that report on the same TextRange.