Great question! Let's walk through how to tackle this with both Acorn and Esprima—since their approaches to extension are night and day.

Extending Acorn (Recommended, No Fork Needed) #

Acorn was built with extensibility in mind, so you can add your custom keyword and map it to parse as an IfStatement without touching core code. Here's how to do it:

1. Add MyStatement as a Recognized Keyword #

First, extend Acorn's base Parser class and update its keyword table to treat MyStatement like the if keyword. This tells the parser to flag it as a conditional statement trigger.

const { Parser, keywordTypes } = require("acorn");

class CustomParser extends Parser {
  constructor(options) {
    super(options);
    // Map MyStatement to the same keyword type as 'if'
    this.keywords["MyStatement"] = keywordTypes.CONDITIONAL;
  }
}

2. Parse MyStatement as an IfStatement #

Next, override the parseStatement method to handle your custom keyword. You have two options depending on your syntax needs:

Option A: Match if's full syntax (with condition)

If your MyStatement supports a condition like MyStatement (x > 5) { ... }, you can directly reuse Acorn's built-in parseIf method:

class CustomParser extends Parser {
  // ... constructor code from above ...

  parseStatement(context, topLevel, exports) {
    const token = this.type;
    // Check if we're looking at our custom keyword
    if (token === keywordTypes.CONDITIONAL && this.value === "MyStatement") {
      this.next(); // Consume the 'MyStatement' keyword
      // Reuse Acorn's existing if-statement parsing logic
      return this.parseIf();
    }
    // Fall back to default parsing for all other statements
    return super.parseStatement(context, topLevel, exports);
  }
}

Option B: Unconditional MyStatement (no condition)

For your example MyStatement {a=1;} (no condition), tweak the parsing to treat it as an if (true) under the hood:

class CustomParser extends Parser {
  // ... constructor code from above ...

  parseStatement(context, topLevel, exports) {
    const token = this.type;
    if (token === keywordTypes.CONDITIONAL && this.value === "MyStatement") {
      this.next(); // Consume 'MyStatement'
      const node = this.startNode();
      // Set condition to a literal `true`
      node.test = this.nodeLiteral(true);
      // Parse the following block statement
      node.consequent = this.parseBlock();
      node.alternate = null;
      return this.finishNode(node, "IfStatement");
    }
    return super.parseStatement(context, topLevel, exports);
  }
}

To use your custom parser:

const code = "MyStatement {a=1;}";
const ast = CustomParser.parse(code, { ecmaVersion: 2020 });
console.log(ast.body[0]); // Outputs an IfStatement node with test: Literal(true)

Working with Esprima (Limited, No-Fork Hack) #

Esprima is a strict, non-extensible parser for standard JavaScript—there's no official way to add custom keywords or statements without forking the repository. But if you want to avoid forking, you can use a preprocessing workaround:

Preprocess Code to Mimic Valid JS #

Since you want MyStatement {a=1;} to parse as an IfStatement, replace all instances of MyStatement with valid JavaScript that Esprima can understand. For an unconditional block, replace it with if (true):

const esprima = require("esprima");
const originalCode = "MyStatement {a=1;}";
// Replace MyStatement with if (true) to make it valid JS
const processedCode = originalCode.replace(/\bMyStatement\b/g, "if (true)");
const ast = esprima.parse(processedCode);
console.log(ast.body[0]); // Outputs an IfStatement node with test: Literal(true)

Note: This is a hack—you'll need to handle edge cases (like MyStatement appearing in strings) manually with more sophisticated regex or a tokenizer.

Final Notes #

Acorn is the better choice for a robust, maintainable solution. Its extensibility lets you refine your custom syntax later (e.g., adding condition support) without hacks. Esprima's workaround is only viable if you're working with a simple, predictable syntax.

内容的提问来源于stack exchange，提问作者bruceceng