Syntax Parser and AST in JavaScript

Syntax Parser and AST in JavaScript

Before V8 can execute JavaScript, it must parse the source code into an Abstract Syntax Tree (AST). Understanding this step helps with debugging, tooling, and performance.

What a Syntax Parser Does

1. Lexing (tokenizing): split source code into tokens (keywords, identifiers, operators, literals).
2. Parsing: build an AST from the tokens, following the language grammar.

var x = 5 + 3;
``
Tokens: `var`, `x`, `=`, `5`, `+`, `3`, `;`.

AST: a VariableDeclaration node containing a VariableDeclarator with an Identifier (`x`) and a BinaryExpression (`5 + 3`).

### What an AST Is

A tree representation of the code's structure. Each node is a construct: VariableDeclaration, FunctionDeclaration, IfStatement, BinaryExpression, Identifier, Literal, etc.

### Why the AST Matters

- **Compilation**: V8 compiles the AST into bytecode (Ignition) and then to machine code (TurboFan).
- **Linters** (ESLint): walk the AST to find patterns.
- **Formatters** (Prettier): parse into AST, then print back to formatted source.
- **Transpilers** (Babel): parse ES6+ into AST, transform the tree, print ES5.
- **Bundlers** (Webpack, Rollup): analyze the AST for imports, exports, tree shaking.
- **Type checkers** (TypeScript): parse into AST, check types.

### Syntax Errors

If the parser finds malformed code (unbalanced braces, missing parentheses), it throws a **SyntaxError** and the AST is not created. The entire script (or module) fails to load.

```js
const x = ; // SyntaxError: Unexpected token ';'
``
### Parsing Performance

Parsing is not free. Large scripts take measurable time before any code runs. V8:

- **Lazily parses** functions: it does a pre-parse (quick scan) and only fully parses a function when it is called.
- **Caches parsed ASTs** to avoid re-parsing on page reload.
- This is why code splitting improves startup time (less code to parse).

### Lazy Parsing

```js
function foo() { ... } // pre-parsed (quick scan)
foo(); // now fully parsed and compiled
``
V8 pre-parses functions to skip the full parse until they are actually called. This speeds up startup for code that is not immediately executed.

### The Takeaway

Parsing converts source code into tokens, then into an AST. The AST is the input to compilation, linting, transpilation, and bundling. A syntax error stops the entire process before code can run. V8 lazily parses functions and caches ASTs to improve startup performance.