On forming CFGs with dead code.

[TzviPM]

consider the following code:

class A extends B {
    constructor() {
        return;
        this;
    }
}

Currently, the AST generated for this code is (some parts removed for emphasis):

Class {
  id: BindingIdentifier {
      name: "A",
  },
  super_class: Identifier(
      IdentifierReference {
          name: "B",
      },
  ),
  body: ClassBody {
      body: Vec([
        MethodDefinition {
            key: Identifier(
                IdentifierName {
                    name: "constructor",
                },
            ),
            value: Function {
              params: FormalParameters {
                  items: Vec([]),
              },
              body: FunctionBody {
                statements: Vec([
                    ReturnStatement,
                    ExpressionStatement(
                            expression: ThisExpression,
                    ),
                ]),
              },
            },
            kind: Constructor,
    ]),
  }
}

The CFG for this node essentially does the following:

+--------------------+
|                    |
|  MethodDefinition  |
|        return      |
|        this        |
|                    |
+--------------------+

However, strictly speaking, the return statement does have a specific control-flow meaning as follows:

    +--------------------+
    |                    |
--> |  MethodDefinition  |
    |        return      | -->
    |                    |
    +--------------------+

    +--------------------+
    |        this        |
    +--------------------+

In this alternate CFG, we see that the second node, containing the this is unreachable, whereas the return statement indicates a transition in control flow.

Currently, oxc creates the first type of CFG. I'm curious if there are any objections to my changing the CFG node structure to better handle these types of dead code?

[Boshen]

Let's experiment and get the tests passing first, as long as there are no performance regressions.