aboutsummaryrefslogtreecommitdiff
path: root/src/z/parser/js
diff options
context:
space:
mode:
Diffstat (limited to 'src/z/parser/js')
-rw-r--r--src/z/parser/js/ast.zig4125
-rw-r--r--src/z/parser/js/ast.zig.bak3334
-rw-r--r--src/z/parser/js/lexical_grammar.zig1137
-rw-r--r--src/z/parser/js/root.zig85
-rw-r--r--src/z/parser/js/test_fixture.js86
5 files changed, 8767 insertions, 0 deletions
diff --git a/src/z/parser/js/ast.zig b/src/z/parser/js/ast.zig
new file mode 100644
index 0000000..0e49a4b
--- /dev/null
+++ b/src/z/parser/js/ast.zig
@@ -0,0 +1,4125 @@
+const std = @import("std");
+
+pub const Loc = struct {
+ start: usize,
+ end: usize,
+};
+
+const lex = @import("lexical_grammar.zig");
+const Token = lex.Token;
+const TokenType = lex.TokenType;
+
+pub const FormatOptions = struct {
+ indent_size: usize = 4,
+};
+
+pub const Formatter = struct {
+ buf: []u8,
+ pos: usize,
+ indent_level: usize,
+ options: FormatOptions,
+
+ pub fn write(self: *@This(), s: []const u8) void {
+ @memcpy(self.buf[self.pos..][0..s.len], s);
+ self.pos += s.len;
+ }
+
+ pub fn writeChar(self: *@This(), c: u8) void {
+ self.buf[self.pos] = c;
+ self.pos += 1;
+ }
+
+ pub fn writeIndent(self: *@This()) void {
+ const spaces = self.indent_level * self.options.indent_size;
+ var i: usize = 0;
+ while (i < spaces) : (i += 1) {
+ self.writeChar(' ');
+ }
+ }
+
+ pub fn newline(self: *@This()) void {
+ self.writeChar('\n');
+ }
+};
+
+pub const ParseError = error{
+ UnexpectedToken,
+ ExpectedToken,
+ ExpectedExpression,
+ ExpectedStatement,
+ ExpectedIdentifier,
+ UnclosedString,
+ InvalidNumber,
+ InvalidEscape,
+ UnterminatedComment,
+ ExpectedParameterName,
+ ExpectedPropertyName,
+ UnterminatedTemplate,
+ InvalidAssignmentTarget,
+ TooManyTokens,
+};
+
+const BP = struct {
+ const comma = 1;
+ const assign = 2;
+ const yield = 3;
+ const conditional = 4;
+ const coalesce = 5;
+ const log_or = 6;
+ const log_and = 7;
+ const bit_or = 8;
+ const bit_xor = 9;
+ const bit_and = 10;
+ const equality = 11;
+ const relational = 12;
+ const shift = 13;
+ const additive = 14;
+ const multiplicative = 15;
+ const exponentiation = 16;
+ const unary = 17;
+ const update = 18;
+ const call = 19;
+ const member = 20;
+};
+
+pub const NodeArena = struct {
+ exprs: [8192]Expr = undefined,
+ expr_count: usize = 0,
+ stmts: [8192]Stmt = undefined,
+ stmt_count: usize = 0,
+ decls: [1024]Decl = undefined,
+ decl_count: usize = 0,
+ pats: [1024]Pat = undefined,
+ pat_count: usize = 0,
+ lits: [1024]Lit = undefined,
+ lit_count: usize = 0,
+ string_buf: [65536]u8 = undefined,
+ string_pos: usize = 0,
+
+ fn exprPtr(self: *NodeArena, data: ExprType, loc: Loc) *const Expr {
+ const idx = self.expr_count;
+ self.exprs[idx] = .{ .loc = loc, .data = data };
+ self.expr_count += 1;
+ return &self.exprs[idx];
+ }
+
+ fn stmtPtr(self: *NodeArena, data: StmtType, loc: Loc) *const Stmt {
+ const idx = self.stmt_count;
+ self.stmts[idx] = .{ .loc = loc, .data = data };
+ self.stmt_count += 1;
+ return &self.stmts[idx];
+ }
+
+ fn declPtr(self: *NodeArena, data: DeclType, loc: Loc) *const Decl {
+ const idx = self.decl_count;
+ self.decls[idx] = .{ .loc = loc, .data = data };
+ self.decl_count += 1;
+ return &self.decls[idx];
+ }
+
+ fn patPtr(self: *NodeArena, data: PatType, loc: Loc) *const Pat {
+ const idx = self.pat_count;
+ self.pats[idx] = .{ .loc = loc, .data = data };
+ self.pat_count += 1;
+ return &self.pats[idx];
+ }
+
+ fn litPtr(self: *NodeArena, data: LitType, loc: Loc) *const Lit {
+ const idx = self.lit_count;
+ self.lits[idx] = .{ .loc = loc, .data = data };
+ self.lit_count += 1;
+ return &self.lits[idx];
+ }
+};
+
+pub const Parser = struct {
+ tokens: []const Token,
+ pos: usize,
+ source: []const u8,
+ arena: *NodeArena,
+
+ pub fn init(tokens: []const Token, source: []const u8, arena: *NodeArena) @This() {
+ return .{ .tokens = tokens, .pos = 0, .source = source, .arena = arena };
+ }
+
+ fn tok(self: *@This()) Token {
+ return self.tokens[self.pos];
+ }
+
+ fn peek(self: *@This()) TokenType {
+ return self.tokens[self.pos].kind;
+ }
+
+ fn peekAt(self: *@This(), offset: usize) TokenType {
+ const idx = self.pos + offset;
+ if (idx >= self.tokens.len) return .eof;
+ return self.tokens[idx].kind;
+ }
+
+ fn advance(self: *@This()) void {
+ self.pos += 1;
+ }
+
+ fn advanceTok(self: *@This()) Token {
+ const t = self.tokens[self.pos];
+ self.pos += 1;
+ return t;
+ }
+
+ fn expect(self: *@This(), kind: TokenType) ParseError!void {
+ if (self.peek() != kind) return ParseError.ExpectedToken;
+ self.advance();
+ }
+
+ fn expectTok(self: *@This(), kind: TokenType) ParseError!Token {
+ if (self.peek() != kind) return ParseError.ExpectedToken;
+ return self.advanceTok();
+ }
+
+ fn match(self: *@This(), kind: TokenType) bool {
+ if (self.peek() == kind) {
+ _ = self.advanceTok();
+ return true;
+ }
+ return false;
+ }
+
+ fn matchKeyword(self: *@This(), kw: TokenType) bool {
+ if (self.peek() == kw) {
+ _ = self.advanceTok();
+ return true;
+ }
+ return false;
+ }
+
+ fn isLineTerminatorBeforeNext(self: *@This()) bool {
+ if (self.pos == 0) return false;
+ const prev_token = self.tokens[self.pos - 1];
+ const next_token = self.tokens[self.pos];
+ var i = prev_token.loc.end;
+ while (i < next_token.loc.start) : (i += 1) {
+ if (i >= self.source.len) break;
+ const c = self.source[i];
+ switch (c) {
+ '\n', '\r' => return true,
+ else => {},
+ }
+ }
+ return false;
+ }
+
+ fn as_identifier(self: *@This(), t: Token) []const u8 {
+ return self.source[t.loc.start..t.loc.end];
+ }
+
+ fn tokenSlice(self: *@This(), t: Token) []const u8 {
+ return self.source[t.loc.start..t.loc.end];
+ }
+
+ pub fn parseProgram(self: *@This()) ParseError!Program {
+ var stmts: [2048]Stmt = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .eof) {
+ const item = try self.parseStatementListItem();
+ stmts[count] = item;
+ count += 1;
+ if (count >= stmts.len) return ParseError.TooManyTokens;
+ }
+
+ const body = stmts[0..count];
+ const loc: Loc = if (body.len > 0) .{ .start = body[0].loc.start, .end = body[body.len - 1].loc.end } else .{ .start = 0, .end = 0 };
+
+ return .{ .body = body, .loc = loc };
+ }
+
+ fn parseStatementListItem(self: *@This()) ParseError!Stmt {
+ switch (self.peek()) {
+ .function => return (try self.parseFunctionDecl(.normal, .stmt)).?,
+ .async => {
+ if (self.peekAt(1) == .function) {
+ return (try self.parseFunctionDecl(.async, .stmt)).?;
+ }
+ if (self.peekAt(1) == .@"*" and self.peekAt(2) == .function) {
+ return (try self.parseFunctionDecl(.async_generator, .stmt)).?;
+ }
+ return self.parseStatement();
+ },
+ .class => return (try self.parseClassDecl(.stmt)).?,
+ .@"const", .let => return self.parseLexicalDecl(),
+ .@"var" => return self.parseVarStmt(),
+ .using => return self.parseUsingStmt(),
+ .import => return try self.parseImport(),
+ .@"export" => return try self.parseExport(),
+ else => return self.parseStatement(),
+ }
+ }
+
+ fn parseStatement(self: *@This()) ParseError!Stmt {
+ switch (self.peek()) {
+ .lbrace => return self.parseBlock(),
+ .semicolon => {
+ const t = self.advanceTok();
+ return Stmt{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .data = .{ .empty = {} } };
+ },
+ .@"if" => return self.parseIf(),
+ .@"while" => return self.parseWhile(),
+ .do => return self.parseDoWhile(),
+ .@"for" => return self.parseFor(),
+ .@"continue" => return self.parseContinue(),
+ .@"break" => return self.parseBreak(),
+ .@"return" => return self.parseReturn(),
+ .@"switch" => return self.parseSwitch(),
+ .throw => return self.parseThrow(),
+ .@"try" => return self.parseTry(),
+ .debugger => {
+ const t = self.advanceTok();
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .data = .{ .debugger = {} } };
+ },
+ .with => return self.parseWith(),
+ .function => return (try self.parseFunctionDecl(.normal, .stmt)).?,
+ .async => {
+ if (self.peekAt(1) == .function) {
+ return (try self.parseFunctionDecl(.async, .stmt)).?;
+ }
+ if (self.peekAt(1) == .@"*") return self.parseExpressionStatement();
+ if (self.peekAt(1).isIdentifier()) {
+ return self.parseExpressionStatement();
+ }
+ return self.parseExpressionStatement();
+ },
+ .class => return (try self.parseClassDecl(.stmt)).?,
+ .@"const", .let => return self.parseLexicalDecl(),
+ .@"var" => return self.parseVarStmt(),
+ .import => return try self.parseImport(),
+ .@"export" => return try self.parseExport(),
+ else => return self.parseExpressionStatement(),
+ }
+ }
+
+ fn parseBlock(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var stmts: [1024]Stmt = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ stmts[count] = s;
+ count += 1;
+ if (count >= stmts.len) return ParseError.TooManyTokens;
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+ const end = end_tok.loc.end;
+
+ const block = Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .block = .{ .loc = .{ .start = start, .end = end }, .body = stmts[0..count] } },
+ };
+ return block;
+ }
+
+ fn parseIf(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const condition = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const consequent = try self.statementPointer();
+ var alternate: ?*const Stmt = null;
+ if (self.matchKeyword(.@"else")) {
+ alternate = try self.statementPointer();
+ }
+ const end = if (alternate) |a| a.loc.end else consequent.loc.end;
+ return Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .@"if" = .{ .loc = .{ .start = start, .end = end }, .condition = condition, .consequent = consequent, .alternate = alternate } },
+ };
+ }
+
+ fn parseWhile(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const condition = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .@"while" = .{ .loc = .{ .start = start, .end = body.loc.end }, .condition = condition, .body = body } },
+ };
+ }
+
+ fn parseDoWhile(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ const body = try self.statementPointer();
+ try self.expect(.@"while");
+ try self.expect(.lparen);
+ const condition = try self.parseExpr(0);
+ try self.expect(.rparen);
+ self.semicolon();
+ return Stmt{
+ .loc = .{ .start = start, .end = condition.loc.end },
+ .data = .{ .do_while = .{ .loc = .{ .start = start, .end = condition.loc.end }, .body = body, .condition = condition } },
+ };
+ }
+
+ fn parseFor(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+
+ var for_init: ?ForInit = null;
+ var condition: ?*const Expr = null;
+ var update: ?*const Expr = null;
+
+ if (self.peek() != .semicolon) {
+ if (self.peek() == .@"var" or self.peek() == .let or self.peek() == .@"const") {
+ const decl = try self.parseForDeclaration();
+ for_init = .{ .decl = decl };
+ } else {
+ const expr = try self.parseExpr(0);
+ for_init = .{ .expr = expr };
+ }
+ }
+
+ if (self.matchKeyword(.in)) {
+ const right = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .for_in = .{ .loc = .{ .start = start, .end = body.loc.end }, .left = for_init.?, .right = right, .body = body } },
+ };
+ }
+
+ if (self.matchKeyword(.of)) {
+ const right = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .for_of = .{ .loc = .{ .start = start, .end = body.loc.end }, .await_token = false, .left = for_init.?, .right = right, .body = body } },
+ };
+ }
+
+ try self.expect(.semicolon);
+ if (self.peek() != .semicolon and self.peek() != .rparen) {
+ condition = try self.parseExpr(0);
+ }
+ try self.expect(.semicolon);
+ if (self.peek() != .rparen) {
+ update = try self.parseExpr(0);
+ }
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .@"for" = .{ .loc = .{ .start = start, .end = body.loc.end }, .init = for_init, .condition = condition, .update = update, .body = body } },
+ };
+ }
+
+ fn parseForDeclaration(self: *@This()) ParseError!*const Decl {
+ const kind_tok = self.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try self.parseBindingPattern();
+ var decl_init: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ const kind: VarKind = switch (kind_tok.kind) {
+ .@"var" => .@"var",
+ .let => .let,
+ .@"const" => .@"const",
+ else => return ParseError.UnexpectedToken,
+ };
+
+ return self.arena.declPtr(.{ .@"var" = .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = kind, .decls = decls[0..count] } }, .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end });
+ }
+
+ fn parseContinue(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var label: ?[]const u8 = null;
+ if (self.peek() == .identifier and !self.isLineTerminatorBeforeNext()) {
+ const t = self.advanceTok();
+ label = self.tokenSlice(t);
+ }
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = start + 8 }, .data = .{ .@"continue" = .{ .loc = .{ .start = start, .end = start + 8 }, .label = label } } };
+ }
+
+ fn parseBreak(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var label: ?[]const u8 = null;
+ if (self.peek() == .identifier and !self.isLineTerminatorBeforeNext()) {
+ const t = self.advanceTok();
+ label = self.tokenSlice(t);
+ }
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = start + 5 }, .data = .{ .@"break" = .{ .loc = .{ .start = start, .end = start + 5 }, .label = label } } };
+ }
+
+ fn parseReturn(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var arg: ?*const Expr = null;
+ if (self.peek() != .semicolon and self.peek() != .rbrace and self.peek() != .eof and !self.isLineTerminatorBeforeNext()) {
+ arg = try self.parseExpr(0);
+ }
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = arg.?.loc.end }, .data = .{ .@"return" = .{ .loc = .{ .start = start, .end = if (arg) |a| a.loc.end else start + 6 }, .arg = arg } } };
+ }
+
+ fn parseSwitch(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const discriminant = try self.parseExpr(0);
+ try self.expect(.rparen);
+ try self.expect(.lbrace);
+
+ var cases: [256]SwitchCase = undefined;
+ var case_count: usize = 0;
+
+ while (self.peek() == .case or self.peek() == .default) {
+ const case_start = self.tok().loc.start;
+ if (self.matchKeyword(.case)) {
+ const case_test = try self.parseExpr(0);
+ try self.expect(.@":");
+ var consequent: [128]Stmt = undefined;
+ var cons_count: usize = 0;
+ while (self.peek() != .case and self.peek() != .default and self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ consequent[cons_count] = s;
+ cons_count += 1;
+ }
+ cases[case_count] = .{ .loc = .{ .start = case_start, .end = self.tok().loc.start }, .condition = case_test, .consequent = consequent[0..cons_count] };
+ case_count += 1;
+ } else if (self.matchKeyword(.default)) {
+ try self.expect(.@":");
+ var consequent: [128]Stmt = undefined;
+ var cons_count: usize = 0;
+ while (self.peek() != .case and self.peek() != .default and self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ consequent[cons_count] = s;
+ cons_count += 1;
+ }
+ cases[case_count] = .{ .loc = .{ .start = case_start, .end = self.tok().loc.start }, .condition = null, .consequent = consequent[0..cons_count] };
+ case_count += 1;
+ }
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+ return Stmt{
+ .loc = .{ .start = start, .end = end_tok.loc.end },
+ .data = .{ .@"switch" = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .discriminant = discriminant, .cases = cases[0..case_count] } },
+ };
+ }
+
+ fn parseThrow(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ if (self.isLineTerminatorBeforeNext()) return ParseError.ExpectedExpression;
+ const arg = try self.parseExpr(0);
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = arg.loc.end }, .data = .{ .throw = .{ .loc = .{ .start = start, .end = arg.loc.end }, .arg = arg } } };
+ }
+
+ fn parseTry(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ const block = try self.parseBlockStmt();
+ var handler: ?CatchClause = null;
+ var finalizer: ?BlockStmt = null;
+
+ if (self.matchKeyword(.@"catch")) {
+ var param: ?Pat = null;
+ if (self.match(.lparen)) {
+ const pat = try self.parseBindingPattern();
+ param = pat;
+ try self.expect(.rparen);
+ }
+ const catch_body = try self.parseBlockStmt();
+ handler = .{ .loc = .{ .start = block.loc.start, .end = catch_body.loc.end }, .param = param, .body = catch_body };
+ }
+
+ if (self.matchKeyword(.finally)) {
+ const finally_body = try self.parseBlockStmt();
+ finalizer = finally_body;
+ }
+
+ const end = if (finalizer) |f| f.loc.end else if (handler) |h| h.loc.end else block.loc.end;
+ return Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .@"try" = .{ .loc = .{ .start = start, .end = end }, .block = block, .handler = handler, .finalizer = finalizer } },
+ };
+ }
+
+ fn parseWith(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const obj = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .with = .{ .loc = .{ .start = start, .end = body.loc.end }, .obj = obj, .body = body } },
+ };
+ }
+
+ fn parseBlockStmt(self: *@This()) ParseError!BlockStmt {
+ const start = try self.expectTok(.lbrace);
+ var stmts: [1024]Stmt = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ stmts[count] = s;
+ count += 1;
+ if (count >= stmts.len) return ParseError.TooManyTokens;
+ }
+
+ const end = try self.expectTok(.rbrace);
+ return .{ .loc = .{ .start = start.loc.start, .end = end.loc.end }, .body = stmts[0..count] };
+ }
+
+ fn parseVarStmt(self: *@This()) ParseError!Stmt {
+ const kind_tok = self.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try self.parseBindingPattern();
+ var decl_init: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ self.semicolon();
+ const kind: VarKind = .@"var";
+ return Stmt{
+ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end },
+ .data = .{ .variable = .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = kind, .decls = decls[0..count] } },
+ };
+ }
+
+ fn parseLexicalDecl(self: *@This()) ParseError!Stmt {
+ const kind_tok = self.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try self.parseBindingPattern();
+ var decl_init: ?*const Expr = null;
+ if (kind_tok.kind == .@"const") {
+ if (!self.match(.@"=")) return ParseError.ExpectedToken;
+ decl_init = try self.parseExpr(0);
+ } else if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ self.semicolon();
+ const kind: VarKind = switch (kind_tok.kind) {
+ .let => .let,
+ .@"const" => .@"const",
+ else => return ParseError.UnexpectedToken,
+ };
+ return Stmt{
+ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end },
+ .data = .{ .lexical = .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = kind, .decls = decls[0..count] } },
+ };
+ }
+
+ fn parseUsingStmt(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const id_tok = try self.expectTok(.identifier);
+ const id = self.tokenSlice(id_tok);
+ var decl_init: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = .{ .start = id_tok.loc.start, .end = if (decl_init) |e| e.loc.end else id_tok.loc.end }, .id = Pat{ .loc = .{ .start = id_tok.loc.start, .end = id_tok.loc.end }, .data = .{ .ident = id } }, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ self.semicolon();
+ return Stmt{
+ .loc = .{ .start = start, .end = decls[count - 1].loc.end },
+ .data = .{ .using = .{ .loc = .{ .start = start, .end = decls[count - 1].loc.end }, .decls = decls[0..count] } },
+ };
+ }
+
+ fn parseExpressionStatement(self: *@This()) ParseError!Stmt {
+ const expr = try self.parseExpr(0);
+ self.semicolon();
+ return Stmt{ .loc = expr.loc, .data = .{ .expr = .{ .loc = expr.loc, .expr = expr } } };
+ }
+
+ fn parseFunctionDecl(self: *@This(), fn_type_arg: FnType, mode: enum { stmt, expr }) ParseError!?Stmt {
+ const start = self.tok().loc.start;
+ var fn_type = fn_type_arg;
+
+ if (fn_type == .async) {
+ _ = self.advanceTok(); // async
+ } else if (fn_type == .async_generator) {
+ _ = self.advanceTok(); // async
+ _ = self.advanceTok(); // *
+ }
+
+ _ = self.advanceTok(); // function
+
+ if (fn_type == .normal and self.peek() == .@"*") {
+ self.advance();
+ fn_type = .generator;
+ }
+
+ var id: ?[]const u8 = null;
+ if (self.peek().isIdentifier()) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+
+ const end = body.loc.end;
+
+ if (mode == .stmt) {
+ return Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .function = .{ .loc = .{ .start = start, .end = end }, .fn_type = fn_type, .id = id, .params = params, .body = body } },
+ };
+ }
+ return null;
+ }
+
+ fn parseFnExpr(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+
+ var fn_type: FnType = .normal;
+ if (self.peek() == .@"*") {
+ fn_type = .generator;
+ self.advance();
+ }
+
+ var id: ?[]const u8 = null;
+ if (self.peek() == .identifier or self.peek().isKeywordButNotLet()) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+
+ return self.arena.exprPtr(
+ .{ .func = .{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = fn_type, .id = id, .params = params, .body = body } },
+ .{ .start = start, .end = body.loc.end },
+ );
+ }
+
+ fn parseParams(self: *@This()) ParseError![]const Pat {
+ try self.expect(.lparen);
+ var params: [128]Pat = undefined;
+ var count: usize = 0;
+
+ if (self.peek() != .rparen) {
+ while (true) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const pat = try self.parseBindingPattern();
+ params[count] = Pat{ .loc = pat.loc, .data = .{ .rest = .{ .loc = pat.loc, .arg = self.arena.patPtr(pat.data, pat.loc) } } };
+ count += 1;
+ break;
+ }
+ const pat = try self.parseBindingPattern();
+ if (self.match(.@"=")) {
+ const expr = try self.parseExpr(0);
+ params[count] = Pat{ .loc = .{ .start = pat.loc.start, .end = expr.loc.end }, .data = .{ .assign = .{ .loc = .{ .start = pat.loc.start, .end = expr.loc.end }, .left = self.arena.patPtr(pat.data, pat.loc), .right = expr } } };
+ } else {
+ params[count] = pat;
+ }
+ count += 1;
+ if (!self.match(.comma)) break;
+ if (self.peek() == .@"...") {
+ self.advance();
+ const rest_pat = try self.parseBindingPattern();
+ params[count] = Pat{ .loc = rest_pat.loc, .data = .{ .rest = .{ .loc = rest_pat.loc, .arg = self.arena.patPtr(rest_pat.data, rest_pat.loc) } } };
+ count += 1;
+ break;
+ }
+ }
+ }
+
+ try self.expect(.rparen);
+ return params[0..count];
+ }
+
+ fn parseFunctionBody(self: *@This()) ParseError!BlockStmt {
+ return self.parseBlockStmt();
+ }
+
+ fn parseClassDecl(self: *@This(), mode: enum { stmt, expr }) ParseError!?Stmt {
+ const start = self.advanceTok().loc.start;
+
+ var id: ?[]const u8 = null;
+ if (self.peek() == .identifier) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ var super_class: ?*const Expr = null;
+ if (self.matchKeyword(.extends)) {
+ super_class = try self.parseExpr(0);
+ }
+
+ try self.expect(.lbrace);
+ var elems: [128]ClassElem = undefined;
+ var elem_count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const elem = try self.parseClassElement();
+ elems[elem_count] = elem;
+ elem_count += 1;
+ if (elem_count >= elems.len) return ParseError.TooManyTokens;
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+
+ if (mode == .stmt) {
+ return Stmt{
+ .loc = .{ .start = start, .end = end_tok.loc.end },
+ .data = .{ .class = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .id = id, .super_class = super_class, .body = elems[0..elem_count] } },
+ };
+ }
+ return null;
+ }
+
+ fn parseClassExpr(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+
+ var id: ?[]const u8 = null;
+ if (self.peek() == .identifier) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ var super_class: ?*const Expr = null;
+ if (self.matchKeyword(.extends)) {
+ super_class = try self.parseExpr(0);
+ }
+
+ try self.expect(.lbrace);
+ var elems: [128]ClassElem = undefined;
+ var elem_count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const elem = try self.parseClassElement();
+ elems[elem_count] = elem;
+ elem_count += 1;
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+ return self.arena.exprPtr(
+ .{ .class = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .id = id, .super_class = super_class, .body = elems[0..elem_count] } },
+ .{ .start = start, .end = end_tok.loc.end },
+ );
+ }
+
+ fn parseClassElement(self: *@This()) ParseError!ClassElem {
+ const start = self.tok().loc.start;
+ const is_static = self.matchKeyword(.static);
+
+ if (is_static and self.peek() == .lbrace) {
+ const body = try self.parseBlockStmt();
+ return ClassElem{ .static_block = body };
+ }
+
+ if (self.matchKeyword(.get)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ if (is_static) return ClassElem{ .static_get = .{ .key = key, .body = body } };
+ return ClassElem{ .get = .{ .key = key, .body = body } };
+ }
+
+ if (self.matchKeyword(.set)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ const param = try self.parseBindingPattern();
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ if (is_static) return ClassElem{ .static_set = .{ .key = key, .param = param, .body = body } };
+ return ClassElem{ .set = .{ .key = key, .param = param, .body = body } };
+ }
+
+ if (self.match(.@"*")) {
+ _ = try self.parsePropKey();
+ try self.expect(.lparen);
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ const fn_expr = FnExpr{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .generator, .id = null, .params = params, .body = body };
+ if (is_static) return ClassElem{ .static_method = fn_expr };
+ return ClassElem{ .method = fn_expr };
+ }
+
+ const key = try self.parsePropKey();
+
+ if (self.peek() == .lparen) {
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ const fn_expr = FnExpr{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .normal, .id = null, .params = params, .body = body };
+ if (is_static) return ClassElem{ .static_method = fn_expr };
+ return ClassElem{ .method = fn_expr };
+ }
+
+ var value: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ value = try self.parseExpr(0);
+ }
+ if (self.peek() == .semicolon) self.advance();
+
+ const field = FieldDef{ .loc = .{ .start = start, .end = if (value) |v| v.loc.end else self.tok().loc.start }, .key = key, .value = value };
+ if (is_static) return ClassElem{ .static_field = field };
+ return ClassElem{ .field = field };
+ }
+
+ fn parseImport(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var specifiers: [32]ImportSpecifier = undefined;
+ var spec_count: usize = 0;
+
+ if (self.peek() != .string and self.peek() != .lparen) {
+ if (self.peek() == .identifier or self.peek().isKeyword()) {
+ const local_tok = self.advanceTok();
+ const local = self.tokenSlice(local_tok);
+ specifiers[spec_count] = .{ .default = local };
+ spec_count += 1;
+ if (self.match(.comma)) {}
+ }
+
+ if (self.match(.@"*")) {
+ try self.expect(.identifier); // as
+ const ns_tok = try self.expectTok(.identifier);
+ const ns = self.tokenSlice(ns_tok);
+ specifiers[spec_count] = .{ .namespace = ns };
+ spec_count += 1;
+ } else if (self.peek() == .lbrace) {
+ self.advance();
+ if (self.peek() != .rbrace) {
+ while (true) {
+ const imported_tok = try self.expectTok(.identifier);
+ const imported = self.tokenSlice(imported_tok);
+ var local = imported;
+ if (self.match(.identifier)) {
+ local = self.tokenSlice(self.tokens[self.pos - 1]);
+ }
+ specifiers[spec_count] = .{ .named = .{ .imported = imported, .local = local } };
+ spec_count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+ try self.expect(.rbrace);
+ }
+ }
+
+ var source: []const u8 = "";
+ var attrs: [8]ImportAttribute = undefined;
+ var attr_count: usize = 0;
+
+ if (self.matchKeyword(.from)) {
+ const str_tok = try self.expectTok(.string);
+ source = self.tokenSlice(str_tok);
+ } else if (self.peek() == .string) {
+ const str_tok = self.advanceTok();
+ source = self.tokenSlice(str_tok);
+ }
+
+ if (self.matchKeyword(.with)) {
+ try self.expect(.lbrace);
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const key_tok = self.advanceTok();
+ const key = self.tokenSlice(key_tok);
+ try self.expect(.@":");
+ const val_tok = try self.expectTok(.string);
+ const val = self.tokenSlice(val_tok);
+ attrs[attr_count] = .{ .key = key, .value = val };
+ attr_count += 1;
+ _ = self.match(.comma);
+ }
+ try self.expect(.rbrace);
+ }
+
+ try self.expect(.semicolon);
+ return Stmt{
+ .loc = .{ .start = start, .end = self.tok().loc.start },
+ .data = .{ .import = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .specifiers = specifiers[0..spec_count], .source = source, .attributes = attrs[0..attr_count] } },
+ };
+ }
+
+ fn parseExport(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+
+ if (self.matchKeyword(.default)) {
+ if (self.peek() == .function or self.peek() == .async or self.peek() == .class) {
+ const decl = try self.parseStatementListItem();
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = decl.loc.end }, .data = decl.data };
+ }
+ const expr = try self.parseExpr(0);
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = expr.loc.end }, .data = .{ .expr = .{ .loc = expr.loc, .expr = expr } } };
+ }
+
+ if (self.peek() == .@"*") {
+ self.advance();
+ try self.expect(.identifier); // from
+ const source_tok = try self.expectTok(.string);
+ _ = self.tokenSlice(source_tok);
+ try self.expect(.semicolon);
+ return Stmt{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .empty = {} } };
+ }
+
+ if (self.peek() == .lbrace) {
+ self.advance();
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ _ = self.advanceTok();
+ _ = self.match(.identifier); // as
+ if (!self.match(.comma)) break;
+ }
+ try self.expect(.rbrace);
+ if (self.matchKeyword(.from)) {
+ _ = self.advanceTok();
+ }
+ try self.expect(.semicolon);
+ return Stmt{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .empty = {} } };
+ }
+
+ const decl = try self.parseStatementListItem();
+ self.semicolon();
+ return decl;
+ }
+
+ fn parseExpr(self: *@This(), min_bp: u32) ParseError!*const Expr {
+ var left = try self.parsePrimaryExpr();
+
+ while (true) {
+ const cur_bp = self.bp(self.peek());
+ if (cur_bp <= min_bp) break;
+
+ switch (self.peek()) {
+ .@"=",
+ .@"+=",
+ .@"-=",
+ .@"*=",
+ .@"/=",
+ .@"%=",
+ .@"**=",
+ .@"<<=",
+ .@">>=",
+ .@">>>=",
+ .@"&=",
+ .@"|=",
+ .@"^=",
+ .@"&&=",
+ .@"||=",
+ .@"??=",
+ => {
+ self.advance();
+ const op = self.assignOpFromToken();
+ const right = try self.parseExpr(BP.assign);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .assign = .{ .loc = loc, .op = op, .left = left, .right = right } }, loc);
+ },
+
+ .@"?" => {
+ self.advance();
+ const consequent = try self.parseExpr(0);
+ try self.expect(.@":");
+ const alternate = try self.parseExpr(BP.conditional);
+ const loc: Loc = .{ .start = left.loc.start, .end = alternate.loc.end };
+ left = self.arena.exprPtr(.{ .conditional = .{ .loc = loc, .condition = left, .consequent = consequent, .alternate = alternate } }, loc);
+ },
+
+ .@"??" => {
+ self.advance();
+ const right = try self.parseExpr(BP.coalesce);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"??", .left = left, .right = right } }, loc);
+ },
+
+ .@"||" => {
+ self.advance();
+ const right = try self.parseExpr(BP.log_or);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"||", .left = left, .right = right } }, loc);
+ },
+
+ .@"&&" => {
+ self.advance();
+ const right = try self.parseExpr(BP.log_and);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"&&", .left = left, .right = right } }, loc);
+ },
+
+ .@"|" => {
+ self.advance();
+ const right = try self.parseExpr(BP.bit_or);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"|", .left = left, .right = right } }, loc);
+ },
+
+ .@"^" => {
+ self.advance();
+ const right = try self.parseExpr(BP.bit_xor);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"^", .left = left, .right = right } }, loc);
+ },
+
+ .@"&" => {
+ self.advance();
+ const right = try self.parseExpr(BP.bit_and);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"&", .left = left, .right = right } }, loc);
+ },
+
+ .@"==" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"==", .left = left, .right = right } }, loc);
+ },
+
+ .@"!=" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"!=", .left = left, .right = right } }, loc);
+ },
+
+ .@"===" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"===", .left = left, .right = right } }, loc);
+ },
+
+ .@"!==" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"!==", .left = left, .right = right } }, loc);
+ },
+
+ .@"<" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"<", .left = left, .right = right } }, loc);
+ },
+
+ .@">" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">", .left = left, .right = right } }, loc);
+ },
+
+ .@"<=" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"<=", .left = left, .right = right } }, loc);
+ },
+
+ .@">=" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">=", .left = left, .right = right } }, loc);
+ },
+
+ .in => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .in, .left = left, .right = right } }, loc);
+ },
+
+ .instanceof => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .instanceof, .left = left, .right = right } }, loc);
+ },
+
+ .@"<<" => {
+ self.advance();
+ const right = try self.parseExpr(BP.shift);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"<<", .left = left, .right = right } }, loc);
+ },
+
+ .@">>" => {
+ self.advance();
+ const right = try self.parseExpr(BP.shift);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">>", .left = left, .right = right } }, loc);
+ },
+
+ .@">>>" => {
+ self.advance();
+ const right = try self.parseExpr(BP.shift);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">>>", .left = left, .right = right } }, loc);
+ },
+
+ .@"+" => {
+ self.advance();
+ const right = try self.parseExpr(BP.additive);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"+", .left = left, .right = right } }, loc);
+ },
+
+ .@"-" => {
+ self.advance();
+ const right = try self.parseExpr(BP.additive);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"-", .left = left, .right = right } }, loc);
+ },
+
+ .@"*" => {
+ self.advance();
+ const right = try self.parseExpr(BP.multiplicative);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"*", .left = left, .right = right } }, loc);
+ },
+
+ .@"/" => {
+ self.advance();
+ const right = try self.parseExpr(BP.multiplicative);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"/", .left = left, .right = right } }, loc);
+ },
+
+ .@"%" => {
+ self.advance();
+ const right = try self.parseExpr(BP.multiplicative);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"%", .left = left, .right = right } }, loc);
+ },
+
+ .@"**" => {
+ self.advance();
+ const right = try self.parseExpr(BP.exponentiation - 1);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"**", .left = left, .right = right } }, loc);
+ },
+
+ .lparen => {
+ self.advance();
+ var args: [256]Expr = undefined;
+ var arg_count: usize = 0;
+
+ if (self.peek() != .rparen) {
+ while (true) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ args[arg_count] = Expr{ .loc = arg.loc, .data = .{ .spread = .{ .loc = arg.loc, .arg = self.arena.exprPtr(arg.data, arg.loc) } } };
+ arg_count += 1;
+ } else {
+ const arg = try self.parseExpr(0);
+ args[arg_count] = arg.*;
+ arg_count += 1;
+ }
+ if (!self.match(.comma)) break;
+ }
+ }
+
+ try self.expect(.rparen);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .call = .{ .loc = loc, .callee = left, .args = args[0..arg_count], .optional = false } }, loc);
+ },
+
+ .@"?." => {
+ self.advance();
+ if (self.peek() == .lparen) {
+ self.advance();
+ var args: [256]Expr = undefined;
+ var arg_count: usize = 0;
+ if (self.peek() != .rparen) {
+ while (true) {
+ const arg = try self.parseExpr(0);
+ args[arg_count] = arg.*;
+ arg_count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+ try self.expect(.rparen);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .call = .{ .loc = loc, .callee = left, .args = args[0..arg_count], .optional = true } }, loc);
+ } else if (self.peek() == .lbracket) {
+ self.advance();
+ const expr = try self.parseExpr(0);
+ try self.expect(.rbracket);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .computed_member = .{ .loc = loc, .obj = left, .expr = expr } }, loc);
+ } else if (self.peek() == .identifier or self.peek().isKeyword()) {
+ const prop_tok = self.advanceTok();
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .ident = prop } } }, loc);
+ } else if (self.peek() == .private_identifier) {
+ const prop_tok = self.advanceTok();
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .private = prop } } }, loc);
+ }
+ },
+
+ .lbracket => {
+ self.advance();
+ const expr = try self.parseExpr(0);
+ try self.expect(.rbracket);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .computed_member = .{ .loc = loc, .obj = left, .expr = expr } }, loc);
+ },
+
+ .@"." => {
+ self.advance();
+ if (self.peek() == .private_identifier) {
+ const prop_tok = self.advanceTok();
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .private = prop } } }, loc);
+ } else {
+ const prop_tok = try self.expectTok(.identifier);
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .ident = prop } } }, loc);
+ }
+ },
+
+ .template_head, .no_sub_template => {
+ const template = try self.parseTemplateLit();
+ const loc: Loc = .{ .start = left.loc.start, .end = template.loc.end };
+ left = self.arena.exprPtr(.{ .tagged_template = .{ .loc = loc, .tag = left, .quasi = template } }, loc);
+ },
+
+ .@"++" => {
+ if (!self.isLineTerminatorBeforeNext()) {
+ self.advance();
+ const loc: Loc = .{ .start = left.loc.start, .end = left.loc.end + 2 };
+ left = self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"++", .arg = left, .prefix = false } }, loc);
+ } else break;
+ },
+
+ .@"--" => {
+ if (!self.isLineTerminatorBeforeNext()) {
+ self.advance();
+ const loc: Loc = .{ .start = left.loc.start, .end = left.loc.end + 2 };
+ left = self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"--", .arg = left, .prefix = false } }, loc);
+ } else break;
+ },
+
+ .comma => {
+ self.advance();
+ const right = try self.parseExpr(BP.comma);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ var exprs: [2]Expr = .{ left.*, right.* };
+ left = self.arena.exprPtr(.{ .sequence = .{ .loc = loc, .exprs = &exprs } }, loc);
+ },
+
+ else => break,
+ }
+ }
+
+ return left;
+ }
+
+ fn parsePrimaryExpr(self: *@This()) ParseError!*const Expr {
+ const start = self.tok().loc.start;
+
+ switch (self.peek()) {
+ .this => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .this = {} }, .{ .start = start, .end = t.loc.end });
+ },
+ .super => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .super = {} }, .{ .start = start, .end = t.loc.end });
+ },
+ .null => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .null = {} }, .{ .start = start, .end = t.loc.end });
+ },
+ .true => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .bool = true }, .{ .start = start, .end = t.loc.end });
+ },
+ .false => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .bool = false }, .{ .start = start, .end = t.loc.end });
+ },
+ .number => {
+ const t = self.advanceTok();
+ const val = std.fmt.parseFloat(f64, self.tokenSlice(t)) catch 0.0;
+ return self.arena.exprPtr(.{ .number = val }, .{ .start = start, .end = t.loc.end });
+ },
+ .string => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .string = self.tokenSlice(t) }, .{ .start = start, .end = t.loc.end });
+ },
+ .bigint => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .number = 0 }, .{ .start = start, .end = t.loc.end });
+ },
+ .regex => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ const slash_pos = std.mem.indexOfScalar(u8, slice[1..], '/') orelse 0;
+ const pattern = slice[1 .. slash_pos + 1];
+ const flags = slice[slash_pos + 2 ..];
+ return self.arena.exprPtr(
+ .{ .regex = .{ .pattern = pattern, .flags = flags } },
+ .{ .start = start, .end = t.loc.end },
+ );
+ },
+ .identifier => {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ return self.arena.exprPtr(.{ .identifier = name }, .{ .start = start, .end = t.loc.end });
+ },
+ .private_identifier => {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ return self.arena.exprPtr(.{ .private_ident = name }, .{ .start = start, .end = t.loc.end });
+ },
+ .lbrace => return self.parseObjLiteral(),
+ .lbracket => return self.parseArrayLiteral(),
+ .lparen => {
+ self.advance();
+ if (self.peek() == .rparen) {
+ self.advance();
+ if (self.peek() == .@"=>") {
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = self.tok().loc.start }, .params = &.{} });
+ }
+ return self.arena.exprPtr(.{ .identifier = "" }, .{ .start = start, .end = self.tok().loc.start });
+ }
+ if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ try self.expect(.rparen);
+ if (self.peek() == .@"=>") {
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = arg.loc.end }, .params = &.{} });
+ }
+ const loc: Loc = .{ .start = start, .end = self.tok().loc.start };
+ return self.arena.exprPtr(.{ .spread = .{ .loc = loc, .arg = arg } }, loc);
+ }
+ const expr = try self.parseExpr(0);
+ if (self.peek() == .comma) {
+ var params: [128]Pat = undefined;
+ var count: usize = 0;
+ params[count] = Pat{ .loc = expr.loc, .data = .{ .ident = expr.data.identifier } };
+ count += 1;
+ while (self.match(.comma)) {
+ const p = try self.parseBindingPattern();
+ params[count] = p;
+ count += 1;
+ }
+ try self.expect(.rparen);
+ if (self.peek() == .@"=>") {
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = self.tok().loc.start }, .params = params[0..count] });
+ }
+ return self.arena.exprPtr(.{ .identifier = "" }, .{ .start = start, .end = self.tok().loc.start });
+ }
+ try self.expect(.rparen);
+ if (self.peek() == .@"=>") {
+ const pat = Pat{ .loc = expr.loc, .data = .{ .ident = expr.data.identifier } };
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = self.tok().loc.start }, .params = &.{pat} });
+ }
+ return self.arena.exprPtr(.{ .parenthesized = expr }, .{ .start = start, .end = self.tok().loc.start });
+ },
+ .function => return self.parseFnExpr(),
+ .class => return self.parseClassExpr(),
+ .async => {
+ self.advance();
+ if (self.peek() == .function) {
+ return self.parseFnExpr();
+ }
+ const id_tok = try self.expectTok(.identifier);
+ const name = self.tokenSlice(id_tok);
+ if (self.peek() == .@"=>") {
+ const pat = Pat{ .loc = .{ .start = start, .end = id_tok.loc.end }, .data = .{ .ident = name } };
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = id_tok.loc.end }, .params = &.{pat} });
+ }
+ return self.arena.exprPtr(.{ .identifier = name }, .{ .start = start, .end = id_tok.loc.end });
+ },
+ .new => {
+ self.advance();
+ const callee = try self.parseExpr(BP.member);
+ var args: [256]Expr = undefined;
+ var arg_count: usize = 0;
+ if (self.peek() == .lparen) {
+ self.advance();
+ if (self.peek() != .rparen) {
+ while (true) {
+ const arg = try self.parseExpr(0);
+ args[arg_count] = arg.*;
+ arg_count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+ try self.expect(.rparen);
+ }
+ const loc: Loc = .{ .start = start, .end = if (arg_count > 0) args[arg_count - 1].loc.end else callee.loc.end };
+ return self.arena.exprPtr(.{ .new = .{ .loc = loc, .callee = callee, .args = args[0..arg_count] } }, loc);
+ },
+ .delete, .typeof, .void, .@"!", .@"~", .@"+", .@"-" => {
+ const op = self.unaryOpFromToken();
+ self.advance();
+ const arg = try self.parseExpr(BP.unary);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .unary = .{ .loc = loc, .op = op, .arg = arg, .prefix = true } }, loc);
+ },
+ .@"++" => {
+ self.advance();
+ const arg = try self.parseExpr(BP.update);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"++", .arg = arg, .prefix = true } }, loc);
+ },
+ .@"--" => {
+ self.advance();
+ const arg = try self.parseExpr(BP.update);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"--", .arg = arg, .prefix = true } }, loc);
+ },
+ .await => {
+ self.advance();
+ const arg = try self.parseExpr(BP.unary);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .await = .{ .loc = loc, .arg = arg } }, loc);
+ },
+ .yield => {
+ self.advance();
+ var delegate = false;
+ var arg: ?*const Expr = null;
+ if (!self.isLineTerminatorBeforeNext()) {
+ if (self.match(.@"*")) {
+ delegate = true;
+ }
+ if (self.peek() != .rbrace and self.peek() != .rparen and self.peek() != .rbracket and self.peek() != .semicolon and self.peek() != .comma and self.peek() != .@":" and self.peek() != .eof) {
+ arg = try self.parseExpr(0);
+ }
+ }
+ const loc: Loc = .{ .start = start, .end = if (arg) |a| a.loc.end else start + 5 };
+ return self.arena.exprPtr(.{ .yield = .{ .loc = loc, .arg = arg, .delegate = delegate } }, loc);
+ },
+ .template_head, .no_sub_template => return self.arena.exprPtr(.{ .template = try self.parseTemplateLit() }, .{ .start = start, .end = self.tok().loc.start }),
+ .import => {
+ self.advance();
+ try self.expect(.lparen);
+ _ = try self.parseExpr(0);
+ try self.expect(.rparen);
+ return self.arena.exprPtr(.{ .identifier = "import" }, .{ .start = start, .end = self.tok().loc.start });
+ },
+ .@"#" => {
+ self.advance();
+ const id_tok = try self.expectTok(.identifier);
+ return self.arena.exprPtr(.{ .private_ident = self.tokenSlice(id_tok) }, .{ .start = start, .end = id_tok.loc.end });
+ },
+ else => {
+ if (self.peek().isIdentifier()) {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ if (self.peek() == .@"=>") {
+ const pat = Pat{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .data = .{ .ident = name } };
+ return self.parseArrowExpr(.{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .params = &.{pat} });
+ }
+ return self.arena.exprPtr(.{ .identifier = name }, .{ .start = t.loc.start, .end = t.loc.end });
+ }
+ return ParseError.ExpectedExpression;
+ },
+ }
+ }
+
+ fn parseArrowExpr(self: *@This(), params_info: struct { loc: Loc, params: []const Pat }) ParseError!*const Expr {
+ try self.expect(.@"=>");
+ const async_token = false;
+
+ if (self.peek() == .lbrace) {
+ const body = try self.parseFunctionBody();
+ return self.arena.exprPtr(
+ .{ .arrow = .{ .loc = .{ .start = params_info.loc.start, .end = body.loc.end }, .async_token = async_token, .params = params_info.params, .body = .{ .block = body } } },
+ .{ .start = params_info.loc.start, .end = body.loc.end },
+ );
+ }
+
+ const expr = try self.parseExpr(0);
+ return self.arena.exprPtr(
+ .{ .arrow = .{ .loc = .{ .start = params_info.loc.start, .end = expr.loc.end }, .async_token = async_token, .params = params_info.params, .body = .{ .expr = expr } } },
+ .{ .start = params_info.loc.start, .end = expr.loc.end },
+ );
+ }
+
+ fn parseObjLiteral(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+ var props: [128]Prop = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ props[count] = .{ .loc = arg.loc, .key = .{ .ident = "" }, .data = .{ .spread = .{ .loc = arg.loc, .arg = arg } } };
+ count += 1;
+ } else if (self.peek() == .identifier) {
+ const name_tok = self.tok();
+ const name = self.tokenSlice(name_tok);
+ self.advance();
+ if (self.peek() == .@":") {
+ self.advance();
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = value.loc.end }, .key = .{ .ident = name }, .data = .{ .init = .{ .key = .{ .ident = name }, .value = value } } };
+ count += 1;
+ } else if (self.peek() == .lparen) {
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = body.loc.end }, .key = .{ .ident = name }, .data = .{ .method = .{ .loc = .{ .start = name_tok.loc.start, .end = body.loc.end }, .fn_type = .normal, .id = null, .params = params, .body = body } } };
+ count += 1;
+ } else if (self.peek() == .@"=") {
+ self.advance();
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = value.loc.end }, .key = .{ .ident = name }, .data = .{ .init = .{ .key = .{ .ident = name }, .value = value } } };
+ count += 1;
+ } else if (self.peek() == .comma or self.peek() == .rbrace) {
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = name_tok.loc.end }, .key = .{ .ident = name }, .data = .{ .shorthand = name } };
+ count += 1;
+ }
+ } else if (self.peek() == .number or self.peek() == .string) {
+ const key = try self.parsePropKey();
+ try self.expect(.@":");
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = start, .end = value.loc.end }, .key = key, .data = .{ .init = .{ .key = key, .value = value } } };
+ count += 1;
+ } else if (self.peek() == .lbracket) {
+ const key = try self.parsePropKey();
+ try self.expect(.@":");
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = start, .end = value.loc.end }, .key = key, .data = .{ .init = .{ .key = key, .value = value } } };
+ count += 1;
+ } else if (self.matchKeyword(.get)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .get = .{ .key = key, .body = body } } };
+ count += 1;
+ } else if (self.matchKeyword(.set)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ const param = try self.parseBindingPattern();
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .set = .{ .key = key, .param = param, .body = body } } };
+ count += 1;
+ } else if (self.match(.@"*")) {
+ const key = try self.parsePropKey();
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .method = .{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .generator, .id = null, .params = params, .body = body } } };
+ count += 1;
+ } else {
+ break;
+ }
+
+ if (!self.match(.comma)) break;
+ }
+
+ try self.expect(.rbrace);
+ return self.arena.exprPtr(.{ .object = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .props = props[0..count] } }, .{ .start = start, .end = self.tok().loc.start });
+ }
+
+ fn parseArrayLiteral(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+ var elems: [256]?Expr = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbracket and self.peek() != .eof) {
+ if (self.match(.comma)) {
+ elems[count] = null;
+ count += 1;
+ } else if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ elems[count] = Expr{ .loc = arg.loc, .data = .{ .spread = .{ .loc = arg.loc, .arg = arg } } };
+ count += 1;
+ if (!self.match(.comma)) break;
+ } else {
+ const expr = try self.parseExpr(0);
+ elems[count] = expr.*;
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+
+ try self.expect(.rbracket);
+ return self.arena.exprPtr(.{ .array = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .elems = elems[0..count] } }, .{ .start = start, .end = self.tok().loc.start });
+ }
+
+ fn parseTemplateLit(self: *@This()) ParseError!TemplateLit {
+ const start = self.tok().loc.start;
+ var quasis: [64]TemplateElem = undefined;
+ var exprs: [64]Expr = undefined;
+ var q_count: usize = 0;
+ var e_count: usize = 0;
+
+ while (true) {
+ switch (self.peek()) {
+ .no_sub_template => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = true };
+ q_count += 1;
+ break;
+ },
+ .template_head => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = false };
+ q_count += 1;
+ const expr = try self.parseExpr(0);
+ exprs[e_count] = expr.*;
+ e_count += 1;
+ try self.expect(.rbrace);
+ },
+ .template_middle => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = false };
+ q_count += 1;
+ const expr = try self.parseExpr(0);
+ exprs[e_count] = expr.*;
+ e_count += 1;
+ try self.expect(.rbrace);
+ },
+ .template_tail => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = true };
+ q_count += 1;
+ break;
+ },
+ else => break,
+ }
+ }
+
+ return .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .quasis = quasis[0..q_count], .exprs = exprs[0..e_count] };
+ }
+
+ fn parsePropKey(self: *@This()) ParseError!PropKey {
+ switch (self.peek()) {
+ .identifier, .let, .static, .get, .set, .async => {
+ const t = self.advanceTok();
+ return PropKey{ .ident = self.tokenSlice(t) };
+ },
+ .string => {
+ const t = self.advanceTok();
+ return PropKey{ .string = self.tokenSlice(t) };
+ },
+ .number => {
+ const t = self.advanceTok();
+ const val = std.fmt.parseFloat(f64, self.tokenSlice(t)) catch 0.0;
+ return PropKey{ .number = val };
+ },
+ .lbracket => {
+ self.advance();
+ const expr = try self.parseExpr(0);
+ try self.expect(.rbracket);
+ return PropKey{ .computed = expr };
+ },
+ .private_identifier => {
+ const t = self.advanceTok();
+ return PropKey{ .private = self.tokenSlice(t) };
+ },
+ else => return ParseError.ExpectedPropertyName,
+ }
+ }
+
+ fn parseBindingPattern(self: *@This()) ParseError!Pat {
+ const start = self.tok().loc.start;
+
+ switch (self.peek()) {
+ .identifier, .await, .yield => {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ return Pat{ .loc = .{ .start = start, .end = t.loc.end }, .data = .{ .ident = name } };
+ },
+ .lbrace => {
+ self.advance();
+ var props: [128]PatProp = undefined;
+ var count: usize = 0;
+ var rest: ?*const Pat = null;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const pat = try self.parseBindingPattern();
+ rest = self.arena.patPtr(pat.data, pat.loc);
+ break;
+ }
+ if (self.peek() == .identifier) {
+ const name_tok = self.tok();
+ const name = self.tokenSlice(name_tok);
+ self.advance();
+ if (self.peek() == .@":") {
+ self.advance();
+ const val_pat = try self.parseBindingPattern();
+ props[count] = .{ .key_value = .{ .key = .{ .ident = name }, .value = self.arena.patPtr(val_pat.data, val_pat.loc) } };
+ count += 1;
+ } else {
+ props[count] = .{ .shorthand = name };
+ count += 1;
+ }
+ } else if (self.peek() == .lbracket) {
+ const key = try self.parsePropKey();
+ try self.expect(.@":");
+ const val_pat = try self.parseBindingPattern();
+ props[count] = .{ .key_value = .{ .key = key, .value = self.arena.patPtr(val_pat.data, val_pat.loc) } };
+ count += 1;
+ } else {
+ break;
+ }
+ if (!self.match(.comma)) break;
+ }
+
+ try self.expect(.rbrace);
+ return Pat{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .object = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .props = props[0..count], .rest = rest } } };
+ },
+ .lbracket => {
+ self.advance();
+ var elems: [128]?Pat = undefined;
+ var count: usize = 0;
+ var rest: ?*const Pat = null;
+
+ while (self.peek() != .rbracket and self.peek() != .eof) {
+ if (self.match(.comma)) {
+ elems[count] = null;
+ count += 1;
+ } else if (self.peek() == .@"...") {
+ self.advance();
+ const pat = try self.parseBindingPattern();
+ rest = self.arena.patPtr(pat.data, pat.loc);
+ break;
+ } else {
+ const pat = try self.parseBindingPattern();
+ elems[count] = pat;
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+
+ try self.expect(.rbracket);
+ return Pat{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .array = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .elems = elems[0..count], .rest = rest } } };
+ },
+ else => return ParseError.ExpectedParameterName,
+ }
+ }
+
+ fn bp(_: *@This(), kind: TokenType) u32 {
+ return switch (kind) {
+ .comma => BP.comma,
+ .@"=", .@"+=", .@"-=", .@"*=", .@"/=", .@"%=", .@"**=", .@"<<=", .@">>=", .@">>>=", .@"&=", .@"|=", .@"^=", .@"&&=", .@"||=", .@"??=" => BP.assign,
+ .@"?" => BP.conditional,
+ .@"??" => BP.coalesce,
+ .@"||" => BP.log_or,
+ .@"&&" => BP.log_and,
+ .@"|" => BP.bit_or,
+ .@"^" => BP.bit_xor,
+ .@"&" => BP.bit_and,
+ .@"==", .@"!=", .@"===", .@"!==" => BP.equality,
+ .@"<", .@">", .@"<=", .@">=", .in, .instanceof => BP.relational,
+ .@"<<", .@">>", .@">>>" => BP.shift,
+ .@"+", .@"-" => BP.additive,
+ .@"*", .@"/", .@"%" => BP.multiplicative,
+ .@"**" => BP.exponentiation,
+ .lparen => BP.call,
+ .lbracket, .@".", .@"?." => BP.member,
+ .@"++", .@"--" => BP.update,
+ .template_head, .no_sub_template => BP.member,
+ else => 0,
+ };
+ }
+
+ fn unaryOpFromToken(self: *@This()) UnaryOp {
+ return switch (self.tok().kind) {
+ .@"+" => .@"+",
+ .@"-" => .@"-",
+ .@"!" => .@"!",
+ .@"~" => .@"~",
+ .typeof => .typeof,
+ .void => .void,
+ .delete => .delete,
+ else => .@"+",
+ };
+ }
+
+ fn assignOpFromToken(self: *@This()) AssignOp {
+ return switch (self.tokens[self.pos - 1].kind) {
+ .@"=" => .@"=",
+ .@"+=" => .@"+=",
+ .@"-=" => .@"-=",
+ .@"*=" => .@"*=",
+ .@"/=" => .@"/=",
+ .@"%=" => .@"%=",
+ .@"**=" => .@"**=",
+ .@"<<=" => .@"<<=",
+ .@">>=" => .@">>=",
+ .@">>>=" => .@">>>=",
+ .@"&=" => .@"&=",
+ .@"|=" => .@"|=",
+ .@"^=" => .@"^=",
+ .@"&&=" => .@"&&=",
+ .@"||=" => .@"||=",
+ .@"??=" => .@"??=",
+ else => .@"=",
+ };
+ }
+
+ fn semicolon(self: *@This()) void {
+ if (self.peek() == .semicolon) {
+ self.advance();
+ }
+ }
+
+ fn statementPointer(self: *@This()) ParseError!*const Stmt {
+ const s = try self.parseStatement();
+ return self.arena.stmtPtr(s.data, s.loc);
+ }
+};
+
+pub const Node = union(enum) {
+ program: Program,
+
+ stmt: Stmt,
+ expr: Expr,
+ pat: Pat,
+
+ decl: Decl,
+ literal: Lit,
+ property: Prop,
+ template: TemplateLit,
+ spread: SpreadElem,
+ decorator: Decorator,
+
+ import_specifier: ImportSpecifier,
+ export_specifier: ExportSpecifier,
+ import_attr: ImportAttribute,
+ catch_clause: CatchClause,
+ switch_case: SwitchCase,
+};
+
+pub const Program = struct {
+ body: []const Stmt,
+ loc: Loc,
+
+ pub fn parse(comptime source: []const u8) ParseError!Program {
+ return comptime blk: {
+ var token_buf: [4096]Token = undefined;
+ const tokens = lex.Lexer.tokenizeBuf(source, &token_buf);
+ var arena: NodeArena = .{};
+ var parser = Parser.init(tokens, source, &arena);
+ break :blk try parser.parseProgram();
+ };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ @setEvalBranchQuota(100000);
+ for (self.body, 0..) |stmt, i| {
+ if (i > 0) f.newline();
+ stmt.fmt(f);
+ }
+ }
+};
+
+pub const StmtType = union(enum) {
+ block: BlockStmt,
+ empty: void,
+ debugger: void,
+ expr: ExprStmt,
+ @"if": IfStmt,
+ @"while": WhileStmt,
+ do_while: DoWhileStmt,
+ @"for": ForStmt,
+ for_in: ForInStmt,
+ for_of: ForOfStmt,
+ @"continue": ContinueStmt,
+ @"break": BreakStmt,
+ @"return": ReturnStmt,
+ @"switch": SwitchStmt,
+ throw: ThrowStmt,
+ @"try": TryStmt,
+ labelled: LabelledStmt,
+ with: WithStmt,
+ variable: VarStmt,
+ lexical: LexicalDecl,
+ function: FnDecl,
+ class: ClassDecl,
+ using: UsingStmt,
+ import: ImportDecl,
+ @"export": ExportDecl,
+};
+
+pub const Stmt = struct {
+ loc: Loc,
+ data: StmtType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .block => |b| b.fmt(f),
+ .empty => f.writeChar(';'),
+ .debugger => f.write("debugger;"),
+ .expr => |e| {
+ e.expr.*.fmt(f);
+ f.writeChar(';');
+ },
+ .@"if" => |s| s.fmt(f),
+ .@"while" => |w| w.fmt(f),
+ .do_while => |d| d.fmt(f),
+ .@"for" => |fo| fo.fmt(f),
+ .for_in => |fi| fi.fmt(f),
+ .for_of => |fo| fo.fmt(f),
+ .@"continue" => |c| {
+ f.write("continue");
+ if (c.label) |l| {
+ f.writeChar(' ');
+ f.write(l);
+ }
+ f.writeChar(';');
+ },
+ .@"break" => |b| {
+ f.write("break");
+ if (b.label) |l| {
+ f.writeChar(' ');
+ f.write(l);
+ }
+ f.writeChar(';');
+ },
+ .@"return" => |r| {
+ f.write("return");
+ if (r.arg) |a| {
+ f.writeChar(' ');
+ a.*.fmt(f);
+ }
+ f.writeChar(';');
+ },
+ .@"switch" => |s| s.fmt(f),
+ .throw => |t| {
+ f.write("throw ");
+ t.arg.*.fmt(f);
+ f.writeChar(';');
+ },
+ .@"try" => |t| t.fmt(f),
+ .labelled => |l| {
+ f.write(l.label);
+ f.write(": ");
+ l.body.*.fmt(f);
+ },
+ .with => |w| {
+ f.write("with (");
+ w.obj.*.fmt(f);
+ f.write(") ");
+ w.body.*.fmt(f);
+ },
+ .variable => |v| v.fmt(f),
+ .lexical => |l| l.fmt(f),
+ .using => |u| {
+ f.write("using ");
+ for (u.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ f.writeChar(';');
+ },
+ .import => |i| i.fmt(f),
+ .@"export" => |e| e.fmt(f),
+ .class => |c| c.fmt(f),
+ .function => |d| d.fmt(f),
+ }
+ }
+};
+
+pub const ExprType = union(enum) {
+ identifier: []const u8,
+ this: void,
+ super: void,
+ null: void,
+ bool: bool,
+ number: f64,
+ string: []const u8,
+ regex: Regex,
+ array: ArrayExpr,
+ object: ObjectExpr,
+ func: FnExpr,
+ arrow: ArrowFn,
+ class: ClassExpr,
+ template: TemplateLit,
+ tagged_template: TaggedTemplate,
+ member: MemberExpr,
+ computed_member: ComputedMember,
+ call: CallExpr,
+ new: NewExpr,
+ chain: ChainExpr,
+ unary: UnaryExpr,
+ binary: BinaryExpr,
+ update: UpdateExpr,
+ conditional: IfExpr,
+ assign: AssignExpr,
+ sequence: SeqExpr,
+ spread: SpreadElem,
+ yield: YieldExpr,
+ await: AwaitExpr,
+ meta_prop: MetaProp,
+ parenthesized: *const Expr,
+ private_ident: []const u8,
+};
+
+pub const Expr = struct {
+ loc: Loc,
+ data: ExprType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .identifier => |name| f.write(name),
+ .this => f.write("this"),
+ .super => f.write("super"),
+ .null => f.write("null"),
+ .bool => |b| f.write(if (b) "true" else "false"),
+ .number => |n| {
+ var buf: [64]u8 = undefined;
+ f.write(std.fmt.bufPrint(&buf, "{d}", .{n}) catch "0");
+ },
+ .string => |s| {
+ f.writeChar('"');
+ f.write(s);
+ f.writeChar('"');
+ },
+ .regex => |r| {
+ f.writeChar('/');
+ f.write(r.pattern);
+ f.writeChar('/');
+ f.write(r.flags);
+ },
+ .array => |a| a.fmt(f),
+ .object => |o| o.fmt(f),
+ .func => |fn_expr| fn_expr.fmt(f),
+ .arrow => |arrow| arrow.fmt(f),
+ .class => |c| c.fmt(f),
+ .template => |t| t.fmt(f),
+ .tagged_template => |tt| tt.fmt(f),
+ .member => |m| m.fmt(f),
+ .computed_member => |cm| cm.fmt(f),
+ .call => |call| call.fmt(f),
+ .new => |n| {
+ f.write("new ");
+ n.callee.*.fmt(f);
+ f.writeChar('(');
+ for (n.args, 0..) |a, i| {
+ if (i > 0) f.write(", ");
+ a.fmt(f);
+ }
+ f.writeChar(')');
+ },
+ .chain => |c| c.expr.*.fmt(f),
+ .unary => |u| {
+ if (u.prefix) {
+ f.write(@tagName(u.op));
+ u.arg.*.fmt(f);
+ } else {
+ u.arg.*.fmt(f);
+ f.write(@tagName(u.op));
+ }
+ },
+ .binary => |b| {
+ f.writeChar('(');
+ b.left.*.fmt(f);
+ f.writeChar(' ');
+ f.write(@tagName(b.op));
+ f.writeChar(' ');
+ b.right.*.fmt(f);
+ f.writeChar(')');
+ },
+ .update => |u| {
+ const s = if (u.op == .@"++") "++" else "--";
+ if (u.prefix) {
+ f.write(s);
+ u.arg.*.fmt(f);
+ } else {
+ u.arg.*.fmt(f);
+ f.write(s);
+ }
+ },
+ .conditional => |c| {
+ c.condition.*.fmt(f);
+ f.write(" ? ");
+ c.consequent.*.fmt(f);
+ f.write(" : ");
+ c.alternate.*.fmt(f);
+ },
+ .assign => |a| {
+ a.left.*.fmt(f);
+ f.writeChar(' ');
+ f.write(@tagName(a.op));
+ f.writeChar(' ');
+ a.right.*.fmt(f);
+ },
+ .sequence => |s| {
+ for (s.exprs, 0..) |e, i| {
+ if (i > 0) f.write(", ");
+ e.fmt(f);
+ }
+ },
+ .spread => |s| {
+ f.write("...");
+ s.arg.*.fmt(f);
+ },
+ .yield => |y| {
+ f.write("yield");
+ if (y.delegate) f.write("*");
+ if (y.arg) |a| {
+ f.writeChar(' ');
+ a.*.fmt(f);
+ }
+ },
+ .await => |a| {
+ f.write("await ");
+ a.arg.*.fmt(f);
+ },
+ .meta_prop => |m| {
+ f.write(m.meta);
+ f.writeChar('.');
+ f.write(m.prop);
+ },
+ .parenthesized => |p| {
+ f.writeChar('(');
+ p.*.fmt(f);
+ f.writeChar(')');
+ },
+ .private_ident => |name| f.write(name),
+ }
+ }
+};
+
+pub const PatType = union(enum) {
+ ident: []const u8,
+ object: ObjectPat,
+ array: ArrayPat,
+ assign: AssignPat,
+ rest: RestPat,
+};
+
+pub const Pat = struct {
+ loc: Loc,
+ data: PatType,
+
+ pub fn parse(p: *Parser) ParseError!Pat {
+ const start = p.tok().loc.start;
+
+ switch (p.peek()) {
+ .identifier, .await, .yield => {
+ const t = p.advanceTok();
+ const name = p.tokenSlice(t);
+ return Pat{ .loc = .{ .start = start, .end = t.loc.end }, .data = .{ .ident = name } };
+ },
+ .lbrace => {
+ p.advance();
+ var props: [128]PatProp = undefined;
+ var count: usize = 0;
+ var rest: ?*const Pat = null;
+
+ while (p.peek() != .rbrace and p.peek() != .eof) {
+ if (p.peek() == .@"...") {
+ p.advance();
+ const pat = try Pat.parse(p);
+ rest = p.arena.patPtr(pat.data, pat.loc);
+ break;
+ }
+ if (p.peek() == .identifier) {
+ const name_tok = p.tok();
+ const name = p.tokenSlice(name_tok);
+ p.advance();
+ if (p.peek() == .@":") {
+ p.advance();
+ const val_pat = try Pat.parse(p);
+ props[count] = .{ .key_value = .{ .key = .{ .ident = name }, .value = p.arena.patPtr(val_pat.data, val_pat.loc) } };
+ count += 1;
+ } else {
+ props[count] = .{ .shorthand = name };
+ count += 1;
+ }
+ } else if (p.peek() == .lbracket) {
+ const key = try p.parsePropKey();
+ try p.expect(.@":");
+ const val_pat = try Pat.parse(p);
+ props[count] = .{ .key_value = .{ .key = key, .value = p.arena.patPtr(val_pat.data, val_pat.loc) } };
+ count += 1;
+ } else {
+ break;
+ }
+ if (!p.match(.comma)) break;
+ }
+
+ try p.expect(.rbrace);
+ return Pat{ .loc = .{ .start = start, .end = p.tok().loc.start }, .data = .{ .object = .{ .loc = .{ .start = start, .end = p.tok().loc.start }, .props = props[0..count], .rest = rest } } };
+ },
+ .lbracket => {
+ p.advance();
+ var elems: [128]?Pat = undefined;
+ var count: usize = 0;
+ var rest: ?*const Pat = null;
+
+ while (p.peek() != .rbracket and p.peek() != .eof) {
+ if (p.match(.comma)) {
+ elems[count] = null;
+ count += 1;
+ } else if (p.peek() == .@"...") {
+ p.advance();
+ const pat = try Pat.parse(p);
+ rest = p.arena.patPtr(pat.data, pat.loc);
+ break;
+ } else {
+ const pat = try Pat.parse(p);
+ elems[count] = pat;
+ count += 1;
+ if (!p.match(.comma)) break;
+ }
+ }
+
+ try p.expect(.rbracket);
+ return Pat{ .loc = .{ .start = start, .end = p.tok().loc.start }, .data = .{ .array = .{ .loc = .{ .start = start, .end = p.tok().loc.start }, .elems = elems[0..count], .rest = rest } } };
+ },
+ else => return ParseError.ExpectedParameterName,
+ }
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .ident => |name| f.write(name),
+ .object => |o| o.fmt(f),
+ .array => |a| a.fmt(f),
+ .assign => |a| {
+ a.left.*.fmt(f);
+ f.write(" = ");
+ a.right.*.fmt(f);
+ },
+ .rest => |r| {
+ f.write("...");
+ r.arg.*.fmt(f);
+ },
+ }
+ }
+};
+
+pub const DeclType = union(enum) {
+ @"fn": FnDecl,
+ class: ClassDecl,
+ @"var": VarDecl,
+ using: UsingDecl,
+ import: ImportDecl,
+ @"export": ExportDecl,
+ export_default: ExportDefault,
+};
+
+pub const Decl = struct {
+ loc: Loc,
+ data: DeclType,
+};
+
+pub const LitType = union(enum) {
+ null: void,
+ bool: bool,
+ number: f64,
+ string: []const u8,
+ regex: Regex,
+ bigint: []const u8,
+};
+
+pub const Lit = struct {
+ loc: Loc,
+ data: LitType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .null => f.write("null"),
+ .bool => |b| f.write(if (b) "true" else "false"),
+ .number => |n| {
+ var buf: [64]u8 = undefined;
+ f.write(std.fmt.bufPrint(&buf, "{d}", .{n}) catch "0");
+ },
+ .string => |s| {
+ f.writeChar('"');
+ f.write(s);
+ f.writeChar('"');
+ },
+ .regex => |r| {
+ f.writeChar('/');
+ f.write(r.pattern);
+ f.writeChar('/');
+ f.write(r.flags);
+ },
+ .bigint => |s| {
+ f.write(s);
+ f.writeChar('n');
+ },
+ }
+ }
+};
+
+pub const Regex = struct {
+ pattern: []const u8,
+ flags: []const u8,
+};
+
+pub const PropType = union(enum) {
+ init: PropInit,
+ get: PropGet,
+ set: PropSet,
+ shorthand: []const u8,
+ spread: SpreadElem,
+ method: FnExpr,
+};
+
+pub const Prop = struct {
+ loc: Loc,
+ key: PropKey,
+ data: PropType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .init => |p_init| {
+ self.key.fmt(f);
+ f.write(": ");
+ p_init.value.*.fmt(f);
+ },
+ .get => |g| g.fmt(f),
+ .set => |s| s.fmt(f),
+ .shorthand => |name| f.write(name),
+ .spread => |sp| {
+ f.write("...");
+ sp.arg.*.fmt(f);
+ },
+ .method => |m| m.fmt(f),
+ }
+ }
+};
+
+pub const PropKey = union(enum) {
+ ident: []const u8,
+ string: []const u8,
+ number: f64,
+ computed: *const Expr,
+ private: []const u8,
+};
+
+pub const PropInit = struct {
+ key: PropKey,
+ value: *const Expr,
+};
+
+pub const PropGet = struct {
+ key: PropKey,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("get ");
+ self.key.fmt(f);
+ f.write("() ");
+ self.body.fmt(f);
+ }
+};
+
+pub const PropSet = struct {
+ key: PropKey,
+ param: Pat,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("set ");
+ self.key.fmt(f);
+ f.writeChar('(');
+ self.param.fmt(f);
+ f.write(") ");
+ self.body.fmt(f);
+ }
+};
+
+pub const SpreadElem = struct {
+ loc: Loc,
+ arg: *const Expr,
+};
+
+pub const BlockStmt = struct {
+ loc: Loc,
+ body: []const Stmt,
+
+ pub fn parse(p: *Parser) ParseError!BlockStmt {
+ const start = try p.expectTok(.lbrace);
+ var stmts: [1024]Stmt = undefined;
+ var count: usize = 0;
+
+ while (p.peek() != .rbrace and p.peek() != .eof) {
+ const s = try Stmt.parse(p);
+ stmts[count] = s;
+ count += 1;
+ if (count >= stmts.len) return ParseError.TooManyTokens;
+ }
+
+ const end = try p.expectTok(.rbrace);
+ return .{ .loc = .{ .start = start.loc.start, .end = end.loc.end }, .body = stmts[0..count] };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('{');
+ if (self.body.len > 0) {
+ f.newline();
+ f.indent_level += 1;
+ for (self.body) |s| {
+ f.writeIndent();
+ s.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ }
+ f.writeChar('}');
+ }
+};
+
+pub const ExprStmt = struct {
+ loc: Loc,
+ expr: *const Expr,
+
+ pub fn parse(p: *Parser) ParseError!ExprStmt {
+ const expr = try Expr.parse(p, 0);
+ p.semicolon();
+ return .{ .loc = expr.loc, .expr = expr };
+ }
+};
+
+pub const IfStmt = struct {
+ loc: Loc,
+ condition: *const Expr,
+ consequent: *const Stmt,
+ alternate: ?*const Stmt,
+
+ pub fn parse(p: *Parser) ParseError!IfStmt {
+ const start = p.advanceTok().loc.start;
+ try p.expect(.lparen);
+ const condition = try Expr.parse(p, 0);
+ try p.expect(.rparen);
+ const consequent = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ var alternate: ?*const Stmt = null;
+ if (p.matchKeyword(.@"else")) {
+ alternate = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ }
+ const end = if (alternate) |a| a.loc.end else consequent.loc.end;
+ return .{ .loc = .{ .start = start, .end = end }, .condition = condition, .consequent = consequent, .alternate = alternate };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("if (");
+ self.condition.*.fmt(f);
+ f.write(") ");
+ self.consequent.*.fmt(f);
+ if (self.alternate) |alt| {
+ f.write(" else ");
+ alt.*.fmt(f);
+ }
+ }
+};
+
+pub const WhileStmt = struct {
+ loc: Loc,
+ condition: *const Expr,
+ body: *const Stmt,
+
+ pub fn parse(p: *Parser) ParseError!WhileStmt {
+ const start = p.advanceTok().loc.start;
+ try p.expect(.lparen);
+ const condition = try Expr.parse(p, 0);
+ try p.expect(.rparen);
+ const body = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ return .{ .loc = .{ .start = start, .end = body.loc.end }, .condition = condition, .body = body };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("while (");
+ self.condition.*.fmt(f);
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const DoWhileStmt = struct {
+ loc: Loc,
+ body: *const Stmt,
+ condition: *const Expr,
+
+ pub fn parse(p: *Parser) ParseError!DoWhileStmt {
+ const start = p.advanceTok().loc.start;
+ const body = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ try p.expect(.@"while");
+ try p.expect(.lparen);
+ const condition = try Expr.parse(p, 0);
+ try p.expect(.rparen);
+ p.semicolon();
+ return .{ .loc = .{ .start = start, .end = condition.loc.end }, .body = body, .condition = condition };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("do ");
+ self.body.*.fmt(f);
+ f.write(" while (");
+ self.condition.*.fmt(f);
+ f.write(");");
+ }
+};
+
+pub const ForInit = union(enum) {
+ expr: *const Expr,
+ decl: *const Decl,
+};
+
+pub const ForStmt = struct {
+ loc: Loc,
+ init: ?ForInit,
+ condition: ?*const Expr,
+ update: ?*const Expr,
+ body: *const Stmt,
+
+ pub fn parse(p: *Parser, start: usize, for_init: ?ForInit) ParseError!ForStmt {
+ var condition: ?*const Expr = null;
+ var update: ?*const Expr = null;
+
+ try p.expect(.semicolon);
+ if (p.peek() != .semicolon and p.peek() != .rparen) {
+ condition = try Expr.parse(p, 0);
+ }
+ try p.expect(.semicolon);
+ if (p.peek() != .rparen) {
+ update = try Expr.parse(p, 0);
+ }
+ try p.expect(.rparen);
+ const body = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ return .{ .loc = .{ .start = start, .end = body.loc.end }, .init = for_init, .condition = condition, .update = update, .body = body };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("for (");
+ if (self.init) |init| {
+ switch (init) {
+ .expr => |e| e.*.fmt(f),
+ .decl => |d| d.*.fmt(f),
+ }
+ }
+ f.writeChar(';');
+ if (self.condition) |c| {
+ f.writeChar(' ');
+ c.*.fmt(f);
+ }
+ f.writeChar(';');
+ if (self.update) |u| {
+ f.writeChar(' ');
+ u.*.fmt(f);
+ }
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const ForInStmt = struct {
+ loc: Loc,
+ left: ForInit,
+ right: *const Expr,
+ body: *const Stmt,
+
+ pub fn parse(p: *Parser, start: usize, for_init: ?ForInit) ParseError!ForInStmt {
+ const right = try Expr.parse(p, 0);
+ try p.expect(.rparen);
+ const body = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ return .{ .loc = .{ .start = start, .end = body.loc.end }, .left = for_init.?, .right = right, .body = body };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("for (");
+ switch (self.left) {
+ .expr => |e| e.*.fmt(f),
+ .decl => |d| d.*.fmt(f),
+ }
+ f.write(" in ");
+ self.right.*.fmt(f);
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const ForOfStmt = struct {
+ loc: Loc,
+ await_token: bool,
+ left: ForInit,
+ right: *const Expr,
+ body: *const Stmt,
+
+ pub fn parse(p: *Parser, start: usize, for_init: ?ForInit) ParseError!ForOfStmt {
+ const right = try Expr.parse(p, 0);
+ try p.expect(.rparen);
+ const body = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ return .{ .loc = .{ .start = start, .end = body.loc.end }, .await_token = false, .left = for_init.?, .right = right, .body = body };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("for");
+ if (self.await_token) f.write(" await");
+ f.write(" (");
+ switch (self.left) {
+ .expr => |e| e.*.fmt(f),
+ .decl => |d| d.*.fmt(f),
+ }
+ f.write(" of ");
+ self.right.*.fmt(f);
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const ContinueStmt = struct {
+ loc: Loc,
+ label: ?[]const u8,
+
+ pub fn parse(p: *Parser) ParseError!ContinueStmt {
+ const start = p.advanceTok().loc.start;
+ var label: ?[]const u8 = null;
+ if (p.peek() == .identifier and !p.isLineTerminatorBeforeNext()) {
+ const t = p.advanceTok();
+ label = p.tokenSlice(t);
+ }
+ p.semicolon();
+ return .{ .loc = .{ .start = start, .end = start + 8 }, .label = label };
+ }
+};
+
+pub const BreakStmt = struct {
+ loc: Loc,
+ label: ?[]const u8,
+
+ pub fn parse(p: *Parser) ParseError!BreakStmt {
+ const start = p.advanceTok().loc.start;
+ var label: ?[]const u8 = null;
+ if (p.peek() == .identifier and !p.isLineTerminatorBeforeNext()) {
+ const t = p.advanceTok();
+ label = p.tokenSlice(t);
+ }
+ p.semicolon();
+ return .{ .loc = .{ .start = start, .end = start + 5 }, .label = label };
+ }
+};
+
+pub const ReturnStmt = struct {
+ loc: Loc,
+ arg: ?*const Expr,
+
+ pub fn parse(p: *Parser) ParseError!ReturnStmt {
+ const start = p.advanceTok().loc.start;
+ var arg: ?*const Expr = null;
+ if (p.peek() != .semicolon and p.peek() != .rbrace and p.peek() != .eof and !p.isLineTerminatorBeforeNext()) {
+ arg = try Expr.parse(p, 0);
+ }
+ p.semicolon();
+ return .{ .loc = .{ .start = start, .end = if (arg) |a| a.loc.end else start + 6 }, .arg = arg };
+ }
+};
+
+pub const SwitchStmt = struct {
+ loc: Loc,
+ discriminant: *const Expr,
+ cases: []const SwitchCase,
+
+ pub fn parse(p: *Parser) ParseError!SwitchStmt {
+ const start = p.advanceTok().loc.start;
+ try p.expect(.lparen);
+ const discriminant = try Expr.parse(p, 0);
+ try p.expect(.rparen);
+ try p.expect(.lbrace);
+
+ var cases: [256]SwitchCase = undefined;
+ var case_count: usize = 0;
+
+ while (p.peek() == .case or p.peek() == .default) {
+ const case_start = p.tok().loc.start;
+ if (p.matchKeyword(.case)) {
+ const case_test = try Expr.parse(p, 0);
+ try p.expect(.@":");
+ var consequent: [128]Stmt = undefined;
+ var cons_count: usize = 0;
+ while (p.peek() != .case and p.peek() != .default and p.peek() != .rbrace and p.peek() != .eof) {
+ const s = try Stmt.parse(p);
+ consequent[cons_count] = s;
+ cons_count += 1;
+ }
+ cases[case_count] = .{ .loc = .{ .start = case_start, .end = p.tok().loc.start }, .condition = case_test, .consequent = consequent[0..cons_count] };
+ case_count += 1;
+ } else if (p.matchKeyword(.default)) {
+ try p.expect(.@":");
+ var consequent: [128]Stmt = undefined;
+ var cons_count: usize = 0;
+ while (p.peek() != .case and p.peek() != .default and p.peek() != .rbrace and p.peek() != .eof) {
+ const s = try Stmt.parse(p);
+ consequent[cons_count] = s;
+ cons_count += 1;
+ }
+ cases[case_count] = .{ .loc = .{ .start = case_start, .end = p.tok().loc.start }, .condition = null, .consequent = consequent[0..cons_count] };
+ case_count += 1;
+ }
+ }
+
+ const end_tok = try p.expectTok(.rbrace);
+ return .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .discriminant = discriminant, .cases = cases[0..case_count] };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("switch (");
+ self.discriminant.*.fmt(f);
+ f.write(") {");
+ f.newline();
+ f.indent_level += 1;
+ for (self.cases) |c| {
+ f.writeIndent();
+ c.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ f.writeChar('}');
+ }
+};
+
+pub const SwitchCase = struct {
+ loc: Loc,
+ condition: ?*const Expr,
+ consequent: []const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ if (self.condition) |c| {
+ f.write("case ");
+ c.*.fmt(f);
+ } else {
+ f.write("default");
+ }
+ f.writeChar(':');
+ for (self.consequent) |s| {
+ f.writeChar(' ');
+ s.fmt(f);
+ }
+ }
+};
+
+pub const ThrowStmt = struct {
+ loc: Loc,
+ arg: *const Expr,
+
+ pub fn parse(p: *Parser) ParseError!ThrowStmt {
+ const start = p.advanceTok().loc.start;
+ if (p.isLineTerminatorBeforeNext()) return ParseError.ExpectedExpression;
+ const arg = try Expr.parse(p, 0);
+ p.semicolon();
+ return .{ .loc = .{ .start = start, .end = arg.loc.end }, .arg = arg };
+ }
+};
+
+pub const TryStmt = struct {
+ loc: Loc,
+ block: BlockStmt,
+ handler: ?CatchClause,
+ finalizer: ?BlockStmt,
+
+ pub fn parse(p: *Parser) ParseError!TryStmt {
+ const start = p.advanceTok().loc.start;
+ const block = try p.parseFunctionBody();
+ var handler: ?CatchClause = null;
+ var finalizer: ?BlockStmt = null;
+
+ if (p.matchKeyword(.@"catch")) {
+ var param: ?Pat = null;
+ if (p.match(.lparen)) {
+ const pat = try Pat.parse(p);
+ param = pat;
+ try p.expect(.rparen);
+ }
+ const catch_body = try p.parseFunctionBody();
+ handler = .{ .loc = .{ .start = block.loc.start, .end = catch_body.loc.end }, .param = param, .body = catch_body };
+ }
+
+ if (p.matchKeyword(.finally)) {
+ const finally_body = try p.parseFunctionBody();
+ finalizer = finally_body;
+ }
+
+ const end = if (finalizer) |f| f.loc.end else if (handler) |h| h.loc.end else block.loc.end;
+ return .{ .loc = .{ .start = start, .end = end }, .block = block, .handler = handler, .finalizer = finalizer };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("try ");
+ self.block.fmt(f);
+ if (self.handler) |h| {
+ f.writeChar(' ');
+ h.fmt(f);
+ }
+ if (self.finalizer) |fin| {
+ f.write(" finally ");
+ fin.fmt(f);
+ }
+ }
+};
+
+pub const CatchClause = struct {
+ loc: Loc,
+ param: ?Pat,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("catch");
+ if (self.param) |p| {
+ f.write(" (");
+ p.fmt(f);
+ f.write(") ");
+ } else {
+ f.writeChar(' ');
+ }
+ self.body.fmt(f);
+ }
+};
+
+pub const LabelledStmt = struct {
+ loc: Loc,
+ label: []const u8,
+ body: *const Stmt,
+};
+
+pub const WithStmt = struct {
+ loc: Loc,
+ obj: *const Expr,
+ body: *const Stmt,
+
+ pub fn parse(p: *Parser) ParseError!WithStmt {
+ const start = p.advanceTok().loc.start;
+ try p.expect(.lparen);
+ const obj = try Expr.parse(p, 0);
+ try p.expect(.rparen);
+ const body = try p.arena.stmtPtr((try Stmt.parse(p)).data, (try Stmt.parse(p)).loc);
+ return .{ .loc = .{ .start = start, .end = body.loc.end }, .obj = obj, .body = body };
+ }
+};
+
+pub const VarStmt = struct {
+ loc: Loc,
+ kind: VarKind,
+ decls: []const VarDeclarator,
+
+ pub fn parse(p: *Parser) ParseError!VarStmt {
+ const kind_tok = p.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try Pat.parse(p);
+ var decl_init: ?*const Expr = null;
+ if (p.match(.@"=")) {
+ decl_init = try Expr.parse(p, 0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!p.match(.comma)) break;
+ }
+
+ p.semicolon();
+ return .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = .@"var", .decls = decls[0..count] };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(@tagName(self.kind));
+ f.writeChar(' ');
+ for (self.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ f.writeChar(';');
+ }
+};
+
+pub const UsingStmt = struct {
+ loc: Loc,
+ decls: []const VarDeclarator,
+
+ pub fn parse(p: *Parser) ParseError!UsingStmt {
+ const start = p.advanceTok().loc.start;
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const id_tok = try p.expectTok(.identifier);
+ const id = p.tokenSlice(id_tok);
+ var decl_init: ?*const Expr = null;
+ if (p.match(.@"=")) {
+ decl_init = try Expr.parse(p, 0);
+ }
+ decls[count] = .{ .loc = .{ .start = id_tok.loc.start, .end = if (decl_init) |e| e.loc.end else id_tok.loc.end }, .id = Pat{ .loc = .{ .start = id_tok.loc.start, .end = id_tok.loc.end }, .data = .{ .ident = id } }, .init = decl_init };
+ count += 1;
+ if (!p.match(.comma)) break;
+ }
+
+ p.semicolon();
+ return .{ .loc = .{ .start = start, .end = decls[count - 1].loc.end }, .decls = decls[0..count] };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("using ");
+ for (self.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ }
+};
+
+pub const VarKind = enum {
+ @"var",
+ let,
+ @"const",
+};
+
+pub const VarDecl = struct {
+ loc: Loc,
+ kind: VarKind,
+ decls: []const VarDeclarator,
+};
+
+pub const LexicalDecl = struct {
+ loc: Loc,
+ kind: VarKind,
+ decls: []const VarDeclarator,
+
+ pub fn parse(p: *Parser) ParseError!LexicalDecl {
+ const kind_tok = p.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try Pat.parse(p);
+ var decl_init: ?*const Expr = null;
+ if (kind_tok.kind == .@"const") {
+ if (!p.match(.@"=")) return ParseError.ExpectedToken;
+ decl_init = try Expr.parse(p, 0);
+ } else if (p.match(.@"=")) {
+ decl_init = try Expr.parse(p, 0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!p.match(.comma)) break;
+ }
+
+ p.semicolon();
+ const kind: VarKind = switch (kind_tok.kind) {
+ .let => .let,
+ .@"const" => .@"const",
+ else => return ParseError.UnexpectedToken,
+ };
+ return .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = kind, .decls = decls[0..count] };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(@tagName(self.kind));
+ f.writeChar(' ');
+ for (self.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ f.writeChar(';');
+ }
+};
+
+pub const UsingDecl = struct {
+ loc: Loc,
+ is_await: bool,
+ decls: []const VarDeclarator,
+};
+
+pub const VarDeclarator = struct {
+ loc: Loc,
+ id: Pat,
+ init: ?*const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.id.fmt(f);
+ if (self.init) |init| {
+ f.write(" = ");
+ init.*.fmt(f);
+ }
+ }
+};
+
+pub const ObjectPat = struct {
+ loc: Loc,
+ props: []const PatProp,
+ rest: ?*const Pat,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('{');
+ var first = true;
+ for (self.props) |prop| {
+ if (!first) f.write(", ");
+ first = false;
+ switch (prop) {
+ .key_value => |kv| {
+ kv.key.fmt(f);
+ f.write(": ");
+ kv.value.*.fmt(f);
+ },
+ .shorthand => |name| f.write(name),
+ .rest => |r| {
+ f.write("...");
+ r.*.fmt(f);
+ },
+ }
+ }
+ if (self.rest) |rest| {
+ if (!first) f.write(", ");
+ f.write("...");
+ rest.*.fmt(f);
+ }
+ f.writeChar('}');
+ }
+};
+
+pub const PatProp = union(enum) {
+ key_value: struct {
+ key: PropKey,
+ value: *const Pat,
+ },
+ shorthand: []const u8,
+ rest: *const Pat,
+};
+
+pub const ArrayPat = struct {
+ loc: Loc,
+ elems: []const ?Pat,
+ rest: ?*const Pat,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('[');
+ for (self.elems, 0..) |elem, i| {
+ if (i > 0) f.write(", ");
+ if (elem) |pat| pat.fmt(f);
+ }
+ if (self.rest) |rest| {
+ if (self.elems.len > 0) f.write(", ");
+ f.write("...");
+ rest.*.fmt(f);
+ }
+ f.writeChar(']');
+ }
+};
+
+pub const AssignPat = struct {
+ loc: Loc,
+ left: *const Pat,
+ right: *const Expr,
+};
+
+pub const RestPat = struct {
+ loc: Loc,
+ arg: *const Pat,
+};
+
+pub const FnType = union(enum) {
+ normal: void,
+ generator: void,
+ async: void,
+ async_generator: void,
+};
+
+pub const FnDecl = struct {
+ loc: Loc,
+ fn_type: FnType,
+ id: ?[]const u8,
+ params: []const Pat,
+ body: BlockStmt,
+
+ pub fn parse(p: *Parser, fn_type_arg: FnType, mode: enum { stmt, expr }) ParseError!?Stmt {
+ const start = p.tok().loc.start;
+ var fn_type = fn_type_arg;
+
+ if (fn_type == .async) {
+ _ = p.advanceTok();
+ } else if (fn_type == .async_generator) {
+ _ = p.advanceTok();
+ _ = p.advanceTok();
+ }
+
+ _ = p.advanceTok();
+
+ if (fn_type == .normal and p.peek() == .@"*") {
+ p.advance();
+ fn_type = .generator;
+ }
+
+ var id: ?[]const u8 = null;
+ if (p.peek().isIdentifier()) {
+ const id_tok = p.advanceTok();
+ id = p.tokenSlice(id_tok);
+ }
+
+ const params = try p.parseParams();
+ const body = try p.parseFunctionBody();
+
+ const end = body.loc.end;
+
+ if (mode == .stmt) {
+ return Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .function = .{ .loc = .{ .start = start, .end = end }, .fn_type = fn_type, .id = id, .params = params, .body = body } },
+ };
+ }
+ return null;
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("function");
+ if (self.fn_type == .generator or self.fn_type == .async_generator) {
+ f.write("*");
+ }
+ if (self.fn_type == .async or self.fn_type == .async_generator) {
+ f.write(" async");
+ }
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ f.writeChar('(');
+ for (self.params, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.write(") ");
+ self.body.fmt(f);
+ }
+};
+
+pub const FnExpr = struct {
+ loc: Loc,
+ fn_type: FnType,
+ id: ?[]const u8,
+ params: []const Pat,
+ body: BlockStmt,
+
+ pub fn parse(p: *Parser) ParseError!*const Expr {
+ const start = p.advanceTok().loc.start;
+
+ var fn_type: FnType = .normal;
+ if (p.peek() == .@"*") {
+ fn_type = .generator;
+ p.advance();
+ }
+
+ var id: ?[]const u8 = null;
+ if (p.peek() == .identifier or p.peek().isKeywordButNotLet()) {
+ const id_tok = p.advanceTok();
+ id = p.tokenSlice(id_tok);
+ }
+
+ const params = try p.parseParams();
+ const body = try p.parseFunctionBody();
+
+ return p.arena.exprPtr(
+ .{ .func = .{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = fn_type, .id = id, .params = params, .body = body } },
+ .{ .start = start, .end = body.loc.end },
+ );
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("function");
+ if (self.fn_type == .generator or self.fn_type == .async_generator) {
+ f.write("*");
+ }
+ if (self.fn_type == .async or self.fn_type == .async_generator) {
+ f.write(" async");
+ }
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ f.writeChar('(');
+ for (self.params, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.write(") ");
+ self.body.fmt(f);
+ }
+};
+
+pub const ArrowFn = struct {
+ loc: Loc,
+ async_token: bool,
+ params: []const Pat,
+ body: union(enum) {
+ block: BlockStmt,
+ expr: *const Expr,
+ },
+
+ pub fn parse(p: *Parser, params_info: struct { loc: Loc, params: []const Pat }) ParseError!*const Expr {
+ try p.expect(.@"=>");
+ const async_token = false;
+
+ if (p.peek() == .lbrace) {
+ const body = try p.parseFunctionBody();
+ return p.arena.exprPtr(
+ .{ .arrow = .{ .loc = .{ .start = params_info.loc.start, .end = body.loc.end }, .async_token = async_token, .params = params_info.params, .body = .{ .block = body } } },
+ .{ .start = params_info.loc.start, .end = body.loc.end },
+ );
+ }
+
+ const expr = try Expr.parse(p, 0);
+ return p.arena.exprPtr(
+ .{ .arrow = .{ .loc = .{ .start = params_info.loc.start, .end = expr.loc.end }, .async_token = async_token, .params = params_info.params, .body = .{ .expr = expr } } },
+ .{ .start = params_info.loc.start, .end = expr.loc.end },
+ );
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ if (self.async_token) f.write("async ");
+ f.writeChar('(');
+ for (self.params, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.write(") => ");
+ switch (self.body) {
+ .block => |b| b.fmt(f),
+ .expr => |e| e.*.fmt(f),
+ }
+ }
+};
+
+pub const ClassDecl = struct {
+ loc: Loc,
+ id: ?[]const u8,
+ super_class: ?*const Expr,
+ body: []const ClassElem,
+
+ pub fn parse(p: *Parser, mode: enum { stmt, expr }) ParseError!?Stmt {
+ const start = p.advanceTok().loc.start;
+
+ var id: ?[]const u8 = null;
+ if (p.peek() == .identifier) {
+ const id_tok = p.advanceTok();
+ id = p.tokenSlice(id_tok);
+ }
+
+ var super_class: ?*const Expr = null;
+ if (p.matchKeyword(.extends)) {
+ super_class = try Expr.parse(p, 0);
+ }
+
+ try p.expect(.lbrace);
+ var elems: [128]ClassElem = undefined;
+ var elem_count: usize = 0;
+
+ while (p.peek() != .rbrace and p.peek() != .eof) {
+ const elem = try ClassElem.parse(p);
+ elems[elem_count] = elem;
+ elem_count += 1;
+ if (elem_count >= elems.len) return ParseError.TooManyTokens;
+ }
+
+ const end_tok = try p.expectTok(.rbrace);
+
+ if (mode == .stmt) {
+ return Stmt{
+ .loc = .{ .start = start, .end = end_tok.loc.end },
+ .data = .{ .class = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .id = id, .super_class = super_class, .body = elems[0..elem_count] } },
+ };
+ }
+ return null;
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("class");
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ if (self.super_class) |sc| {
+ f.write(" extends ");
+ sc.*.fmt(f);
+ }
+ f.write(" {");
+ f.newline();
+ f.indent_level += 1;
+ for (self.body) |elem| {
+ f.writeIndent();
+ elem.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ f.writeChar('}');
+ }
+};
+
+pub const ClassExpr = struct {
+ loc: Loc,
+ id: ?[]const u8,
+ super_class: ?*const Expr,
+ body: []const ClassElem,
+
+ pub fn parse(p: *Parser) ParseError!*const Expr {
+ const start = p.advanceTok().loc.start;
+
+ var id: ?[]const u8 = null;
+ if (p.peek() == .identifier) {
+ const id_tok = p.advanceTok();
+ id = p.tokenSlice(id_tok);
+ }
+
+ var super_class: ?*const Expr = null;
+ if (p.matchKeyword(.extends)) {
+ super_class = try Expr.parse(p, 0);
+ }
+
+ try p.expect(.lbrace);
+ var elems: [128]ClassElem = undefined;
+ var elem_count: usize = 0;
+
+ while (p.peek() != .rbrace and p.peek() != .eof) {
+ const elem = try ClassElem.parse(p);
+ elems[elem_count] = elem;
+ elem_count += 1;
+ }
+
+ const end_tok = try p.expectTok(.rbrace);
+ return p.arena.exprPtr(
+ .{ .class = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .id = id, .super_class = super_class, .body = elems[0..elem_count] } },
+ .{ .start = start, .end = end_tok.loc.end },
+ );
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("class");
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ if (self.super_class) |sc| {
+ f.write(" extends ");
+ sc.*.fmt(f);
+ }
+ f.write(" {");
+ f.newline();
+ f.indent_level += 1;
+ for (self.body) |elem| {
+ f.writeIndent();
+ elem.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ f.writeChar('}');
+ }
+};
+
+pub const ClassElem = union(enum) {
+ method: FnExpr,
+ get: PropGet,
+ set: PropSet,
+ field: FieldDef,
+ static_block: BlockStmt,
+ static_method: FnExpr,
+ static_get: PropGet,
+ static_set: PropSet,
+ static_field: FieldDef,
+
+ pub fn parse(p: *Parser) ParseError!ClassElem {
+ const start = p.tok().loc.start;
+ const is_static = p.matchKeyword(.static);
+
+ if (is_static and p.peek() == .lbrace) {
+ const body = try p.parseFunctionBody();
+ return ClassElem{ .static_block = body };
+ }
+
+ if (p.matchKeyword(.get)) {
+ const key = try p.parsePropKey();
+ try p.expect(.lparen);
+ try p.expect(.rparen);
+ const body = try p.parseFunctionBody();
+ if (is_static) return ClassElem{ .static_get = .{ .key = key, .body = body } };
+ return ClassElem{ .get = .{ .key = key, .body = body } };
+ }
+
+ if (p.matchKeyword(.set)) {
+ const key = try p.parsePropKey();
+ try p.expect(.lparen);
+ const param = try Pat.parse(p);
+ try p.expect(.rparen);
+ const body = try p.parseFunctionBody();
+ if (is_static) return ClassElem{ .static_set = .{ .key = key, .param = param, .body = body } };
+ return ClassElem{ .set = .{ .key = key, .param = param, .body = body } };
+ }
+
+ if (p.match(.@"*")) {
+ _ = try p.parsePropKey();
+ try p.expect(.lparen);
+ const params = try p.parseParams();
+ const body = try p.parseFunctionBody();
+ const fn_expr = FnExpr{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .generator, .id = null, .params = params, .body = body };
+ if (is_static) return ClassElem{ .static_method = fn_expr };
+ return ClassElem{ .method = fn_expr };
+ }
+
+ const key = try p.parsePropKey();
+
+ if (p.peek() == .lparen) {
+ const params = try p.parseParams();
+ const body = try p.parseFunctionBody();
+ const fn_expr = FnExpr{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .normal, .id = null, .params = params, .body = body };
+ if (is_static) return ClassElem{ .static_method = fn_expr };
+ return ClassElem{ .method = fn_expr };
+ }
+
+ var value: ?*const Expr = null;
+ if (p.match(.@"=")) {
+ value = try Expr.parse(p, 0);
+ }
+ if (p.peek() == .semicolon) p.advance();
+
+ const field = FieldDef{ .loc = .{ .start = start, .end = if (value) |v| v.loc.end else p.tok().loc.start }, .key = key, .value = value };
+ if (is_static) return ClassElem{ .static_field = field };
+ return ClassElem{ .field = field };
+ }
+};
+
+pub const FieldDef = struct {
+ loc: Loc,
+ key: PropKey,
+ value: ?*const Expr,
+};
+
+pub const ImportDecl = struct {
+ loc: Loc,
+ specifiers: []const ImportSpecifier,
+ source: []const u8,
+ attributes: []const ImportAttribute,
+
+ pub fn parse(p: *Parser) ParseError!ImportDecl {
+ const start = p.advanceTok().loc.start;
+ var specifiers: [32]ImportSpecifier = undefined;
+ var spec_count: usize = 0;
+
+ if (p.peek() != .string and p.peek() != .lparen) {
+ if (p.peek() == .identifier or p.peek().isKeyword()) {
+ const local_tok = p.advanceTok();
+ const local = p.tokenSlice(local_tok);
+ specifiers[spec_count] = .{ .default = local };
+ spec_count += 1;
+ if (p.match(.comma)) {}
+ }
+
+ if (p.match(.@"*")) {
+ try p.expect(.identifier);
+ const ns_tok = try p.expectTok(.identifier);
+ const ns = p.tokenSlice(ns_tok);
+ specifiers[spec_count] = .{ .namespace = ns };
+ spec_count += 1;
+ } else if (p.peek() == .lbrace) {
+ p.advance();
+ if (p.peek() != .rbrace) {
+ while (true) {
+ const imported_tok = try p.expectTok(.identifier);
+ const imported = p.tokenSlice(imported_tok);
+ var local = imported;
+ if (p.match(.identifier)) {
+ local = p.tokenSlice(p.tokens[p.pos - 1]);
+ }
+ specifiers[spec_count] = .{ .named = .{ .imported = imported, .local = local } };
+ spec_count += 1;
+ if (!p.match(.comma)) break;
+ }
+ }
+ try p.expect(.rbrace);
+ }
+ }
+
+ var source: []const u8 = "";
+ var attrs: [8]ImportAttribute = undefined;
+ var attr_count: usize = 0;
+
+ if (p.matchKeyword(.from)) {
+ const str_tok = try p.expectTok(.string);
+ source = p.tokenSlice(str_tok);
+ } else if (p.peek() == .string) {
+ const str_tok = p.advanceTok();
+ source = p.tokenSlice(str_tok);
+ }
+
+ if (p.matchKeyword(.with)) {
+ try p.expect(.lbrace);
+ while (p.peek() != .rbrace and p.peek() != .eof) {
+ const key_tok = p.advanceTok();
+ const key = p.tokenSlice(key_tok);
+ try p.expect(.@":");
+ const val_tok = try p.expectTok(.string);
+ const val = p.tokenSlice(val_tok);
+ attrs[attr_count] = .{ .key = key, .value = val };
+ attr_count += 1;
+ _ = p.match(.comma);
+ }
+ try p.expect(.rbrace);
+ }
+
+ try p.expect(.semicolon);
+ return .{ .loc = .{ .start = start, .end = p.tok().loc.start }, .specifiers = specifiers[0..spec_count], .source = source, .attributes = attrs[0..attr_count] };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("import ");
+ if (self.specifiers.len > 0) {
+ for (self.specifiers, 0..) |spec, j| {
+ if (j > 0) f.write(", ");
+ spec.fmt(f);
+ }
+ f.write(" from ");
+ }
+ f.writeChar('"');
+ f.write(self.source);
+ f.writeChar('"');
+ for (self.attributes) |a| {
+ f.write(" /* ");
+ a.fmt(f);
+ f.write(" */");
+ }
+ f.writeChar(';');
+ }
+};
+
+pub const ImportSpecifier = union(enum) {
+ default: []const u8,
+ namespace: []const u8,
+ named: struct { imported: []const u8, local: []const u8 },
+};
+
+pub const ImportAttribute = struct {
+ key: []const u8,
+ value: []const u8,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(self.key);
+ f.write(": \"");
+ f.write(self.value);
+ f.writeChar('"');
+ }
+};
+
+pub const ExportDecl = struct {
+ loc: Loc,
+ declaration: ?*const Decl,
+ specifiers: ?[]const ExportSpecifier,
+ source: ?[]const u8,
+
+ pub fn parse(p: *Parser) ParseError!ExportDecl {
+ const start = p.advanceTok().loc.start;
+
+ return .{ .loc = .{ .start = start, .end = p.tok().loc.start }, .declaration = null, .specifiers = null, .source = null };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("export ");
+ if (self.declaration) |d| {
+ d.*.fmt(f);
+ } else if (self.specifiers) |s| {
+ f.writeChar('{');
+ for (s, 0..) |sp, i| {
+ if (i > 0) f.write(", ");
+ sp.fmt(f);
+ }
+ f.writeChar('}');
+ if (self.source) |src| {
+ f.write(" from \"");
+ f.write(src);
+ f.writeChar('"');
+ }
+ f.writeChar(';');
+ } else if (self.source) |src| {
+ f.write("* from \"");
+ f.write(src);
+ f.writeChar("\";");
+ }
+ }
+};
+
+pub const ExportSpecifier = struct {
+ loc: Loc,
+ exported: []const u8,
+ local: []const u8,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(self.local);
+ if (!std.mem.eql(u8, self.local, self.exported)) {
+ f.write(" as ");
+ f.write(self.exported);
+ }
+ }
+};
+
+pub const ExportDefault = struct {
+ loc: Loc,
+ declaration: *const Decl,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("export default ");
+ self.declaration.*.fmt(f);
+ }
+};
+
+pub const ArrayExpr = struct {
+ loc: Loc,
+ elems: []const ?Expr,
+
+ pub fn parse(p: *Parser) ParseError!*const Expr {
+ const start = p.advanceTok().loc.start;
+ var elems: [256]?Expr = undefined;
+ var count: usize = 0;
+
+ while (p.peek() != .rbracket and p.peek() != .eof) {
+ if (p.match(.comma)) {
+ elems[count] = null;
+ count += 1;
+ } else if (p.peek() == .@"...") {
+ p.advance();
+ const arg = try Expr.parse(p, 0);
+ elems[count] = Expr{ .loc = arg.loc, .data = .{ .spread = .{ .loc = arg.loc, .arg = arg } } };
+ count += 1;
+ if (!p.match(.comma)) break;
+ } else {
+ const expr = try Expr.parse(p, 0);
+ elems[count] = expr.*;
+ count += 1;
+ if (!p.match(.comma)) break;
+ }
+ }
+
+ try p.expect(.rbracket);
+ return p.arena.exprPtr(.{ .array = .{ .loc = .{ .start = start, .end = p.tok().loc.start }, .elems = elems[0..count] } }, .{ .start = start, .end = p.tok().loc.start });
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('[');
+ for (self.elems, 0..) |elem, i| {
+ if (i > 0) f.write(", ");
+ if (elem) |e| e.fmt(f);
+ }
+ f.writeChar(']');
+ }
+};
+
+pub const ObjectExpr = struct {
+ loc: Loc,
+ props: []const Prop,
+
+ pub fn parse(p: *Parser) ParseError!*const Expr {
+ const start = p.advanceTok().loc.start;
+ var props: [128]Prop = undefined;
+ var count: usize = 0;
+
+ while (p.peek() != .rbrace and p.peek() != .eof) {
+ if (p.peek() == .@"...") {
+ p.advance();
+ const arg = try Expr.parse(p, 0);
+ props[count] = .{ .loc = arg.loc, .key = .{ .ident = "" }, .data = .{ .spread = .{ .loc = arg.loc, .arg = arg } } };
+ count += 1;
+ } else if (p.peek() == .identifier) {
+ const name_tok = p.tok();
+ const name = p.tokenSlice(name_tok);
+ p.advance();
+ if (p.peek() == .@":") {
+ p.advance();
+ const value = try Expr.parse(p, 0);
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = value.loc.end }, .key = .{ .ident = name }, .data = .{ .init = .{ .key = .{ .ident = name }, .value = value } } };
+ count += 1;
+ } else if (p.peek() == .lparen) {
+ const params = try p.parseParams();
+ const body = try p.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = body.loc.end }, .key = .{ .ident = name }, .data = .{ .method = .{ .loc = .{ .start = name_tok.loc.start, .end = body.loc.end }, .fn_type = .normal, .id = null, .params = params, .body = body } } };
+ count += 1;
+ } else if (p.peek() == .@"=") {
+ p.advance();
+ const value = try Expr.parse(p, 0);
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = value.loc.end }, .key = .{ .ident = name }, .data = .{ .init = .{ .key = .{ .ident = name }, .value = value } } };
+ count += 1;
+ } else if (p.peek() == .comma or p.peek() == .rbrace) {
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = name_tok.loc.end }, .key = .{ .ident = name }, .data = .{ .shorthand = name } };
+ count += 1;
+ }
+ } else if (p.peek() == .number or p.peek() == .string) {
+ const key = try p.parsePropKey();
+ try p.expect(.@":");
+ const value = try Expr.parse(p, 0);
+ props[count] = .{ .loc = .{ .start = start, .end = value.loc.end }, .key = key, .data = .{ .init = .{ .key = key, .value = value } } };
+ count += 1;
+ } else if (p.peek() == .lbracket) {
+ const key = try p.parsePropKey();
+ try p.expect(.@":");
+ const value = try Expr.parse(p, 0);
+ props[count] = .{ .loc = .{ .start = start, .end = value.loc.end }, .key = key, .data = .{ .init = .{ .key = key, .value = value } } };
+ count += 1;
+ } else if (p.matchKeyword(.get)) {
+ const key = try p.parsePropKey();
+ try p.expect(.lparen);
+ try p.expect(.rparen);
+ const body = try p.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .get = .{ .key = key, .body = body } } };
+ count += 1;
+ } else if (p.matchKeyword(.set)) {
+ const key = try p.parsePropKey();
+ try p.expect(.lparen);
+ const param = try Pat.parse(p);
+ try p.expect(.rparen);
+ const body = try p.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .set = .{ .key = key, .param = param, .body = body } } };
+ count += 1;
+ } else if (p.match(.@"*")) {
+ const key = try p.parsePropKey();
+ const params = try p.parseParams();
+ const body = try p.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .method = .{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .generator, .id = null, .params = params, .body = body } } };
+ count += 1;
+ } else {
+ break;
+ }
+
+ if (!p.match(.comma)) break;
+ }
+
+ try p.expect(.rbrace);
+ return p.arena.exprPtr(.{ .object = .{ .loc = .{ .start = start, .end = p.tok().loc.start }, .props = props[0..count] } }, .{ .start = start, .end = p.tok().loc.start });
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('{');
+ for (self.props, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.writeChar('}');
+ }
+};
+
+pub const MemberExpr = struct {
+ loc: Loc,
+ obj: *const Expr,
+ prop: union(enum) {
+ ident: []const u8,
+ private: []const u8,
+ },
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.obj.*.fmt(f);
+ switch (self.prop) {
+ .ident => |name| {
+ f.writeChar('.');
+ f.write(name);
+ },
+ .private => |name| {
+ f.writeChar('.');
+ f.write(name);
+ },
+ }
+ }
+};
+
+pub const ComputedMember = struct {
+ loc: Loc,
+ obj: *const Expr,
+ expr: *const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.obj.*.fmt(f);
+ f.writeChar('[');
+ self.expr.*.fmt(f);
+ f.writeChar(']');
+ }
+};
+
+pub const CallExpr = struct {
+ loc: Loc,
+ callee: *const Expr,
+ args: []const Expr,
+ optional: bool,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.callee.*.fmt(f);
+ if (self.optional) {
+ f.write("?.(");
+ } else {
+ f.writeChar('(');
+ }
+ for (self.args, 0..) |a, i| {
+ if (i > 0) f.write(", ");
+ a.fmt(f);
+ }
+ f.writeChar(')');
+ }
+};
+
+pub const NewExpr = struct {
+ loc: Loc,
+ callee: *const Expr,
+ args: []const Expr,
+};
+
+pub const ChainExpr = struct {
+ loc: Loc,
+ expr: *const Expr,
+};
+
+pub const UnaryOp = enum {
+ @"-",
+ @"+",
+ @"!",
+ @"~",
+ typeof,
+ void,
+ delete,
+};
+
+pub const UnaryExpr = struct {
+ loc: Loc,
+ op: UnaryOp,
+ arg: *const Expr,
+ prefix: bool,
+};
+
+pub const BinaryOp = enum {
+ @"==",
+ @"!=",
+ @"===",
+ @"!==",
+ @"<",
+ @"<=",
+ @">",
+ @">=",
+ @"<<",
+ @">>",
+ @">>>",
+ @"+",
+ @"-",
+ @"*",
+ @"/",
+ @"%",
+ @"**",
+ @"|",
+ @"^",
+ @"&",
+ in,
+ instanceof,
+ @"||",
+ @"&&",
+ @"??",
+};
+
+pub const BinaryExpr = struct {
+ loc: Loc,
+ op: BinaryOp,
+ left: *const Expr,
+ right: *const Expr,
+};
+
+pub const UpdateOp = enum {
+ @"++",
+ @"--",
+};
+
+pub const UpdateExpr = struct {
+ loc: Loc,
+ op: UpdateOp,
+ arg: *const Expr,
+ prefix: bool,
+};
+
+pub const IfExpr = struct {
+ loc: Loc,
+ condition: *const Expr,
+ consequent: *const Expr,
+ alternate: *const Expr,
+};
+
+pub const AssignOp = enum {
+ @"=",
+ @"+=",
+ @"-=",
+ @"*=",
+ @"/=",
+ @"%=",
+ @"**=",
+ @"<<=",
+ @">>=",
+ @">>>=",
+ @"|=",
+ @"^=",
+ @"&=",
+ @"||=",
+ @"&&=",
+ @"??=",
+};
+
+pub const AssignExpr = struct {
+ loc: Loc,
+ op: AssignOp,
+ left: *const Expr,
+ right: *const Expr,
+};
+
+pub const SeqExpr = struct {
+ loc: Loc,
+ exprs: []const Expr,
+};
+
+pub const YieldExpr = struct {
+ loc: Loc,
+ arg: ?*const Expr,
+ delegate: bool,
+};
+
+pub const AwaitExpr = struct {
+ loc: Loc,
+ arg: *const Expr,
+};
+
+pub const MetaProp = struct {
+ loc: Loc,
+ meta: []const u8,
+ prop: []const u8,
+};
+
+pub const TemplateLit = struct {
+ loc: Loc,
+ quasis: []const TemplateElem,
+ exprs: []const Expr,
+
+ pub fn parse(p: *Parser) ParseError!TemplateLit {
+ const start = p.tok().loc.start;
+ var quasis: [64]TemplateElem = undefined;
+ var exprs: [64]Expr = undefined;
+ var q_count: usize = 0;
+ var e_count: usize = 0;
+
+ while (true) {
+ switch (p.peek()) {
+ .no_sub_template => {
+ const t = p.advanceTok();
+ const slice = p.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = true };
+ q_count += 1;
+ break;
+ },
+ .template_head => {
+ const t = p.advanceTok();
+ const slice = p.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = false };
+ q_count += 1;
+ const expr = try Expr.parse(p, 0);
+ exprs[e_count] = expr.*;
+ e_count += 1;
+ try p.expect(.rbrace);
+ },
+ .template_middle => {
+ const t = p.advanceTok();
+ const slice = p.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = false };
+ q_count += 1;
+ const expr = try Expr.parse(p, 0);
+ exprs[e_count] = expr.*;
+ e_count += 1;
+ try p.expect(.rbrace);
+ },
+ .template_tail => {
+ const t = p.advanceTok();
+ const slice = p.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = true };
+ q_count += 1;
+ break;
+ },
+ else => break,
+ }
+ }
+
+ return .{ .loc = .{ .start = start, .end = p.tok().loc.start }, .quasis = quasis[0..q_count], .exprs = exprs[0..e_count] };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('`');
+ var ei: usize = 0;
+ for (self.quasis, 0..) |q, i| {
+ if (i > 0 and ei < self.exprs.len) {
+ f.write("${");
+ self.exprs[ei].fmt(f);
+ f.writeChar('}');
+ ei += 1;
+ }
+ f.write(q.value);
+ }
+ f.writeChar('`');
+ }
+};
+
+pub const TemplateElem = struct {
+ loc: Loc,
+ value: []const u8,
+ tail: bool,
+};
+
+pub const TaggedTemplate = struct {
+ loc: Loc,
+ tag: *const Expr,
+ quasi: TemplateLit,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.tag.*.fmt(f);
+ self.quasi.fmt(f);
+ }
+};
+
+pub const Decorator = struct {
+ loc: Loc,
+ expr: *const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('@');
+ self.expr.*.fmt(f);
+ }
+};
diff --git a/src/z/parser/js/ast.zig.bak b/src/z/parser/js/ast.zig.bak
new file mode 100644
index 0000000..3dc29a3
--- /dev/null
+++ b/src/z/parser/js/ast.zig.bak
@@ -0,0 +1,3334 @@
+const std = @import("std");
+
+pub const Loc = struct {
+ start: usize,
+ end: usize,
+};
+
+const lex = @import("lexical_grammar.zig");
+const Token = lex.Token;
+const TokenType = lex.TokenType;
+
+pub const FormatOptions = struct {
+ indent_size: usize = 4,
+};
+
+pub const Formatter = struct {
+ buf: []u8,
+ pos: usize,
+ indent_level: usize,
+ options: FormatOptions,
+
+ pub fn write(self: *@This(), s: []const u8) void {
+ @memcpy(self.buf[self.pos..][0..s.len], s);
+ self.pos += s.len;
+ }
+
+ pub fn writeChar(self: *@This(), c: u8) void {
+ self.buf[self.pos] = c;
+ self.pos += 1;
+ }
+
+ pub fn writeIndent(self: *@This()) void {
+ const spaces = self.indent_level * self.options.indent_size;
+ var i: usize = 0;
+ while (i < spaces) : (i += 1) {
+ self.writeChar(' ');
+ }
+ }
+
+ pub fn newline(self: *@This()) void {
+ self.writeChar('\n');
+ }
+};
+
+pub const ParseError = error{
+ UnexpectedToken,
+ ExpectedToken,
+ ExpectedExpression,
+ ExpectedStatement,
+ ExpectedIdentifier,
+ UnclosedString,
+ InvalidNumber,
+ InvalidEscape,
+ UnterminatedComment,
+ ExpectedParameterName,
+ ExpectedPropertyName,
+ UnterminatedTemplate,
+ InvalidAssignmentTarget,
+ TooManyTokens,
+};
+
+const BP = struct {
+ const comma = 1;
+ const assign = 2;
+ const yield = 3;
+ const conditional = 4;
+ const coalesce = 5;
+ const log_or = 6;
+ const log_and = 7;
+ const bit_or = 8;
+ const bit_xor = 9;
+ const bit_and = 10;
+ const equality = 11;
+ const relational = 12;
+ const shift = 13;
+ const additive = 14;
+ const multiplicative = 15;
+ const exponentiation = 16;
+ const unary = 17;
+ const update = 18;
+ const call = 19;
+ const member = 20;
+};
+
+pub const NodeArena = struct {
+ exprs: [8192]Expr = undefined,
+ expr_count: usize = 0,
+ stmts: [8192]Stmt = undefined,
+ stmt_count: usize = 0,
+ decls: [1024]Decl = undefined,
+ decl_count: usize = 0,
+ pats: [1024]Pat = undefined,
+ pat_count: usize = 0,
+ lits: [1024]Lit = undefined,
+ lit_count: usize = 0,
+ string_buf: [65536]u8 = undefined,
+ string_pos: usize = 0,
+
+ fn exprPtr(self: *NodeArena, data: ExprType, loc: Loc) *const Expr {
+ const idx = self.expr_count;
+ self.exprs[idx] = .{ .loc = loc, .data = data };
+ self.expr_count += 1;
+ return &self.exprs[idx];
+ }
+
+ fn stmtPtr(self: *NodeArena, data: StmtType, loc: Loc) *const Stmt {
+ const idx = self.stmt_count;
+ self.stmts[idx] = .{ .loc = loc, .data = data };
+ self.stmt_count += 1;
+ return &self.stmts[idx];
+ }
+
+ fn declPtr(self: *NodeArena, data: DeclType, loc: Loc) *const Decl {
+ const idx = self.decl_count;
+ self.decls[idx] = .{ .loc = loc, .data = data };
+ self.decl_count += 1;
+ return &self.decls[idx];
+ }
+
+ fn patPtr(self: *NodeArena, data: PatType, loc: Loc) *const Pat {
+ const idx = self.pat_count;
+ self.pats[idx] = .{ .loc = loc, .data = data };
+ self.pat_count += 1;
+ return &self.pats[idx];
+ }
+
+ fn litPtr(self: *NodeArena, data: LitType, loc: Loc) *const Lit {
+ const idx = self.lit_count;
+ self.lits[idx] = .{ .loc = loc, .data = data };
+ self.lit_count += 1;
+ return &self.lits[idx];
+ }
+};
+
+pub const Parser = struct {
+ tokens: []const Token,
+ pos: usize,
+ source: []const u8,
+ arena: *NodeArena,
+
+ pub fn init(tokens: []const Token, source: []const u8, arena: *NodeArena) @This() {
+ return .{ .tokens = tokens, .pos = 0, .source = source, .arena = arena };
+ }
+
+ fn tok(self: *@This()) Token {
+ return self.tokens[self.pos];
+ }
+
+ fn peek(self: *@This()) TokenType {
+ return self.tokens[self.pos].kind;
+ }
+
+ fn peekAt(self: *@This(), offset: usize) TokenType {
+ const idx = self.pos + offset;
+ if (idx >= self.tokens.len) return .eof;
+ return self.tokens[idx].kind;
+ }
+
+ fn advance(self: *@This()) void {
+ self.pos += 1;
+ }
+
+ fn advanceTok(self: *@This()) Token {
+ const t = self.tokens[self.pos];
+ self.pos += 1;
+ return t;
+ }
+
+ fn expect(self: *@This(), kind: TokenType) ParseError!void {
+ if (self.peek() != kind) return ParseError.ExpectedToken;
+ self.advance();
+ }
+
+ fn expectTok(self: *@This(), kind: TokenType) ParseError!Token {
+ if (self.peek() != kind) return ParseError.ExpectedToken;
+ return self.advanceTok();
+ }
+
+ fn match(self: *@This(), kind: TokenType) bool {
+ if (self.peek() == kind) {
+ _ = self.advanceTok();
+ return true;
+ }
+ return false;
+ }
+
+ fn matchKeyword(self: *@This(), kw: TokenType) bool {
+ if (self.peek() == kw) {
+ _ = self.advanceTok();
+ return true;
+ }
+ return false;
+ }
+
+ fn isLineTerminatorBeforeNext(self: *@This()) bool {
+ if (self.pos == 0) return false;
+ const prev_token = self.tokens[self.pos - 1];
+ const next_token = self.tokens[self.pos];
+ var i = prev_token.loc.end;
+ while (i < next_token.loc.start) : (i += 1) {
+ if (i >= self.source.len) break;
+ const c = self.source[i];
+ switch (c) {
+ '\n', '\r' => return true,
+ else => {},
+ }
+ }
+ return false;
+ }
+
+ fn as_identifier(self: *@This(), t: Token) []const u8 {
+ return self.source[t.loc.start..t.loc.end];
+ }
+
+ fn tokenSlice(self: *@This(), t: Token) []const u8 {
+ return self.source[t.loc.start..t.loc.end];
+ }
+
+ pub fn parseProgram(self: *@This()) ParseError!Program {
+ var stmts: [2048]Stmt = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .eof) {
+ const item = try self.parseStatementListItem();
+ stmts[count] = item;
+ count += 1;
+ if (count >= stmts.len) return ParseError.TooManyTokens;
+ }
+
+ const body = stmts[0..count];
+ const loc: Loc = if (body.len > 0) .{ .start = body[0].loc.start, .end = body[body.len - 1].loc.end } else .{ .start = 0, .end = 0 };
+
+ return .{ .body = body, .loc = loc };
+ }
+
+ fn parseStatementListItem(self: *@This()) ParseError!Stmt {
+ switch (self.peek()) {
+ .function => return (try self.parseFunctionDecl(.normal, .stmt)).?,
+ .async => {
+ if (self.peekAt(1) == .function) {
+ return (try self.parseFunctionDecl(.async, .stmt)).?;
+ }
+ if (self.peekAt(1) == .@"*" and self.peekAt(2) == .function) {
+ return (try self.parseFunctionDecl(.async_generator, .stmt)).?;
+ }
+ return self.parseStatement();
+ },
+ .class => return (try self.parseClassDecl(.stmt)).?,
+ .@"const", .let => return self.parseLexicalDecl(),
+ .@"var" => return self.parseVarStmt(),
+ .using => return self.parseUsingStmt(),
+ .import => return try self.parseImport(),
+ .@"export" => return try self.parseExport(),
+ else => return self.parseStatement(),
+ }
+ }
+
+ fn parseStatement(self: *@This()) ParseError!Stmt {
+ switch (self.peek()) {
+ .lbrace => return self.parseBlock(),
+ .semicolon => {
+ const t = self.advanceTok();
+ return Stmt{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .data = .{ .empty = {} } };
+ },
+ .@"if" => return self.parseIf(),
+ .@"while" => return self.parseWhile(),
+ .do => return self.parseDoWhile(),
+ .@"for" => return self.parseFor(),
+ .@"continue" => return self.parseContinue(),
+ .@"break" => return self.parseBreak(),
+ .@"return" => return self.parseReturn(),
+ .@"switch" => return self.parseSwitch(),
+ .throw => return self.parseThrow(),
+ .@"try" => return self.parseTry(),
+ .debugger => {
+ const t = self.advanceTok();
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .data = .{ .debugger = {} } };
+ },
+ .with => return self.parseWith(),
+ .function => return (try self.parseFunctionDecl(.normal, .stmt)).?,
+ .async => {
+ if (self.peekAt(1) == .function) {
+ return (try self.parseFunctionDecl(.async, .stmt)).?;
+ }
+ if (self.peekAt(1) == .@"*") return self.parseExpressionStatement();
+ if (self.peekAt(1).isIdentifier()) {
+ return self.parseExpressionStatement();
+ }
+ return self.parseExpressionStatement();
+ },
+ .class => return (try self.parseClassDecl(.stmt)).?,
+ .@"const", .let => return self.parseLexicalDecl(),
+ .@"var" => return self.parseVarStmt(),
+ .import => return try self.parseImport(),
+ .@"export" => return try self.parseExport(),
+ else => return self.parseExpressionStatement(),
+ }
+ }
+
+ fn parseBlock(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var stmts: [1024]Stmt = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ stmts[count] = s;
+ count += 1;
+ if (count >= stmts.len) return ParseError.TooManyTokens;
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+ const end = end_tok.loc.end;
+
+ const block = Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .block = .{ .loc = .{ .start = start, .end = end }, .body = stmts[0..count] } },
+ };
+ return block;
+ }
+
+ fn parseIf(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const condition = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const consequent = try self.statementPointer();
+ var alternate: ?*const Stmt = null;
+ if (self.matchKeyword(.@"else")) {
+ alternate = try self.statementPointer();
+ }
+ const end = if (alternate) |a| a.loc.end else consequent.loc.end;
+ return Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .@"if" = .{ .loc = .{ .start = start, .end = end }, .condition = condition, .consequent = consequent, .alternate = alternate } },
+ };
+ }
+
+ fn parseWhile(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const condition = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .@"while" = .{ .loc = .{ .start = start, .end = body.loc.end }, .condition = condition, .body = body } },
+ };
+ }
+
+ fn parseDoWhile(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ const body = try self.statementPointer();
+ try self.expect(.@"while");
+ try self.expect(.lparen);
+ const condition = try self.parseExpr(0);
+ try self.expect(.rparen);
+ self.semicolon();
+ return Stmt{
+ .loc = .{ .start = start, .end = condition.loc.end },
+ .data = .{ .do_while = .{ .loc = .{ .start = start, .end = condition.loc.end }, .body = body, .condition = condition } },
+ };
+ }
+
+ fn parseFor(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+
+ var for_init: ?ForInit = null;
+ var condition: ?*const Expr = null;
+ var update: ?*const Expr = null;
+
+ if (self.peek() != .semicolon) {
+ if (self.peek() == .@"var" or self.peek() == .let or self.peek() == .@"const") {
+ const decl = try self.parseForDeclaration();
+ for_init = .{ .decl = decl };
+ } else {
+ const expr = try self.parseExpr(0);
+ for_init = .{ .expr = expr };
+ }
+ }
+
+ if (self.matchKeyword(.in)) {
+ const right = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .for_in = .{ .loc = .{ .start = start, .end = body.loc.end }, .left = for_init.?, .right = right, .body = body } },
+ };
+ }
+
+ if (self.matchKeyword(.of)) {
+ const right = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .for_of = .{ .loc = .{ .start = start, .end = body.loc.end }, .await_token = false, .left = for_init.?, .right = right, .body = body } },
+ };
+ }
+
+ try self.expect(.semicolon);
+ if (self.peek() != .semicolon and self.peek() != .rparen) {
+ condition = try self.parseExpr(0);
+ }
+ try self.expect(.semicolon);
+ if (self.peek() != .rparen) {
+ update = try self.parseExpr(0);
+ }
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .@"for" = .{ .loc = .{ .start = start, .end = body.loc.end }, .init = for_init, .condition = condition, .update = update, .body = body } },
+ };
+ }
+
+ fn parseForDeclaration(self: *@This()) ParseError!*const Decl {
+ const kind_tok = self.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try self.parseBindingPattern();
+ var decl_init: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ const kind: VarKind = switch (kind_tok.kind) {
+ .@"var" => .@"var",
+ .let => .let,
+ .@"const" => .@"const",
+ else => return ParseError.UnexpectedToken,
+ };
+
+ return self.arena.declPtr(.{ .@"var" = .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = kind, .decls = decls[0..count] } }, .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end });
+ }
+
+ fn parseContinue(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var label: ?[]const u8 = null;
+ if (self.peek() == .identifier and !self.isLineTerminatorBeforeNext()) {
+ const t = self.advanceTok();
+ label = self.tokenSlice(t);
+ }
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = start + 8 }, .data = .{ .@"continue" = .{ .loc = .{ .start = start, .end = start + 8 }, .label = label } } };
+ }
+
+ fn parseBreak(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var label: ?[]const u8 = null;
+ if (self.peek() == .identifier and !self.isLineTerminatorBeforeNext()) {
+ const t = self.advanceTok();
+ label = self.tokenSlice(t);
+ }
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = start + 5 }, .data = .{ .@"break" = .{ .loc = .{ .start = start, .end = start + 5 }, .label = label } } };
+ }
+
+ fn parseReturn(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var arg: ?*const Expr = null;
+ if (self.peek() != .semicolon and self.peek() != .rbrace and self.peek() != .eof and !self.isLineTerminatorBeforeNext()) {
+ arg = try self.parseExpr(0);
+ }
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = arg.?.loc.end }, .data = .{ .@"return" = .{ .loc = .{ .start = start, .end = if (arg) |a| a.loc.end else start + 6 }, .arg = arg } } };
+ }
+
+ fn parseSwitch(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const discriminant = try self.parseExpr(0);
+ try self.expect(.rparen);
+ try self.expect(.lbrace);
+
+ var cases: [256]SwitchCase = undefined;
+ var case_count: usize = 0;
+
+ while (self.peek() == .case or self.peek() == .default) {
+ const case_start = self.tok().loc.start;
+ if (self.matchKeyword(.case)) {
+ const case_test = try self.parseExpr(0);
+ try self.expect(.@":");
+ var consequent: [128]Stmt = undefined;
+ var cons_count: usize = 0;
+ while (self.peek() != .case and self.peek() != .default and self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ consequent[cons_count] = s;
+ cons_count += 1;
+ }
+ cases[case_count] = .{ .loc = .{ .start = case_start, .end = self.tok().loc.start }, .condition = case_test, .consequent = consequent[0..cons_count] };
+ case_count += 1;
+ } else if (self.matchKeyword(.default)) {
+ try self.expect(.@":");
+ var consequent: [128]Stmt = undefined;
+ var cons_count: usize = 0;
+ while (self.peek() != .case and self.peek() != .default and self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ consequent[cons_count] = s;
+ cons_count += 1;
+ }
+ cases[case_count] = .{ .loc = .{ .start = case_start, .end = self.tok().loc.start }, .condition = null, .consequent = consequent[0..cons_count] };
+ case_count += 1;
+ }
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+ return Stmt{
+ .loc = .{ .start = start, .end = end_tok.loc.end },
+ .data = .{ .@"switch" = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .discriminant = discriminant, .cases = cases[0..case_count] } },
+ };
+ }
+
+ fn parseThrow(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ if (self.isLineTerminatorBeforeNext()) return ParseError.ExpectedExpression;
+ const arg = try self.parseExpr(0);
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = arg.loc.end }, .data = .{ .throw = .{ .loc = .{ .start = start, .end = arg.loc.end }, .arg = arg } } };
+ }
+
+ fn parseTry(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ const block = try self.parseBlockStmt();
+ var handler: ?CatchClause = null;
+ var finalizer: ?BlockStmt = null;
+
+ if (self.matchKeyword(.@"catch")) {
+ var param: ?Pat = null;
+ if (self.match(.lparen)) {
+ const pat = try self.parseBindingPattern();
+ param = pat;
+ try self.expect(.rparen);
+ }
+ const catch_body = try self.parseBlockStmt();
+ handler = .{ .loc = .{ .start = block.loc.start, .end = catch_body.loc.end }, .param = param, .body = catch_body };
+ }
+
+ if (self.matchKeyword(.finally)) {
+ const finally_body = try self.parseBlockStmt();
+ finalizer = finally_body;
+ }
+
+ const end = if (finalizer) |f| f.loc.end else if (handler) |h| h.loc.end else block.loc.end;
+ return Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .@"try" = .{ .loc = .{ .start = start, .end = end }, .block = block, .handler = handler, .finalizer = finalizer } },
+ };
+ }
+
+ fn parseWith(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ try self.expect(.lparen);
+ const obj = try self.parseExpr(0);
+ try self.expect(.rparen);
+ const body = try self.statementPointer();
+ return Stmt{
+ .loc = .{ .start = start, .end = body.loc.end },
+ .data = .{ .with = .{ .loc = .{ .start = start, .end = body.loc.end }, .obj = obj, .body = body } },
+ };
+ }
+
+ fn parseBlockStmt(self: *@This()) ParseError!BlockStmt {
+ const start = try self.expectTok(.lbrace);
+ var stmts: [1024]Stmt = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const s = try self.parseStatementListItem();
+ stmts[count] = s;
+ count += 1;
+ if (count >= stmts.len) return ParseError.TooManyTokens;
+ }
+
+ const end = try self.expectTok(.rbrace);
+ return .{ .loc = .{ .start = start.loc.start, .end = end.loc.end }, .body = stmts[0..count] };
+ }
+
+ fn parseVarStmt(self: *@This()) ParseError!Stmt {
+ const kind_tok = self.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try self.parseBindingPattern();
+ var decl_init: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ self.semicolon();
+ const kind: VarKind = .@"var";
+ return Stmt{
+ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end },
+ .data = .{ .variable = .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = kind, .decls = decls[0..count] } },
+ };
+ }
+
+ fn parseLexicalDecl(self: *@This()) ParseError!Stmt {
+ const kind_tok = self.advanceTok();
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const pat = try self.parseBindingPattern();
+ var decl_init: ?*const Expr = null;
+ if (kind_tok.kind == .@"const") {
+ if (!self.match(.@"=")) return ParseError.ExpectedToken;
+ decl_init = try self.parseExpr(0);
+ } else if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = pat.loc, .id = pat, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ self.semicolon();
+ const kind: VarKind = switch (kind_tok.kind) {
+ .let => .let,
+ .@"const" => .@"const",
+ else => return ParseError.UnexpectedToken,
+ };
+ return Stmt{
+ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end },
+ .data = .{ .lexical = .{ .loc = .{ .start = kind_tok.loc.start, .end = decls[count - 1].loc.end }, .kind = kind, .decls = decls[0..count] } },
+ };
+ }
+
+ fn parseUsingStmt(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var decls: [128]VarDeclarator = undefined;
+ var count: usize = 0;
+
+ while (true) {
+ const id_tok = try self.expectTok(.identifier);
+ const id = self.tokenSlice(id_tok);
+ var decl_init: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ decl_init = try self.parseExpr(0);
+ }
+ decls[count] = .{ .loc = .{ .start = id_tok.loc.start, .end = if (decl_init) |e| e.loc.end else id_tok.loc.end }, .id = Pat{ .loc = .{ .start = id_tok.loc.start, .end = id_tok.loc.end }, .data = .{ .ident = id } }, .init = decl_init };
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+
+ self.semicolon();
+ return Stmt{
+ .loc = .{ .start = start, .end = decls[count - 1].loc.end },
+ .data = .{ .using = .{ .loc = .{ .start = start, .end = decls[count - 1].loc.end }, .decls = decls[0..count] } },
+ };
+ }
+
+ fn parseExpressionStatement(self: *@This()) ParseError!Stmt {
+ const expr = try self.parseExpr(0);
+ self.semicolon();
+ return Stmt{ .loc = expr.loc, .data = .{ .expr = .{ .loc = expr.loc, .expr = expr } } };
+ }
+
+ fn parseFunctionDecl(self: *@This(), fn_type_arg: FnType, mode: enum { stmt, expr }) ParseError!?Stmt {
+ const start = self.tok().loc.start;
+ var fn_type = fn_type_arg;
+
+ if (fn_type == .async) {
+ _ = self.advanceTok(); // async
+ } else if (fn_type == .async_generator) {
+ _ = self.advanceTok(); // async
+ _ = self.advanceTok(); // *
+ }
+
+ _ = self.advanceTok(); // function
+
+ if (fn_type == .normal and self.peek() == .@"*") {
+ self.advance();
+ fn_type = .generator;
+ }
+
+ var id: ?[]const u8 = null;
+ if (self.peek().isIdentifier()) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+
+ const end = body.loc.end;
+
+ if (mode == .stmt) {
+ return Stmt{
+ .loc = .{ .start = start, .end = end },
+ .data = .{ .function = .{ .loc = .{ .start = start, .end = end }, .fn_type = fn_type, .id = id, .params = params, .body = body } },
+ };
+ }
+ return null;
+ }
+
+ fn parseFnExpr(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+
+ var fn_type: FnType = .normal;
+ if (self.peek() == .@"*") {
+ fn_type = .generator;
+ self.advance();
+ }
+
+ var id: ?[]const u8 = null;
+ if (self.peek() == .identifier or self.peek().isKeywordButNotLet()) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+
+ return self.arena.exprPtr(
+ .{ .func = .{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = fn_type, .id = id, .params = params, .body = body } },
+ .{ .start = start, .end = body.loc.end },
+ );
+ }
+
+ fn parseParams(self: *@This()) ParseError![]const Pat {
+ try self.expect(.lparen);
+ var params: [128]Pat = undefined;
+ var count: usize = 0;
+
+ if (self.peek() != .rparen) {
+ while (true) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const pat = try self.parseBindingPattern();
+ params[count] = Pat{ .loc = pat.loc, .data = .{ .rest = .{ .loc = pat.loc, .arg = self.arena.patPtr(pat.data, pat.loc) } } };
+ count += 1;
+ break;
+ }
+ const pat = try self.parseBindingPattern();
+ if (self.match(.@"=")) {
+ const expr = try self.parseExpr(0);
+ params[count] = Pat{ .loc = .{ .start = pat.loc.start, .end = expr.loc.end }, .data = .{ .assign = .{ .loc = .{ .start = pat.loc.start, .end = expr.loc.end }, .left = self.arena.patPtr(pat.data, pat.loc), .right = expr } } };
+ } else {
+ params[count] = pat;
+ }
+ count += 1;
+ if (!self.match(.comma)) break;
+ if (self.peek() == .@"...") {
+ self.advance();
+ const rest_pat = try self.parseBindingPattern();
+ params[count] = Pat{ .loc = rest_pat.loc, .data = .{ .rest = .{ .loc = rest_pat.loc, .arg = self.arena.patPtr(rest_pat.data, rest_pat.loc) } } };
+ count += 1;
+ break;
+ }
+ }
+ }
+
+ try self.expect(.rparen);
+ return params[0..count];
+ }
+
+ fn parseFunctionBody(self: *@This()) ParseError!BlockStmt {
+ return self.parseBlockStmt();
+ }
+
+ fn parseClassDecl(self: *@This(), mode: enum { stmt, expr }) ParseError!?Stmt {
+ const start = self.advanceTok().loc.start;
+
+ var id: ?[]const u8 = null;
+ if (self.peek() == .identifier) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ var super_class: ?*const Expr = null;
+ if (self.matchKeyword(.extends)) {
+ super_class = try self.parseExpr(0);
+ }
+
+ try self.expect(.lbrace);
+ var elems: [128]ClassElem = undefined;
+ var elem_count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const elem = try self.parseClassElement();
+ elems[elem_count] = elem;
+ elem_count += 1;
+ if (elem_count >= elems.len) return ParseError.TooManyTokens;
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+
+ if (mode == .stmt) {
+ return Stmt{
+ .loc = .{ .start = start, .end = end_tok.loc.end },
+ .data = .{ .class = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .id = id, .super_class = super_class, .body = elems[0..elem_count] } },
+ };
+ }
+ return null;
+ }
+
+ fn parseClassExpr(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+
+ var id: ?[]const u8 = null;
+ if (self.peek() == .identifier) {
+ const id_tok = self.advanceTok();
+ id = self.tokenSlice(id_tok);
+ }
+
+ var super_class: ?*const Expr = null;
+ if (self.matchKeyword(.extends)) {
+ super_class = try self.parseExpr(0);
+ }
+
+ try self.expect(.lbrace);
+ var elems: [128]ClassElem = undefined;
+ var elem_count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const elem = try self.parseClassElement();
+ elems[elem_count] = elem;
+ elem_count += 1;
+ }
+
+ const end_tok = try self.expectTok(.rbrace);
+ return self.arena.exprPtr(
+ .{ .class = .{ .loc = .{ .start = start, .end = end_tok.loc.end }, .id = id, .super_class = super_class, .body = elems[0..elem_count] } },
+ .{ .start = start, .end = end_tok.loc.end },
+ );
+ }
+
+ fn parseClassElement(self: *@This()) ParseError!ClassElem {
+ const start = self.tok().loc.start;
+ const is_static = self.matchKeyword(.static);
+
+ if (is_static and self.peek() == .lbrace) {
+ const body = try self.parseBlockStmt();
+ return ClassElem{ .static_block = body };
+ }
+
+ if (self.matchKeyword(.get)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ if (is_static) return ClassElem{ .static_get = .{ .key = key, .body = body } };
+ return ClassElem{ .get = .{ .key = key, .body = body } };
+ }
+
+ if (self.matchKeyword(.set)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ const param = try self.parseBindingPattern();
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ if (is_static) return ClassElem{ .static_set = .{ .key = key, .param = param, .body = body } };
+ return ClassElem{ .set = .{ .key = key, .param = param, .body = body } };
+ }
+
+ if (self.match(.@"*")) {
+ _ = try self.parsePropKey();
+ try self.expect(.lparen);
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ const fn_expr = FnExpr{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .generator, .id = null, .params = params, .body = body };
+ if (is_static) return ClassElem{ .static_method = fn_expr };
+ return ClassElem{ .method = fn_expr };
+ }
+
+ const key = try self.parsePropKey();
+
+ if (self.peek() == .lparen) {
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ const fn_expr = FnExpr{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .normal, .id = null, .params = params, .body = body };
+ if (is_static) return ClassElem{ .static_method = fn_expr };
+ return ClassElem{ .method = fn_expr };
+ }
+
+ var value: ?*const Expr = null;
+ if (self.match(.@"=")) {
+ value = try self.parseExpr(0);
+ }
+ if (self.peek() == .semicolon) self.advance();
+
+ const field = FieldDef{ .loc = .{ .start = start, .end = if (value) |v| v.loc.end else self.tok().loc.start }, .key = key, .value = value };
+ if (is_static) return ClassElem{ .static_field = field };
+ return ClassElem{ .field = field };
+ }
+
+ fn parseImport(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+ var specifiers: [32]ImportSpecifier = undefined;
+ var spec_count: usize = 0;
+
+ if (self.peek() != .string and self.peek() != .lparen) {
+ if (self.peek() == .identifier or self.peek().isKeyword()) {
+ const local_tok = self.advanceTok();
+ const local = self.tokenSlice(local_tok);
+ specifiers[spec_count] = .{ .default = local };
+ spec_count += 1;
+ if (self.match(.comma)) {}
+ }
+
+ if (self.match(.@"*")) {
+ try self.expect(.identifier); // as
+ const ns_tok = try self.expectTok(.identifier);
+ const ns = self.tokenSlice(ns_tok);
+ specifiers[spec_count] = .{ .namespace = ns };
+ spec_count += 1;
+ } else if (self.peek() == .lbrace) {
+ self.advance();
+ if (self.peek() != .rbrace) {
+ while (true) {
+ const imported_tok = try self.expectTok(.identifier);
+ const imported = self.tokenSlice(imported_tok);
+ var local = imported;
+ if (self.match(.identifier)) {
+ local = self.tokenSlice(self.tokens[self.pos - 1]);
+ }
+ specifiers[spec_count] = .{ .named = .{ .imported = imported, .local = local } };
+ spec_count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+ try self.expect(.rbrace);
+ }
+ }
+
+ var source: []const u8 = "";
+ var attrs: [8]ImportAttribute = undefined;
+ var attr_count: usize = 0;
+
+ if (self.matchKeyword(.from)) {
+ const str_tok = try self.expectTok(.string);
+ source = self.tokenSlice(str_tok);
+ } else if (self.peek() == .string) {
+ const str_tok = self.advanceTok();
+ source = self.tokenSlice(str_tok);
+ }
+
+ if (self.matchKeyword(.with)) {
+ try self.expect(.lbrace);
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ const key_tok = self.advanceTok();
+ const key = self.tokenSlice(key_tok);
+ try self.expect(.@":");
+ const val_tok = try self.expectTok(.string);
+ const val = self.tokenSlice(val_tok);
+ attrs[attr_count] = .{ .key = key, .value = val };
+ attr_count += 1;
+ _ = self.match(.comma);
+ }
+ try self.expect(.rbrace);
+ }
+
+ try self.expect(.semicolon);
+ return Stmt{
+ .loc = .{ .start = start, .end = self.tok().loc.start },
+ .data = .{ .import = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .specifiers = specifiers[0..spec_count], .source = source, .attributes = attrs[0..attr_count] } },
+ };
+ }
+
+ fn parseExport(self: *@This()) ParseError!Stmt {
+ const start = self.advanceTok().loc.start;
+
+ if (self.matchKeyword(.default)) {
+ if (self.peek() == .function or self.peek() == .async or self.peek() == .class) {
+ const decl = try self.parseStatementListItem();
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = decl.loc.end }, .data = decl.data };
+ }
+ const expr = try self.parseExpr(0);
+ self.semicolon();
+ return Stmt{ .loc = .{ .start = start, .end = expr.loc.end }, .data = .{ .expr = .{ .loc = expr.loc, .expr = expr } } };
+ }
+
+ if (self.peek() == .@"*") {
+ self.advance();
+ try self.expect(.identifier); // from
+ const source_tok = try self.expectTok(.string);
+ _ = self.tokenSlice(source_tok);
+ try self.expect(.semicolon);
+ return Stmt{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .empty = {} } };
+ }
+
+ if (self.peek() == .lbrace) {
+ self.advance();
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ _ = self.advanceTok();
+ _ = self.match(.identifier); // as
+ if (!self.match(.comma)) break;
+ }
+ try self.expect(.rbrace);
+ if (self.matchKeyword(.from)) {
+ _ = self.advanceTok();
+ }
+ try self.expect(.semicolon);
+ return Stmt{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .empty = {} } };
+ }
+
+ const decl = try self.parseStatementListItem();
+ self.semicolon();
+ return decl;
+ }
+
+ fn parseExpr(self: *@This(), min_bp: u32) ParseError!*const Expr {
+ var left = try self.parsePrimaryExpr();
+
+ while (true) {
+ const cur_bp = self.bp(self.peek());
+ if (cur_bp <= min_bp) break;
+
+ switch (self.peek()) {
+ .@"=",
+ .@"+=",
+ .@"-=",
+ .@"*=",
+ .@"/=",
+ .@"%=",
+ .@"**=",
+ .@"<<=",
+ .@">>=",
+ .@">>>=",
+ .@"&=",
+ .@"|=",
+ .@"^=",
+ .@"&&=",
+ .@"||=",
+ .@"??=",
+ => {
+ self.advance();
+ const op = self.assignOpFromToken();
+ const right = try self.parseExpr(BP.assign);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .assign = .{ .loc = loc, .op = op, .left = left, .right = right } }, loc);
+ },
+
+ .@"?" => {
+ self.advance();
+ const consequent = try self.parseExpr(0);
+ try self.expect(.@":");
+ const alternate = try self.parseExpr(BP.conditional);
+ const loc: Loc = .{ .start = left.loc.start, .end = alternate.loc.end };
+ left = self.arena.exprPtr(.{ .conditional = .{ .loc = loc, .condition = left, .consequent = consequent, .alternate = alternate } }, loc);
+ },
+
+ .@"??" => {
+ self.advance();
+ const right = try self.parseExpr(BP.coalesce);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"??", .left = left, .right = right } }, loc);
+ },
+
+ .@"||" => {
+ self.advance();
+ const right = try self.parseExpr(BP.log_or);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"||", .left = left, .right = right } }, loc);
+ },
+
+ .@"&&" => {
+ self.advance();
+ const right = try self.parseExpr(BP.log_and);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"&&", .left = left, .right = right } }, loc);
+ },
+
+ .@"|" => {
+ self.advance();
+ const right = try self.parseExpr(BP.bit_or);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"|", .left = left, .right = right } }, loc);
+ },
+
+ .@"^" => {
+ self.advance();
+ const right = try self.parseExpr(BP.bit_xor);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"^", .left = left, .right = right } }, loc);
+ },
+
+ .@"&" => {
+ self.advance();
+ const right = try self.parseExpr(BP.bit_and);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"&", .left = left, .right = right } }, loc);
+ },
+
+ .@"==" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"==", .left = left, .right = right } }, loc);
+ },
+
+ .@"!=" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"!=", .left = left, .right = right } }, loc);
+ },
+
+ .@"===" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"===", .left = left, .right = right } }, loc);
+ },
+
+ .@"!==" => {
+ self.advance();
+ const right = try self.parseExpr(BP.equality);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"!==", .left = left, .right = right } }, loc);
+ },
+
+ .@"<" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"<", .left = left, .right = right } }, loc);
+ },
+
+ .@">" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">", .left = left, .right = right } }, loc);
+ },
+
+ .@"<=" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"<=", .left = left, .right = right } }, loc);
+ },
+
+ .@">=" => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">=", .left = left, .right = right } }, loc);
+ },
+
+ .in => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .in, .left = left, .right = right } }, loc);
+ },
+
+ .instanceof => {
+ self.advance();
+ const right = try self.parseExpr(BP.relational);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .instanceof, .left = left, .right = right } }, loc);
+ },
+
+ .@"<<" => {
+ self.advance();
+ const right = try self.parseExpr(BP.shift);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"<<", .left = left, .right = right } }, loc);
+ },
+
+ .@">>" => {
+ self.advance();
+ const right = try self.parseExpr(BP.shift);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">>", .left = left, .right = right } }, loc);
+ },
+
+ .@">>>" => {
+ self.advance();
+ const right = try self.parseExpr(BP.shift);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@">>>", .left = left, .right = right } }, loc);
+ },
+
+ .@"+" => {
+ self.advance();
+ const right = try self.parseExpr(BP.additive);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"+", .left = left, .right = right } }, loc);
+ },
+
+ .@"-" => {
+ self.advance();
+ const right = try self.parseExpr(BP.additive);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"-", .left = left, .right = right } }, loc);
+ },
+
+ .@"*" => {
+ self.advance();
+ const right = try self.parseExpr(BP.multiplicative);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"*", .left = left, .right = right } }, loc);
+ },
+
+ .@"/" => {
+ self.advance();
+ const right = try self.parseExpr(BP.multiplicative);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"/", .left = left, .right = right } }, loc);
+ },
+
+ .@"%" => {
+ self.advance();
+ const right = try self.parseExpr(BP.multiplicative);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"%", .left = left, .right = right } }, loc);
+ },
+
+ .@"**" => {
+ self.advance();
+ const right = try self.parseExpr(BP.exponentiation - 1);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ left = self.arena.exprPtr(.{ .binary = .{ .loc = loc, .op = .@"**", .left = left, .right = right } }, loc);
+ },
+
+ .lparen => {
+ self.advance();
+ var args: [256]Expr = undefined;
+ var arg_count: usize = 0;
+
+ if (self.peek() != .rparen) {
+ while (true) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ args[arg_count] = Expr{ .loc = arg.loc, .data = .{ .spread = .{ .loc = arg.loc, .arg = self.arena.exprPtr(arg.data, arg.loc) } } };
+ arg_count += 1;
+ } else {
+ const arg = try self.parseExpr(0);
+ args[arg_count] = arg.*;
+ arg_count += 1;
+ }
+ if (!self.match(.comma)) break;
+ }
+ }
+
+ try self.expect(.rparen);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .call = .{ .loc = loc, .callee = left, .args = args[0..arg_count], .optional = false } }, loc);
+ },
+
+ .@"?." => {
+ self.advance();
+ if (self.peek() == .lparen) {
+ self.advance();
+ var args: [256]Expr = undefined;
+ var arg_count: usize = 0;
+ if (self.peek() != .rparen) {
+ while (true) {
+ const arg = try self.parseExpr(0);
+ args[arg_count] = arg.*;
+ arg_count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+ try self.expect(.rparen);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .call = .{ .loc = loc, .callee = left, .args = args[0..arg_count], .optional = true } }, loc);
+ } else if (self.peek() == .lbracket) {
+ self.advance();
+ const expr = try self.parseExpr(0);
+ try self.expect(.rbracket);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .computed_member = .{ .loc = loc, .obj = left, .expr = expr } }, loc);
+ } else if (self.peek() == .identifier or self.peek().isKeyword()) {
+ const prop_tok = self.advanceTok();
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .ident = prop } } }, loc);
+ } else if (self.peek() == .private_identifier) {
+ const prop_tok = self.advanceTok();
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .private = prop } } }, loc);
+ }
+ },
+
+ .lbracket => {
+ self.advance();
+ const expr = try self.parseExpr(0);
+ try self.expect(.rbracket);
+ const loc: Loc = .{ .start = left.loc.start, .end = self.tok().loc.start };
+ left = self.arena.exprPtr(.{ .computed_member = .{ .loc = loc, .obj = left, .expr = expr } }, loc);
+ },
+
+ .@"." => {
+ self.advance();
+ if (self.peek() == .private_identifier) {
+ const prop_tok = self.advanceTok();
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .private = prop } } }, loc);
+ } else {
+ const prop_tok = try self.expectTok(.identifier);
+ const prop = self.tokenSlice(prop_tok);
+ const loc: Loc = .{ .start = left.loc.start, .end = prop_tok.loc.end };
+ left = self.arena.exprPtr(.{ .member = .{ .loc = loc, .obj = left, .prop = .{ .ident = prop } } }, loc);
+ }
+ },
+
+ .template_head, .no_sub_template => {
+ const template = try self.parseTemplateLit();
+ const loc: Loc = .{ .start = left.loc.start, .end = template.loc.end };
+ left = self.arena.exprPtr(.{ .tagged_template = .{ .loc = loc, .tag = left, .quasi = template } }, loc);
+ },
+
+ .@"++" => {
+ if (!self.isLineTerminatorBeforeNext()) {
+ self.advance();
+ const loc: Loc = .{ .start = left.loc.start, .end = left.loc.end + 2 };
+ left = self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"++", .arg = left, .prefix = false } }, loc);
+ } else break;
+ },
+
+ .@"--" => {
+ if (!self.isLineTerminatorBeforeNext()) {
+ self.advance();
+ const loc: Loc = .{ .start = left.loc.start, .end = left.loc.end + 2 };
+ left = self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"--", .arg = left, .prefix = false } }, loc);
+ } else break;
+ },
+
+ .comma => {
+ self.advance();
+ const right = try self.parseExpr(BP.comma);
+ const loc: Loc = .{ .start = left.loc.start, .end = right.loc.end };
+ var exprs: [2]Expr = .{ left.*, right.* };
+ left = self.arena.exprPtr(.{ .sequence = .{ .loc = loc, .exprs = &exprs } }, loc);
+ },
+
+ else => break,
+ }
+ }
+
+ return left;
+ }
+
+ fn parsePrimaryExpr(self: *@This()) ParseError!*const Expr {
+ const start = self.tok().loc.start;
+
+ switch (self.peek()) {
+ .this => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .this = {} }, .{ .start = start, .end = t.loc.end });
+ },
+ .super => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .super = {} }, .{ .start = start, .end = t.loc.end });
+ },
+ .null => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .null = {} }, .{ .start = start, .end = t.loc.end });
+ },
+ .true => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .bool = true }, .{ .start = start, .end = t.loc.end });
+ },
+ .false => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .bool = false }, .{ .start = start, .end = t.loc.end });
+ },
+ .number => {
+ const t = self.advanceTok();
+ const val = std.fmt.parseFloat(f64, self.tokenSlice(t)) catch 0.0;
+ return self.arena.exprPtr(.{ .number = val }, .{ .start = start, .end = t.loc.end });
+ },
+ .string => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .string = self.tokenSlice(t) }, .{ .start = start, .end = t.loc.end });
+ },
+ .bigint => {
+ const t = self.advanceTok();
+ return self.arena.exprPtr(.{ .number = 0 }, .{ .start = start, .end = t.loc.end });
+ },
+ .regex => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ const slash_pos = std.mem.indexOfScalar(u8, slice[1..], '/') orelse 0;
+ const pattern = slice[1 .. slash_pos + 1];
+ const flags = slice[slash_pos + 2 ..];
+ return self.arena.exprPtr(
+ .{ .regex = .{ .pattern = pattern, .flags = flags } },
+ .{ .start = start, .end = t.loc.end },
+ );
+ },
+ .identifier => {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ return self.arena.exprPtr(.{ .identifier = name }, .{ .start = start, .end = t.loc.end });
+ },
+ .private_identifier => {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ return self.arena.exprPtr(.{ .private_ident = name }, .{ .start = start, .end = t.loc.end });
+ },
+ .lbrace => return self.parseObjLiteral(),
+ .lbracket => return self.parseArrayLiteral(),
+ .lparen => {
+ self.advance();
+ if (self.peek() == .rparen) {
+ self.advance();
+ if (self.peek() == .@"=>") {
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = self.tok().loc.start }, .params = &.{} });
+ }
+ return self.arena.exprPtr(.{ .identifier = "" }, .{ .start = start, .end = self.tok().loc.start });
+ }
+ if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ try self.expect(.rparen);
+ if (self.peek() == .@"=>") {
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = arg.loc.end }, .params = &.{} });
+ }
+ const loc: Loc = .{ .start = start, .end = self.tok().loc.start };
+ return self.arena.exprPtr(.{ .spread = .{ .loc = loc, .arg = arg } }, loc);
+ }
+ const expr = try self.parseExpr(0);
+ if (self.peek() == .comma) {
+ var params: [128]Pat = undefined;
+ var count: usize = 0;
+ params[count] = Pat{ .loc = expr.loc, .data = .{ .ident = expr.data.identifier } };
+ count += 1;
+ while (self.match(.comma)) {
+ const p = try self.parseBindingPattern();
+ params[count] = p;
+ count += 1;
+ }
+ try self.expect(.rparen);
+ if (self.peek() == .@"=>") {
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = self.tok().loc.start }, .params = params[0..count] });
+ }
+ return self.arena.exprPtr(.{ .identifier = "" }, .{ .start = start, .end = self.tok().loc.start });
+ }
+ try self.expect(.rparen);
+ if (self.peek() == .@"=>") {
+ const pat = Pat{ .loc = expr.loc, .data = .{ .ident = expr.data.identifier } };
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = self.tok().loc.start }, .params = &.{pat} });
+ }
+ return self.arena.exprPtr(.{ .parenthesized = expr }, .{ .start = start, .end = self.tok().loc.start });
+ },
+ .function => return self.parseFnExpr(),
+ .class => return self.parseClassExpr(),
+ .async => {
+ self.advance();
+ if (self.peek() == .function) {
+ return self.parseFnExpr();
+ }
+ const id_tok = try self.expectTok(.identifier);
+ const name = self.tokenSlice(id_tok);
+ if (self.peek() == .@"=>") {
+ const pat = Pat{ .loc = .{ .start = start, .end = id_tok.loc.end }, .data = .{ .ident = name } };
+ return self.parseArrowExpr(.{ .loc = .{ .start = start, .end = id_tok.loc.end }, .params = &.{pat} });
+ }
+ return self.arena.exprPtr(.{ .identifier = name }, .{ .start = start, .end = id_tok.loc.end });
+ },
+ .new => {
+ self.advance();
+ const callee = try self.parseExpr(BP.member);
+ var args: [256]Expr = undefined;
+ var arg_count: usize = 0;
+ if (self.peek() == .lparen) {
+ self.advance();
+ if (self.peek() != .rparen) {
+ while (true) {
+ const arg = try self.parseExpr(0);
+ args[arg_count] = arg.*;
+ arg_count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+ try self.expect(.rparen);
+ }
+ const loc: Loc = .{ .start = start, .end = if (arg_count > 0) args[arg_count - 1].loc.end else callee.loc.end };
+ return self.arena.exprPtr(.{ .new = .{ .loc = loc, .callee = callee, .args = args[0..arg_count] } }, loc);
+ },
+ .delete, .typeof, .void, .@"!", .@"~", .@"+", .@"-" => {
+ const op = self.unaryOpFromToken();
+ self.advance();
+ const arg = try self.parseExpr(BP.unary);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .unary = .{ .loc = loc, .op = op, .arg = arg, .prefix = true } }, loc);
+ },
+ .@"++" => {
+ self.advance();
+ const arg = try self.parseExpr(BP.update);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"++", .arg = arg, .prefix = true } }, loc);
+ },
+ .@"--" => {
+ self.advance();
+ const arg = try self.parseExpr(BP.update);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .update = .{ .loc = loc, .op = .@"--", .arg = arg, .prefix = true } }, loc);
+ },
+ .await => {
+ self.advance();
+ const arg = try self.parseExpr(BP.unary);
+ const loc: Loc = .{ .start = start, .end = arg.loc.end };
+ return self.arena.exprPtr(.{ .await = .{ .loc = loc, .arg = arg } }, loc);
+ },
+ .yield => {
+ self.advance();
+ var delegate = false;
+ var arg: ?*const Expr = null;
+ if (!self.isLineTerminatorBeforeNext()) {
+ if (self.match(.@"*")) {
+ delegate = true;
+ }
+ if (self.peek() != .rbrace and self.peek() != .rparen and self.peek() != .rbracket and self.peek() != .semicolon and self.peek() != .comma and self.peek() != .@":" and self.peek() != .eof) {
+ arg = try self.parseExpr(0);
+ }
+ }
+ const loc: Loc = .{ .start = start, .end = if (arg) |a| a.loc.end else start + 5 };
+ return self.arena.exprPtr(.{ .yield = .{ .loc = loc, .arg = arg, .delegate = delegate } }, loc);
+ },
+ .template_head, .no_sub_template => return self.arena.exprPtr(.{ .template = try self.parseTemplateLit() }, .{ .start = start, .end = self.tok().loc.start }),
+ .import => {
+ self.advance();
+ try self.expect(.lparen);
+ _ = try self.parseExpr(0);
+ try self.expect(.rparen);
+ return self.arena.exprPtr(.{ .identifier = "import" }, .{ .start = start, .end = self.tok().loc.start });
+ },
+ .@"#" => {
+ self.advance();
+ const id_tok = try self.expectTok(.identifier);
+ return self.arena.exprPtr(.{ .private_ident = self.tokenSlice(id_tok) }, .{ .start = start, .end = id_tok.loc.end });
+ },
+ else => {
+ if (self.peek().isIdentifier()) {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ if (self.peek() == .@"=>") {
+ const pat = Pat{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .data = .{ .ident = name } };
+ return self.parseArrowExpr(.{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .params = &.{pat} });
+ }
+ return self.arena.exprPtr(.{ .identifier = name }, .{ .start = t.loc.start, .end = t.loc.end });
+ }
+ return ParseError.ExpectedExpression;
+ },
+ }
+ }
+
+ fn parseArrowExpr(self: *@This(), params_info: struct { loc: Loc, params: []const Pat }) ParseError!*const Expr {
+ try self.expect(.@"=>");
+ const async_token = false;
+
+ if (self.peek() == .lbrace) {
+ const body = try self.parseFunctionBody();
+ return self.arena.exprPtr(
+ .{ .arrow = .{ .loc = .{ .start = params_info.loc.start, .end = body.loc.end }, .async_token = async_token, .params = params_info.params, .body = .{ .block = body } } },
+ .{ .start = params_info.loc.start, .end = body.loc.end },
+ );
+ }
+
+ const expr = try self.parseExpr(0);
+ return self.arena.exprPtr(
+ .{ .arrow = .{ .loc = .{ .start = params_info.loc.start, .end = expr.loc.end }, .async_token = async_token, .params = params_info.params, .body = .{ .expr = expr } } },
+ .{ .start = params_info.loc.start, .end = expr.loc.end },
+ );
+ }
+
+ fn parseObjLiteral(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+ var props: [128]Prop = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ props[count] = .{ .loc = arg.loc, .key = .{ .ident = "" }, .data = .{ .spread = .{ .loc = arg.loc, .arg = arg } } };
+ count += 1;
+ } else if (self.peek() == .identifier) {
+ const name_tok = self.tok();
+ const name = self.tokenSlice(name_tok);
+ self.advance();
+ if (self.peek() == .@":") {
+ self.advance();
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = value.loc.end }, .key = .{ .ident = name }, .data = .{ .init = .{ .key = .{ .ident = name }, .value = value } } };
+ count += 1;
+ } else if (self.peek() == .lparen) {
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = body.loc.end }, .key = .{ .ident = name }, .data = .{ .method = .{ .loc = .{ .start = name_tok.loc.start, .end = body.loc.end }, .fn_type = .normal, .id = null, .params = params, .body = body } } };
+ count += 1;
+ } else if (self.peek() == .@"=") {
+ self.advance();
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = value.loc.end }, .key = .{ .ident = name }, .data = .{ .init = .{ .key = .{ .ident = name }, .value = value } } };
+ count += 1;
+ } else if (self.peek() == .comma or self.peek() == .rbrace) {
+ props[count] = .{ .loc = .{ .start = name_tok.loc.start, .end = name_tok.loc.end }, .key = .{ .ident = name }, .data = .{ .shorthand = name } };
+ count += 1;
+ }
+ } else if (self.peek() == .number or self.peek() == .string) {
+ const key = try self.parsePropKey();
+ try self.expect(.@":");
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = start, .end = value.loc.end }, .key = key, .data = .{ .init = .{ .key = key, .value = value } } };
+ count += 1;
+ } else if (self.peek() == .lbracket) {
+ const key = try self.parsePropKey();
+ try self.expect(.@":");
+ const value = try self.parseExpr(0);
+ props[count] = .{ .loc = .{ .start = start, .end = value.loc.end }, .key = key, .data = .{ .init = .{ .key = key, .value = value } } };
+ count += 1;
+ } else if (self.matchKeyword(.get)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .get = .{ .key = key, .body = body } } };
+ count += 1;
+ } else if (self.matchKeyword(.set)) {
+ const key = try self.parsePropKey();
+ try self.expect(.lparen);
+ const param = try self.parseBindingPattern();
+ try self.expect(.rparen);
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .set = .{ .key = key, .param = param, .body = body } } };
+ count += 1;
+ } else if (self.match(.@"*")) {
+ const key = try self.parsePropKey();
+ const params = try self.parseParams();
+ const body = try self.parseFunctionBody();
+ props[count] = .{ .loc = .{ .start = start, .end = body.loc.end }, .key = key, .data = .{ .method = .{ .loc = .{ .start = start, .end = body.loc.end }, .fn_type = .generator, .id = null, .params = params, .body = body } } };
+ count += 1;
+ } else {
+ break;
+ }
+
+ if (!self.match(.comma)) break;
+ }
+
+ try self.expect(.rbrace);
+ return self.arena.exprPtr(.{ .object = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .props = props[0..count] } }, .{ .start = start, .end = self.tok().loc.start });
+ }
+
+ fn parseArrayLiteral(self: *@This()) ParseError!*const Expr {
+ const start = self.advanceTok().loc.start;
+ var elems: [256]?Expr = undefined;
+ var count: usize = 0;
+
+ while (self.peek() != .rbracket and self.peek() != .eof) {
+ if (self.match(.comma)) {
+ elems[count] = null;
+ count += 1;
+ } else if (self.peek() == .@"...") {
+ self.advance();
+ const arg = try self.parseExpr(0);
+ elems[count] = Expr{ .loc = arg.loc, .data = .{ .spread = .{ .loc = arg.loc, .arg = arg } } };
+ count += 1;
+ if (!self.match(.comma)) break;
+ } else {
+ const expr = try self.parseExpr(0);
+ elems[count] = expr.*;
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+
+ try self.expect(.rbracket);
+ return self.arena.exprPtr(.{ .array = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .elems = elems[0..count] } }, .{ .start = start, .end = self.tok().loc.start });
+ }
+
+ fn parseTemplateLit(self: *@This()) ParseError!TemplateLit {
+ const start = self.tok().loc.start;
+ var quasis: [64]TemplateElem = undefined;
+ var exprs: [64]Expr = undefined;
+ var q_count: usize = 0;
+ var e_count: usize = 0;
+
+ while (true) {
+ switch (self.peek()) {
+ .no_sub_template => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = true };
+ q_count += 1;
+ break;
+ },
+ .template_head => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = false };
+ q_count += 1;
+ const expr = try self.parseExpr(0);
+ exprs[e_count] = expr.*;
+ e_count += 1;
+ try self.expect(.rbrace);
+ },
+ .template_middle => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = false };
+ q_count += 1;
+ const expr = try self.parseExpr(0);
+ exprs[e_count] = expr.*;
+ e_count += 1;
+ try self.expect(.rbrace);
+ },
+ .template_tail => {
+ const t = self.advanceTok();
+ const slice = self.tokenSlice(t);
+ quasis[q_count] = .{ .loc = .{ .start = t.loc.start, .end = t.loc.end }, .value = slice, .tail = true };
+ q_count += 1;
+ break;
+ },
+ else => break,
+ }
+ }
+
+ return .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .quasis = quasis[0..q_count], .exprs = exprs[0..e_count] };
+ }
+
+ fn parsePropKey(self: *@This()) ParseError!PropKey {
+ switch (self.peek()) {
+ .identifier, .let, .static, .get, .set, .async => {
+ const t = self.advanceTok();
+ return PropKey{ .ident = self.tokenSlice(t) };
+ },
+ .string => {
+ const t = self.advanceTok();
+ return PropKey{ .string = self.tokenSlice(t) };
+ },
+ .number => {
+ const t = self.advanceTok();
+ const val = std.fmt.parseFloat(f64, self.tokenSlice(t)) catch 0.0;
+ return PropKey{ .number = val };
+ },
+ .lbracket => {
+ self.advance();
+ const expr = try self.parseExpr(0);
+ try self.expect(.rbracket);
+ return PropKey{ .computed = expr };
+ },
+ .private_identifier => {
+ const t = self.advanceTok();
+ return PropKey{ .private = self.tokenSlice(t) };
+ },
+ else => return ParseError.ExpectedPropertyName,
+ }
+ }
+
+ fn parseBindingPattern(self: *@This()) ParseError!Pat {
+ const start = self.tok().loc.start;
+
+ switch (self.peek()) {
+ .identifier, .await, .yield => {
+ const t = self.advanceTok();
+ const name = self.tokenSlice(t);
+ return Pat{ .loc = .{ .start = start, .end = t.loc.end }, .data = .{ .ident = name } };
+ },
+ .lbrace => {
+ self.advance();
+ var props: [128]PatProp = undefined;
+ var count: usize = 0;
+ var rest: ?*const Pat = null;
+
+ while (self.peek() != .rbrace and self.peek() != .eof) {
+ if (self.peek() == .@"...") {
+ self.advance();
+ const pat = try self.parseBindingPattern();
+ rest = self.arena.patPtr(pat.data, pat.loc);
+ break;
+ }
+ if (self.peek() == .identifier) {
+ const name_tok = self.tok();
+ const name = self.tokenSlice(name_tok);
+ self.advance();
+ if (self.peek() == .@":") {
+ self.advance();
+ const val_pat = try self.parseBindingPattern();
+ props[count] = .{ .key_value = .{ .key = .{ .ident = name }, .value = self.arena.patPtr(val_pat.data, val_pat.loc) } };
+ count += 1;
+ } else {
+ props[count] = .{ .shorthand = name };
+ count += 1;
+ }
+ } else if (self.peek() == .lbracket) {
+ const key = try self.parsePropKey();
+ try self.expect(.@":");
+ const val_pat = try self.parseBindingPattern();
+ props[count] = .{ .key_value = .{ .key = key, .value = self.arena.patPtr(val_pat.data, val_pat.loc) } };
+ count += 1;
+ } else {
+ break;
+ }
+ if (!self.match(.comma)) break;
+ }
+
+ try self.expect(.rbrace);
+ return Pat{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .object = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .props = props[0..count], .rest = rest } } };
+ },
+ .lbracket => {
+ self.advance();
+ var elems: [128]?Pat = undefined;
+ var count: usize = 0;
+ var rest: ?*const Pat = null;
+
+ while (self.peek() != .rbracket and self.peek() != .eof) {
+ if (self.match(.comma)) {
+ elems[count] = null;
+ count += 1;
+ } else if (self.peek() == .@"...") {
+ self.advance();
+ const pat = try self.parseBindingPattern();
+ rest = self.arena.patPtr(pat.data, pat.loc);
+ break;
+ } else {
+ const pat = try self.parseBindingPattern();
+ elems[count] = pat;
+ count += 1;
+ if (!self.match(.comma)) break;
+ }
+ }
+
+ try self.expect(.rbracket);
+ return Pat{ .loc = .{ .start = start, .end = self.tok().loc.start }, .data = .{ .array = .{ .loc = .{ .start = start, .end = self.tok().loc.start }, .elems = elems[0..count], .rest = rest } } };
+ },
+ else => return ParseError.ExpectedParameterName,
+ }
+ }
+
+ fn bp(_: *@This(), kind: TokenType) u32 {
+ return switch (kind) {
+ .comma => BP.comma,
+ .@"=", .@"+=", .@"-=", .@"*=", .@"/=", .@"%=", .@"**=", .@"<<=", .@">>=", .@">>>=", .@"&=", .@"|=", .@"^=", .@"&&=", .@"||=", .@"??=" => BP.assign,
+ .@"?" => BP.conditional,
+ .@"??" => BP.coalesce,
+ .@"||" => BP.log_or,
+ .@"&&" => BP.log_and,
+ .@"|" => BP.bit_or,
+ .@"^" => BP.bit_xor,
+ .@"&" => BP.bit_and,
+ .@"==", .@"!=", .@"===", .@"!==" => BP.equality,
+ .@"<", .@">", .@"<=", .@">=", .in, .instanceof => BP.relational,
+ .@"<<", .@">>", .@">>>" => BP.shift,
+ .@"+", .@"-" => BP.additive,
+ .@"*", .@"/", .@"%" => BP.multiplicative,
+ .@"**" => BP.exponentiation,
+ .lparen => BP.call,
+ .lbracket, .@".", .@"?." => BP.member,
+ .@"++", .@"--" => BP.update,
+ .template_head, .no_sub_template => BP.member,
+ else => 0,
+ };
+ }
+
+ fn unaryOpFromToken(self: *@This()) UnaryOp {
+ return switch (self.tok().kind) {
+ .@"+" => .@"+",
+ .@"-" => .@"-",
+ .@"!" => .@"!",
+ .@"~" => .@"~",
+ .typeof => .typeof,
+ .void => .void,
+ .delete => .delete,
+ else => .@"+",
+ };
+ }
+
+ fn assignOpFromToken(self: *@This()) AssignOp {
+ return switch (self.tokens[self.pos - 1].kind) {
+ .@"=" => .@"=",
+ .@"+=" => .@"+=",
+ .@"-=" => .@"-=",
+ .@"*=" => .@"*=",
+ .@"/=" => .@"/=",
+ .@"%=" => .@"%=",
+ .@"**=" => .@"**=",
+ .@"<<=" => .@"<<=",
+ .@">>=" => .@">>=",
+ .@">>>=" => .@">>>=",
+ .@"&=" => .@"&=",
+ .@"|=" => .@"|=",
+ .@"^=" => .@"^=",
+ .@"&&=" => .@"&&=",
+ .@"||=" => .@"||=",
+ .@"??=" => .@"??=",
+ else => .@"=",
+ };
+ }
+
+ fn semicolon(self: *@This()) void {
+ if (self.peek() == .semicolon) {
+ self.advance();
+ }
+ }
+
+ fn statementPointer(self: *@This()) ParseError!*const Stmt {
+ const s = try self.parseStatement();
+ return self.arena.stmtPtr(s.data, s.loc);
+ }
+};
+
+pub const Node = union(enum) {
+ program: Program,
+
+ stmt: Stmt,
+ expr: Expr,
+ pat: Pat,
+
+ decl: Decl,
+ literal: Lit,
+ property: Prop,
+ template: TemplateLit,
+ spread: SpreadElem,
+ decorator: Decorator,
+
+ import_specifier: ImportSpecifier,
+ export_specifier: ExportSpecifier,
+ import_attr: ImportAttribute,
+ catch_clause: CatchClause,
+ switch_case: SwitchCase,
+};
+
+pub const Program = struct {
+ body: []const Stmt,
+ loc: Loc,
+
+ pub fn parse(comptime source: []const u8) ParseError!Program {
+ return comptime blk: {
+ var token_buf: [4096]Token = undefined;
+ const tokens = lex.Lexer.tokenizeBuf(source, &token_buf);
+ var arena: NodeArena = .{};
+ var parser = Parser.init(tokens, source, &arena);
+ break :blk try parser.parseProgram();
+ };
+ }
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ @setEvalBranchQuota(100000);
+ for (self.body, 0..) |stmt, i| {
+ if (i > 0) f.newline();
+ stmt.fmt(f);
+ }
+ }
+};
+
+pub const StmtType = union(enum) {
+ block: BlockStmt,
+ empty: void,
+ debugger: void,
+ expr: ExprStmt,
+ @"if": IfStmt,
+ @"while": WhileStmt,
+ do_while: DoWhileStmt,
+ @"for": ForStmt,
+ for_in: ForInStmt,
+ for_of: ForOfStmt,
+ @"continue": ContinueStmt,
+ @"break": BreakStmt,
+ @"return": ReturnStmt,
+ @"switch": SwitchStmt,
+ throw: ThrowStmt,
+ @"try": TryStmt,
+ labelled: LabelledStmt,
+ with: WithStmt,
+ variable: VarStmt,
+ lexical: LexicalDecl,
+ function: FnDecl,
+ class: ClassDecl,
+ using: UsingStmt,
+ import: ImportDecl,
+ @"export": ExportDecl,
+};
+
+pub const Stmt = struct {
+ loc: Loc,
+ data: StmtType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .block => |b| b.fmt(f),
+ .empty => f.writeChar(';'),
+ .debugger => f.write("debugger;"),
+ .expr => |e| {
+ e.expr.*.fmt(f);
+ f.writeChar(';');
+ },
+ .@"if" => |s| s.fmt(f),
+ .@"while" => |w| w.fmt(f),
+ .do_while => |d| d.fmt(f),
+ .@"for" => |fo| fo.fmt(f),
+ .for_in => |fi| fi.fmt(f),
+ .for_of => |fo| fo.fmt(f),
+ .@"continue" => |c| {
+ f.write("continue");
+ if (c.label) |l| {
+ f.writeChar(' ');
+ f.write(l);
+ }
+ f.writeChar(';');
+ },
+ .@"break" => |b| {
+ f.write("break");
+ if (b.label) |l| {
+ f.writeChar(' ');
+ f.write(l);
+ }
+ f.writeChar(';');
+ },
+ .@"return" => |r| {
+ f.write("return");
+ if (r.arg) |a| {
+ f.writeChar(' ');
+ a.*.fmt(f);
+ }
+ f.writeChar(';');
+ },
+ .@"switch" => |s| s.fmt(f),
+ .throw => |t| {
+ f.write("throw ");
+ t.arg.*.fmt(f);
+ f.writeChar(';');
+ },
+ .@"try" => |t| t.fmt(f),
+ .labelled => |l| {
+ f.write(l.label);
+ f.write(": ");
+ l.body.*.fmt(f);
+ },
+ .with => |w| {
+ f.write("with (");
+ w.obj.*.fmt(f);
+ f.write(") ");
+ w.body.*.fmt(f);
+ },
+ .variable => |v| v.fmt(f),
+ .lexical => |l| l.fmt(f),
+ .using => |u| {
+ f.write("using ");
+ for (u.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ f.writeChar(';');
+ },
+ .import => |i| i.fmt(f),
+ .@"export" => |e| e.fmt(f),
+ .class => |c| c.fmt(f),
+ .function => |d| d.fmt(f),
+ }
+ }
+};
+
+pub const ExprType = union(enum) {
+ identifier: []const u8,
+ this: void,
+ super: void,
+ null: void,
+ bool: bool,
+ number: f64,
+ string: []const u8,
+ regex: Regex,
+ array: ArrayExpr,
+ object: ObjectExpr,
+ func: FnExpr,
+ arrow: ArrowFn,
+ class: ClassExpr,
+ template: TemplateLit,
+ tagged_template: TaggedTemplate,
+ member: MemberExpr,
+ computed_member: ComputedMember,
+ call: CallExpr,
+ new: NewExpr,
+ chain: ChainExpr,
+ unary: UnaryExpr,
+ binary: BinaryExpr,
+ update: UpdateExpr,
+ conditional: IfExpr,
+ assign: AssignExpr,
+ sequence: SeqExpr,
+ spread: SpreadElem,
+ yield: YieldExpr,
+ await: AwaitExpr,
+ meta_prop: MetaProp,
+ parenthesized: *const Expr,
+ private_ident: []const u8,
+};
+
+pub const Expr = struct {
+ loc: Loc,
+ data: ExprType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .identifier => |name| f.write(name),
+ .this => f.write("this"),
+ .super => f.write("super"),
+ .null => f.write("null"),
+ .bool => |b| f.write(if (b) "true" else "false"),
+ .number => |n| {
+ var buf: [64]u8 = undefined;
+ f.write(std.fmt.bufPrint(&buf, "{d}", .{n}) catch "0");
+ },
+ .string => |s| {
+ f.writeChar('"');
+ f.write(s);
+ f.writeChar('"');
+ },
+ .regex => |r| {
+ f.writeChar('/');
+ f.write(r.pattern);
+ f.writeChar('/');
+ f.write(r.flags);
+ },
+ .array => |a| a.fmt(f),
+ .object => |o| o.fmt(f),
+ .func => |fn_expr| fn_expr.fmt(f),
+ .arrow => |arrow| arrow.fmt(f),
+ .class => |c| c.fmt(f),
+ .template => |t| t.fmt(f),
+ .tagged_template => |tt| tt.fmt(f),
+ .member => |m| m.fmt(f),
+ .computed_member => |cm| cm.fmt(f),
+ .call => |call| call.fmt(f),
+ .new => |n| {
+ f.write("new ");
+ n.callee.*.fmt(f);
+ f.writeChar('(');
+ for (n.args, 0..) |a, i| {
+ if (i > 0) f.write(", ");
+ a.fmt(f);
+ }
+ f.writeChar(')');
+ },
+ .chain => |c| c.expr.*.fmt(f),
+ .unary => |u| {
+ if (u.prefix) {
+ f.write(@tagName(u.op));
+ u.arg.*.fmt(f);
+ } else {
+ u.arg.*.fmt(f);
+ f.write(@tagName(u.op));
+ }
+ },
+ .binary => |b| {
+ f.writeChar('(');
+ b.left.*.fmt(f);
+ f.writeChar(' ');
+ f.write(@tagName(b.op));
+ f.writeChar(' ');
+ b.right.*.fmt(f);
+ f.writeChar(')');
+ },
+ .update => |u| {
+ const s = if (u.op == .@"++") "++" else "--";
+ if (u.prefix) {
+ f.write(s);
+ u.arg.*.fmt(f);
+ } else {
+ u.arg.*.fmt(f);
+ f.write(s);
+ }
+ },
+ .conditional => |c| {
+ c.condition.*.fmt(f);
+ f.write(" ? ");
+ c.consequent.*.fmt(f);
+ f.write(" : ");
+ c.alternate.*.fmt(f);
+ },
+ .assign => |a| {
+ a.left.*.fmt(f);
+ f.writeChar(' ');
+ f.write(@tagName(a.op));
+ f.writeChar(' ');
+ a.right.*.fmt(f);
+ },
+ .sequence => |s| {
+ for (s.exprs, 0..) |e, i| {
+ if (i > 0) f.write(", ");
+ e.fmt(f);
+ }
+ },
+ .spread => |s| {
+ f.write("...");
+ s.arg.*.fmt(f);
+ },
+ .yield => |y| {
+ f.write("yield");
+ if (y.delegate) f.write("*");
+ if (y.arg) |a| {
+ f.writeChar(' ');
+ a.*.fmt(f);
+ }
+ },
+ .await => |a| {
+ f.write("await ");
+ a.arg.*.fmt(f);
+ },
+ .meta_prop => |m| {
+ f.write(m.meta);
+ f.writeChar('.');
+ f.write(m.prop);
+ },
+ .parenthesized => |p| {
+ f.writeChar('(');
+ p.*.fmt(f);
+ f.writeChar(')');
+ },
+ .private_ident => |name| f.write(name),
+ }
+ }
+};
+
+pub const PatType = union(enum) {
+ ident: []const u8,
+ object: ObjectPat,
+ array: ArrayPat,
+ assign: AssignPat,
+ rest: RestPat,
+};
+
+pub const Pat = struct {
+ loc: Loc,
+ data: PatType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .ident => |name| f.write(name),
+ .object => |o| o.fmt(f),
+ .array => |a| a.fmt(f),
+ .assign => |a| {
+ a.left.*.fmt(f);
+ f.write(" = ");
+ a.right.*.fmt(f);
+ },
+ .rest => |r| {
+ f.write("...");
+ r.arg.*.fmt(f);
+ },
+ }
+ }
+};
+
+pub const DeclType = union(enum) {
+ @"fn": FnDecl,
+ class: ClassDecl,
+ @"var": VarDecl,
+ using: UsingDecl,
+ import: ImportDecl,
+ @"export": ExportDecl,
+ export_default: ExportDefault,
+};
+
+pub const Decl = struct {
+ loc: Loc,
+ data: DeclType,
+};
+
+pub const LitType = union(enum) {
+ null: void,
+ bool: bool,
+ number: f64,
+ string: []const u8,
+ regex: Regex,
+ bigint: []const u8,
+};
+
+pub const Lit = struct {
+ loc: Loc,
+ data: LitType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .null => f.write("null"),
+ .bool => |b| f.write(if (b) "true" else "false"),
+ .number => |n| {
+ var buf: [64]u8 = undefined;
+ f.write(std.fmt.bufPrint(&buf, "{d}", .{n}) catch "0");
+ },
+ .string => |s| {
+ f.writeChar('"');
+ f.write(s);
+ f.writeChar('"');
+ },
+ .regex => |r| {
+ f.writeChar('/');
+ f.write(r.pattern);
+ f.writeChar('/');
+ f.write(r.flags);
+ },
+ .bigint => |s| {
+ f.write(s);
+ f.writeChar('n');
+ },
+ }
+ }
+};
+
+pub const Regex = struct {
+ pattern: []const u8,
+ flags: []const u8,
+};
+
+pub const PropType = union(enum) {
+ init: PropInit,
+ get: PropGet,
+ set: PropSet,
+ shorthand: []const u8,
+ spread: SpreadElem,
+ method: FnExpr,
+};
+
+pub const Prop = struct {
+ loc: Loc,
+ key: PropKey,
+ data: PropType,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ switch (self.data) {
+ .init => |p_init| {
+ self.key.fmt(f);
+ f.write(": ");
+ p_init.value.*.fmt(f);
+ },
+ .get => |g| g.fmt(f),
+ .set => |s| s.fmt(f),
+ .shorthand => |name| f.write(name),
+ .spread => |sp| {
+ f.write("...");
+ sp.arg.*.fmt(f);
+ },
+ .method => |m| m.fmt(f),
+ }
+ }
+};
+
+pub const PropKey = union(enum) {
+ ident: []const u8,
+ string: []const u8,
+ number: f64,
+ computed: *const Expr,
+ private: []const u8,
+};
+
+pub const PropInit = struct {
+ key: PropKey,
+ value: *const Expr,
+};
+
+pub const PropGet = struct {
+ key: PropKey,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("get ");
+ self.key.fmt(f);
+ f.write("() ");
+ self.body.fmt(f);
+ }
+};
+
+pub const PropSet = struct {
+ key: PropKey,
+ param: Pat,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("set ");
+ self.key.fmt(f);
+ f.writeChar('(');
+ self.param.fmt(f);
+ f.write(") ");
+ self.body.fmt(f);
+ }
+};
+
+pub const SpreadElem = struct {
+ loc: Loc,
+ arg: *const Expr,
+};
+
+pub const BlockStmt = struct {
+ loc: Loc,
+ body: []const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('{');
+ if (self.body.len > 0) {
+ f.newline();
+ f.indent_level += 1;
+ for (self.body) |s| {
+ f.writeIndent();
+ s.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ }
+ f.writeChar('}');
+ }
+};
+
+pub const ExprStmt = struct {
+ loc: Loc,
+ expr: *const Expr,
+};
+
+pub const IfStmt = struct {
+ loc: Loc,
+ condition: *const Expr,
+ consequent: *const Stmt,
+ alternate: ?*const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("if (");
+ self.condition.*.fmt(f);
+ f.write(") ");
+ self.consequent.*.fmt(f);
+ if (self.alternate) |alt| {
+ f.write(" else ");
+ alt.*.fmt(f);
+ }
+ }
+};
+
+pub const WhileStmt = struct {
+ loc: Loc,
+ condition: *const Expr,
+ body: *const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("while (");
+ self.condition.*.fmt(f);
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const DoWhileStmt = struct {
+ loc: Loc,
+ body: *const Stmt,
+ condition: *const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("do ");
+ self.body.*.fmt(f);
+ f.write(" while (");
+ self.condition.*.fmt(f);
+ f.write(");");
+ }
+};
+
+pub const ForInit = union(enum) {
+ expr: *const Expr,
+ decl: *const Decl,
+};
+
+pub const ForStmt = struct {
+ loc: Loc,
+ init: ?ForInit,
+ condition: ?*const Expr,
+ update: ?*const Expr,
+ body: *const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("for (");
+ if (self.init) |init| {
+ switch (init) {
+ .expr => |e| e.*.fmt(f),
+ .decl => |d| d.*.fmt(f),
+ }
+ }
+ f.writeChar(';');
+ if (self.condition) |c| {
+ f.writeChar(' ');
+ c.*.fmt(f);
+ }
+ f.writeChar(';');
+ if (self.update) |u| {
+ f.writeChar(' ');
+ u.*.fmt(f);
+ }
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const ForInStmt = struct {
+ loc: Loc,
+ left: ForInit,
+ right: *const Expr,
+ body: *const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("for (");
+ switch (self.left) {
+ .expr => |e| e.*.fmt(f),
+ .decl => |d| d.*.fmt(f),
+ }
+ f.write(" in ");
+ self.right.*.fmt(f);
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const ForOfStmt = struct {
+ loc: Loc,
+ await_token: bool,
+ left: ForInit,
+ right: *const Expr,
+ body: *const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("for");
+ if (self.await_token) f.write(" await");
+ f.write(" (");
+ switch (self.left) {
+ .expr => |e| e.*.fmt(f),
+ .decl => |d| d.*.fmt(f),
+ }
+ f.write(" of ");
+ self.right.*.fmt(f);
+ f.write(") ");
+ self.body.*.fmt(f);
+ }
+};
+
+pub const ContinueStmt = struct {
+ loc: Loc,
+ label: ?[]const u8,
+};
+
+pub const BreakStmt = struct {
+ loc: Loc,
+ label: ?[]const u8,
+};
+
+pub const ReturnStmt = struct {
+ loc: Loc,
+ arg: ?*const Expr,
+};
+
+pub const SwitchStmt = struct {
+ loc: Loc,
+ discriminant: *const Expr,
+ cases: []const SwitchCase,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("switch (");
+ self.discriminant.*.fmt(f);
+ f.write(") {");
+ f.newline();
+ f.indent_level += 1;
+ for (self.cases) |c| {
+ f.writeIndent();
+ c.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ f.writeChar('}');
+ }
+};
+
+pub const SwitchCase = struct {
+ loc: Loc,
+ condition: ?*const Expr,
+ consequent: []const Stmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ if (self.condition) |c| {
+ f.write("case ");
+ c.*.fmt(f);
+ } else {
+ f.write("default");
+ }
+ f.writeChar(':');
+ for (self.consequent) |s| {
+ f.writeChar(' ');
+ s.fmt(f);
+ }
+ }
+};
+
+pub const ThrowStmt = struct {
+ loc: Loc,
+ arg: *const Expr,
+};
+
+pub const TryStmt = struct {
+ loc: Loc,
+ block: BlockStmt,
+ handler: ?CatchClause,
+ finalizer: ?BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("try ");
+ self.block.fmt(f);
+ if (self.handler) |h| {
+ f.writeChar(' ');
+ h.fmt(f);
+ }
+ if (self.finalizer) |fin| {
+ f.write(" finally ");
+ fin.fmt(f);
+ }
+ }
+};
+
+pub const CatchClause = struct {
+ loc: Loc,
+ param: ?Pat,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("catch");
+ if (self.param) |p| {
+ f.write(" (");
+ p.fmt(f);
+ f.write(") ");
+ } else {
+ f.writeChar(' ');
+ }
+ self.body.fmt(f);
+ }
+};
+
+pub const LabelledStmt = struct {
+ loc: Loc,
+ label: []const u8,
+ body: *const Stmt,
+};
+
+pub const WithStmt = struct {
+ loc: Loc,
+ obj: *const Expr,
+ body: *const Stmt,
+};
+
+pub const VarStmt = struct {
+ loc: Loc,
+ kind: VarKind,
+ decls: []const VarDeclarator,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(@tagName(self.kind));
+ f.writeChar(' ');
+ for (self.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ f.writeChar(';');
+ }
+};
+
+pub const UsingStmt = struct {
+ loc: Loc,
+ decls: []const VarDeclarator,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("using ");
+ for (self.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ }
+};
+
+pub const VarKind = enum {
+ @"var",
+ let,
+ @"const",
+};
+
+pub const VarDecl = struct {
+ loc: Loc,
+ kind: VarKind,
+ decls: []const VarDeclarator,
+};
+
+pub const LexicalDecl = struct {
+ loc: Loc,
+ kind: VarKind,
+ decls: []const VarDeclarator,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(@tagName(self.kind));
+ f.writeChar(' ');
+ for (self.decls, 0..) |d, i| {
+ if (i > 0) f.write(", ");
+ d.fmt(f);
+ }
+ f.writeChar(';');
+ }
+};
+
+pub const UsingDecl = struct {
+ loc: Loc,
+ is_await: bool,
+ decls: []const VarDeclarator,
+};
+
+pub const VarDeclarator = struct {
+ loc: Loc,
+ id: Pat,
+ init: ?*const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.id.fmt(f);
+ if (self.init) |init| {
+ f.write(" = ");
+ init.*.fmt(f);
+ }
+ }
+};
+
+pub const ObjectPat = struct {
+ loc: Loc,
+ props: []const PatProp,
+ rest: ?*const Pat,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('{');
+ var first = true;
+ for (self.props) |prop| {
+ if (!first) f.write(", ");
+ first = false;
+ switch (prop) {
+ .key_value => |kv| {
+ kv.key.fmt(f);
+ f.write(": ");
+ kv.value.*.fmt(f);
+ },
+ .shorthand => |name| f.write(name),
+ .rest => |r| {
+ f.write("...");
+ r.*.fmt(f);
+ },
+ }
+ }
+ if (self.rest) |rest| {
+ if (!first) f.write(", ");
+ f.write("...");
+ rest.*.fmt(f);
+ }
+ f.writeChar('}');
+ }
+};
+
+pub const PatProp = union(enum) {
+ key_value: struct {
+ key: PropKey,
+ value: *const Pat,
+ },
+ shorthand: []const u8,
+ rest: *const Pat,
+};
+
+pub const ArrayPat = struct {
+ loc: Loc,
+ elems: []const ?Pat,
+ rest: ?*const Pat,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('[');
+ for (self.elems, 0..) |elem, i| {
+ if (i > 0) f.write(", ");
+ if (elem) |pat| pat.fmt(f);
+ }
+ if (self.rest) |rest| {
+ if (self.elems.len > 0) f.write(", ");
+ f.write("...");
+ rest.*.fmt(f);
+ }
+ f.writeChar(']');
+ }
+};
+
+pub const AssignPat = struct {
+ loc: Loc,
+ left: *const Pat,
+ right: *const Expr,
+};
+
+pub const RestPat = struct {
+ loc: Loc,
+ arg: *const Pat,
+};
+
+pub const FnType = union(enum) {
+ normal: void,
+ generator: void,
+ async: void,
+ async_generator: void,
+};
+
+pub const FnDecl = struct {
+ loc: Loc,
+ fn_type: FnType,
+ id: ?[]const u8,
+ params: []const Pat,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("function");
+ if (self.fn_type == .generator or self.fn_type == .async_generator) {
+ f.write("*");
+ }
+ if (self.fn_type == .async or self.fn_type == .async_generator) {
+ f.write(" async");
+ }
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ f.writeChar('(');
+ for (self.params, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.write(") ");
+ self.body.fmt(f);
+ }
+};
+
+pub const FnExpr = struct {
+ loc: Loc,
+ fn_type: FnType,
+ id: ?[]const u8,
+ params: []const Pat,
+ body: BlockStmt,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("function");
+ if (self.fn_type == .generator or self.fn_type == .async_generator) {
+ f.write("*");
+ }
+ if (self.fn_type == .async or self.fn_type == .async_generator) {
+ f.write(" async");
+ }
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ f.writeChar('(');
+ for (self.params, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.write(") ");
+ self.body.fmt(f);
+ }
+};
+
+pub const ArrowFn = struct {
+ loc: Loc,
+ async_token: bool,
+ params: []const Pat,
+ body: union(enum) {
+ block: BlockStmt,
+ expr: *const Expr,
+ },
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ if (self.async_token) f.write("async ");
+ f.writeChar('(');
+ for (self.params, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.write(") => ");
+ switch (self.body) {
+ .block => |b| b.fmt(f),
+ .expr => |e| e.*.fmt(f),
+ }
+ }
+};
+
+pub const ClassDecl = struct {
+ loc: Loc,
+ id: ?[]const u8,
+ super_class: ?*const Expr,
+ body: []const ClassElem,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("class");
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ if (self.super_class) |sc| {
+ f.write(" extends ");
+ sc.*.fmt(f);
+ }
+ f.write(" {");
+ f.newline();
+ f.indent_level += 1;
+ for (self.body) |elem| {
+ f.writeIndent();
+ elem.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ f.writeChar('}');
+ }
+};
+
+pub const ClassExpr = struct {
+ loc: Loc,
+ id: ?[]const u8,
+ super_class: ?*const Expr,
+ body: []const ClassElem,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("class");
+ if (self.id) |id| {
+ f.writeChar(' ');
+ f.write(id);
+ }
+ if (self.super_class) |sc| {
+ f.write(" extends ");
+ sc.*.fmt(f);
+ }
+ f.write(" {");
+ f.newline();
+ f.indent_level += 1;
+ for (self.body) |elem| {
+ f.writeIndent();
+ elem.fmt(f);
+ f.newline();
+ }
+ f.indent_level -= 1;
+ f.writeIndent();
+ f.writeChar('}');
+ }
+};
+
+pub const ClassElem = union(enum) {
+ method: FnExpr,
+ get: PropGet,
+ set: PropSet,
+ field: FieldDef,
+ static_block: BlockStmt,
+ static_method: FnExpr,
+ static_get: PropGet,
+ static_set: PropSet,
+ static_field: FieldDef,
+};
+
+pub const FieldDef = struct {
+ loc: Loc,
+ key: PropKey,
+ value: ?*const Expr,
+};
+
+pub const ImportDecl = struct {
+ loc: Loc,
+ specifiers: []const ImportSpecifier,
+ source: []const u8,
+ attributes: []const ImportAttribute,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("import ");
+ if (self.specifiers.len > 0) {
+ for (self.specifiers, 0..) |spec, j| {
+ if (j > 0) f.write(", ");
+ spec.fmt(f);
+ }
+ f.write(" from ");
+ }
+ f.writeChar('"');
+ f.write(self.source);
+ f.writeChar('"');
+ for (self.attributes) |a| {
+ f.write(" /* ");
+ a.fmt(f);
+ f.write(" */");
+ }
+ f.writeChar(';');
+ }
+};
+
+pub const ImportSpecifier = union(enum) {
+ default: []const u8,
+ namespace: []const u8,
+ named: struct { imported: []const u8, local: []const u8 },
+};
+
+pub const ImportAttribute = struct {
+ key: []const u8,
+ value: []const u8,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(self.key);
+ f.write(": \"");
+ f.write(self.value);
+ f.writeChar('"');
+ }
+};
+
+pub const ExportDecl = struct {
+ loc: Loc,
+ declaration: ?*const Decl,
+ specifiers: ?[]const ExportSpecifier,
+ source: ?[]const u8,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("export ");
+ if (self.declaration) |d| {
+ d.*.fmt(f);
+ } else if (self.specifiers) |s| {
+ f.writeChar('{');
+ for (s, 0..) |sp, i| {
+ if (i > 0) f.write(", ");
+ sp.fmt(f);
+ }
+ f.writeChar('}');
+ if (self.source) |src| {
+ f.write(" from \"");
+ f.write(src);
+ f.writeChar('"');
+ }
+ f.writeChar(';');
+ } else if (self.source) |src| {
+ f.write("* from \"");
+ f.write(src);
+ f.writeChar("\";");
+ }
+ }
+};
+
+pub const ExportSpecifier = struct {
+ loc: Loc,
+ exported: []const u8,
+ local: []const u8,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write(self.local);
+ if (!std.mem.eql(u8, self.local, self.exported)) {
+ f.write(" as ");
+ f.write(self.exported);
+ }
+ }
+};
+
+pub const ExportDefault = struct {
+ loc: Loc,
+ declaration: *const Decl,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.write("export default ");
+ self.declaration.*.fmt(f);
+ }
+};
+
+pub const ArrayExpr = struct {
+ loc: Loc,
+ elems: []const ?Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('[');
+ for (self.elems, 0..) |elem, i| {
+ if (i > 0) f.write(", ");
+ if (elem) |e| e.fmt(f);
+ }
+ f.writeChar(']');
+ }
+};
+
+pub const ObjectExpr = struct {
+ loc: Loc,
+ props: []const Prop,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('{');
+ for (self.props, 0..) |p, i| {
+ if (i > 0) f.write(", ");
+ p.fmt(f);
+ }
+ f.writeChar('}');
+ }
+};
+
+pub const MemberExpr = struct {
+ loc: Loc,
+ obj: *const Expr,
+ prop: union(enum) {
+ ident: []const u8,
+ private: []const u8,
+ },
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.obj.*.fmt(f);
+ switch (self.prop) {
+ .ident => |name| {
+ f.writeChar('.');
+ f.write(name);
+ },
+ .private => |name| {
+ f.writeChar('.');
+ f.write(name);
+ },
+ }
+ }
+};
+
+pub const ComputedMember = struct {
+ loc: Loc,
+ obj: *const Expr,
+ expr: *const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.obj.*.fmt(f);
+ f.writeChar('[');
+ self.expr.*.fmt(f);
+ f.writeChar(']');
+ }
+};
+
+pub const CallExpr = struct {
+ loc: Loc,
+ callee: *const Expr,
+ args: []const Expr,
+ optional: bool,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.callee.*.fmt(f);
+ if (self.optional) {
+ f.write("?.(");
+ } else {
+ f.writeChar('(');
+ }
+ for (self.args, 0..) |a, i| {
+ if (i > 0) f.write(", ");
+ a.fmt(f);
+ }
+ f.writeChar(')');
+ }
+};
+
+pub const NewExpr = struct {
+ loc: Loc,
+ callee: *const Expr,
+ args: []const Expr,
+};
+
+pub const ChainExpr = struct {
+ loc: Loc,
+ expr: *const Expr,
+};
+
+pub const UnaryOp = enum {
+ @"-",
+ @"+",
+ @"!",
+ @"~",
+ typeof,
+ void,
+ delete,
+};
+
+pub const UnaryExpr = struct {
+ loc: Loc,
+ op: UnaryOp,
+ arg: *const Expr,
+ prefix: bool,
+};
+
+pub const BinaryOp = enum {
+ @"==",
+ @"!=",
+ @"===",
+ @"!==",
+ @"<",
+ @"<=",
+ @">",
+ @">=",
+ @"<<",
+ @">>",
+ @">>>",
+ @"+",
+ @"-",
+ @"*",
+ @"/",
+ @"%",
+ @"**",
+ @"|",
+ @"^",
+ @"&",
+ in,
+ instanceof,
+ @"||",
+ @"&&",
+ @"??",
+};
+
+pub const BinaryExpr = struct {
+ loc: Loc,
+ op: BinaryOp,
+ left: *const Expr,
+ right: *const Expr,
+};
+
+pub const UpdateOp = enum {
+ @"++",
+ @"--",
+};
+
+pub const UpdateExpr = struct {
+ loc: Loc,
+ op: UpdateOp,
+ arg: *const Expr,
+ prefix: bool,
+};
+
+pub const IfExpr = struct {
+ loc: Loc,
+ condition: *const Expr,
+ consequent: *const Expr,
+ alternate: *const Expr,
+};
+
+pub const AssignOp = enum {
+ @"=",
+ @"+=",
+ @"-=",
+ @"*=",
+ @"/=",
+ @"%=",
+ @"**=",
+ @"<<=",
+ @">>=",
+ @">>>=",
+ @"|=",
+ @"^=",
+ @"&=",
+ @"||=",
+ @"&&=",
+ @"??=",
+};
+
+pub const AssignExpr = struct {
+ loc: Loc,
+ op: AssignOp,
+ left: *const Expr,
+ right: *const Expr,
+};
+
+pub const SeqExpr = struct {
+ loc: Loc,
+ exprs: []const Expr,
+};
+
+pub const YieldExpr = struct {
+ loc: Loc,
+ arg: ?*const Expr,
+ delegate: bool,
+};
+
+pub const AwaitExpr = struct {
+ loc: Loc,
+ arg: *const Expr,
+};
+
+pub const MetaProp = struct {
+ loc: Loc,
+ meta: []const u8,
+ prop: []const u8,
+};
+
+pub const TemplateLit = struct {
+ loc: Loc,
+ quasis: []const TemplateElem,
+ exprs: []const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('`');
+ var ei: usize = 0;
+ for (self.quasis, 0..) |q, i| {
+ if (i > 0 and ei < self.exprs.len) {
+ f.write("${");
+ self.exprs[ei].fmt(f);
+ f.writeChar('}');
+ ei += 1;
+ }
+ f.write(q.value);
+ }
+ f.writeChar('`');
+ }
+};
+
+pub const TemplateElem = struct {
+ loc: Loc,
+ value: []const u8,
+ tail: bool,
+};
+
+pub const TaggedTemplate = struct {
+ loc: Loc,
+ tag: *const Expr,
+ quasi: TemplateLit,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ self.tag.*.fmt(f);
+ self.quasi.fmt(f);
+ }
+};
+
+pub const Decorator = struct {
+ loc: Loc,
+ expr: *const Expr,
+
+ pub fn fmt(self: @This(), f: *Formatter) void {
+ f.writeChar('@');
+ self.expr.*.fmt(f);
+ }
+};
diff --git a/src/z/parser/js/lexical_grammar.zig b/src/z/parser/js/lexical_grammar.zig
new file mode 100644
index 0000000..2211fbe
--- /dev/null
+++ b/src/z/parser/js/lexical_grammar.zig
@@ -0,0 +1,1137 @@
+const std = @import("std");
+
+const ast = @import("ast.zig");
+pub const Loc = ast.Loc;
+
+pub const TokenType = enum {
+ // Keywords
+ await,
+ @"break",
+ case,
+ @"catch",
+ class,
+ @"const",
+ @"continue",
+ debugger,
+ default,
+ delete,
+ do,
+ @"else",
+ @"enum",
+ @"export",
+ extends,
+ false,
+ finally,
+ @"for",
+ function,
+ @"if",
+ import,
+ in,
+ instanceof,
+ let,
+ new,
+ null,
+ @"return",
+ super,
+ @"switch",
+ this,
+ throw,
+ true,
+ @"try",
+ typeof,
+ @"var",
+ void,
+ @"while",
+ with,
+ yield,
+ using,
+ async,
+ static,
+ get,
+ set,
+ of,
+
+ // Identifiers and literals
+ identifier,
+ private_identifier,
+ number,
+ string,
+ bigint,
+ regex,
+ template_head,
+ template_middle,
+ template_tail,
+ no_sub_template,
+
+ // Punctuators
+ lbrace,
+ rbrace,
+ lparen,
+ rparen,
+ lbracket,
+ rbracket,
+ dot,
+ semicolon,
+ comma,
+ @"...",
+ @"<",
+ @">",
+ @"<=",
+ @">=",
+ @"==",
+ @"!=",
+ @"===",
+ @"!==",
+ @"+",
+ @"-",
+ @"*",
+ @"%",
+ @"**",
+ @"++",
+ @"--",
+ @"<<",
+ @">>",
+ @">>>",
+ @"&",
+ @"|",
+ @"^",
+ @"!",
+ @"~",
+ @"&&",
+ @"||",
+ @"??",
+ @"?",
+ @":",
+ @"=",
+ @"+=",
+ @"-=",
+ @"*=",
+ @"%=",
+ @"**=",
+ @"<<=",
+ @">>=",
+ @">>>=",
+ @"&=",
+ @"|=",
+ @"^=",
+ @"&&=",
+ @"||=",
+ @"??=",
+ @"=>",
+ @"/",
+ @"/=",
+ @"?.",
+ @".",
+ @"#",
+
+ // Special
+ from,
+ eof,
+ unknown,
+
+ pub fn isKeyword(self: TokenType) bool {
+ return switch (self) {
+ .await,
+ .@"break",
+ .case,
+ .@"catch",
+ .class,
+ .@"const",
+ .@"continue",
+ .debugger,
+ .default,
+ .delete,
+ .do,
+ .@"else",
+ .@"enum",
+ .@"export",
+ .extends,
+ .false,
+ .finally,
+ .@"for",
+ .function,
+ .@"if",
+ .import,
+ .in,
+ .instanceof,
+ .let,
+ .new,
+ .null,
+ .@"return",
+ .super,
+ .@"switch",
+ .this,
+ .throw,
+ .true,
+ .@"try",
+ .typeof,
+ .@"var",
+ .void,
+ .@"while",
+ .with,
+ .yield,
+ .using,
+ .async,
+ .static,
+ .get,
+ .set,
+ .of,
+ .from,
+ => true,
+ else => false,
+ };
+ }
+
+ pub fn isIdentifier(self: TokenType) bool {
+ return self == .identifier or self.isKeyword();
+ }
+
+ pub fn isKeywordButNotLet(self: TokenType) bool {
+ return self.isKeyword() and self != .let;
+ }
+};
+
+pub const Token = struct {
+ kind: TokenType,
+ loc: Loc,
+ slice: []const u8,
+};
+
+pub const Lexer = struct {
+ source: []const u8,
+ pos: usize,
+
+ const Self = @This();
+
+ pub fn init(source: []const u8) Self {
+ return .{ .source = source, .pos = 0 };
+ }
+
+ pub fn tokenize(source: []const u8) []const Token {
+ var buf: [4096]Token = undefined;
+ return tokenizeBuf(source, &buf);
+ }
+
+ pub fn tokenizeBuf(source: []const u8, tokens: *[4096]Token) []const Token {
+ @setEvalBranchQuota(100000);
+ var lexer = Self.init(source);
+ var count: usize = 0;
+
+ while (true) {
+ const tok = lexer.next();
+ tokens[count] = tok;
+ count += 1;
+ if (tok.kind == .eof) break;
+ if (count >= tokens.len - 1) {
+ tokens[count] = .{ .kind = .eof, .loc = .{ .start = lexer.pos, .end = lexer.pos }, .slice = "" };
+ break;
+ }
+ }
+
+ return tokens[0..count];
+ }
+
+ fn ch(self: Self) ?u8 {
+ if (self.pos >= self.source.len) return null;
+ return self.source[self.pos];
+ }
+
+ fn chAt(self: Self, offset: usize) ?u8 {
+ const idx = self.pos + offset;
+ if (idx >= self.source.len) return null;
+ return self.source[idx];
+ }
+
+ fn advance(self: *Self) void {
+ if (self.pos < self.source.len) self.pos += 1;
+ }
+
+ fn isWhiteSpace(c: u8) bool {
+ return switch (c) {
+ ' ', '\t', 0x0B, 0x0C => true,
+ else => false,
+ };
+ }
+
+ fn isLineTerminator(c: u8) bool {
+ return switch (c) {
+ '\n', '\r' => true,
+ else => false,
+ };
+ }
+
+ fn isDigit(c: u8) bool {
+ return c >= '0' and c <= '9';
+ }
+
+ fn isHexDigit(c: u8) bool {
+ return switch (c) {
+ '0'...'9', 'a'...'f', 'A'...'F' => true,
+ else => false,
+ };
+ }
+
+ fn isOctalDigit(c: u8) bool {
+ return c >= '0' and c <= '7';
+ }
+
+ fn isIdStart(c: u8) bool {
+ return switch (c) {
+ 'a'...'z', 'A'...'Z', '_', '$' => true,
+ else => c > 0x7F,
+ };
+ }
+
+ fn isIdContinue(c: u8) bool {
+ return isIdStart(c) or isDigit(c) or c == 0x200C or c == 0x200D;
+ }
+
+ fn skipWhiteSpace(self: *Self) void {
+ while (self.ch()) |c| {
+ if (isWhiteSpace(c) or isLineTerminator(c)) {
+ self.advance();
+ } else {
+ break;
+ }
+ }
+ }
+
+ fn skipSingleLineComment(self: *Self) void {
+ self.advance();
+ self.advance();
+ while (self.ch()) |c| {
+ if (isLineTerminator(c)) break;
+ self.advance();
+ }
+ }
+
+ fn skipMultiLineComment(self: *Self) void {
+ self.advance();
+ self.advance();
+ while (self.ch()) |c| {
+ if (c == '*') {
+ if (self.chAt(1)) |n| {
+ if (n == '/') {
+ self.advance();
+ self.advance();
+ return;
+ }
+ }
+ }
+ self.advance();
+ }
+ }
+
+ fn skipHashbang(self: *Self) void {
+ if (self.ch()) |c| {
+ if (c == '#') {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '!') {
+ self.advance();
+ while (self.ch()) |c2| {
+ if (isLineTerminator(c2)) break;
+ self.advance();
+ }
+ }
+ }
+ }
+ }
+ }
+
+ fn scanString(self: *Self, quote: u8) Token {
+ const start = self.pos;
+ self.advance();
+
+ while (self.ch()) |c| {
+ if (c == quote) {
+ self.advance();
+ return .{
+ .kind = .string,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start + 1 .. self.pos - 1],
+ };
+ }
+ if (c == '\\') {
+ self.advance();
+ if (self.ch()) |_| self.advance();
+ } else if (isLineTerminator(c) and c != 0x2028 and c != 0x2029) {
+ break;
+ } else {
+ self.advance();
+ }
+ }
+
+ return .{
+ .kind = .string,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start + 1 .. self.pos],
+ };
+ }
+
+ fn scanTemplate(self: *Self, start_kind: TokenType) Token {
+ const start = self.pos;
+ if (start_kind == .template_middle or start_kind == .template_head) {
+ self.advance();
+ }
+ return self.scanTemplateRest(start);
+ }
+
+ fn scanTemplateRest(self: *Self, start: usize) Token {
+ while (self.ch()) |c| {
+ if (c == '`') {
+ self.advance();
+ return .{
+ .kind = .no_sub_template,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ }
+ if (c == '$') {
+ if (self.chAt(1)) |n| {
+ if (n == '{') {
+ self.advance();
+ self.advance();
+ return .{
+ .kind = .template_head,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 2],
+ };
+ }
+ }
+ }
+ if (c == '\\') {
+ self.advance();
+ if (self.ch()) |_| self.advance();
+ } else {
+ self.advance();
+ }
+ }
+
+ return .{
+ .kind = .no_sub_template,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanTemplateMiddleOrTail(self: *Self) Token {
+ const start = self.pos;
+ self.advance();
+
+ while (self.ch()) |c| {
+ if (c == '`') {
+ self.advance();
+ return .{
+ .kind = .template_tail,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ }
+ if (c == '$') {
+ if (self.chAt(1)) |n| {
+ if (n == '{') {
+ self.advance();
+ self.advance();
+ return .{
+ .kind = .template_middle,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 2],
+ };
+ }
+ }
+ }
+ if (c == '\\') {
+ self.advance();
+ if (self.ch()) |_| self.advance();
+ } else {
+ self.advance();
+ }
+ }
+
+ return .{
+ .kind = .template_tail,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanNumber(self: *Self) Token {
+ const start = self.pos;
+
+ if (self.ch()) |c| {
+ if (c == '0') {
+ self.advance();
+ if (self.ch()) |n| {
+ switch (n) {
+ 'x', 'X' => return self.scanHex(start),
+ 'b', 'B' => return self.scanBinary(start),
+ 'o', 'O' => return self.scanOctal(start),
+ 'n' => {
+ self.advance();
+ return .{
+ .kind = .bigint,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ },
+ 'e', 'E' => return self.scanDecimalAfterInt(start),
+ '.', '0'...'9' => return self.scanDecimalAfterInt(start),
+ else => {},
+ }
+ }
+ }
+ }
+
+ return self.scanDecimal(start);
+ }
+
+ fn scanDecimal(self: *Self, start: usize) Token {
+ while (self.ch()) |c| {
+ if (!isDigit(c) and c != '_') break;
+ self.advance();
+ }
+
+ if (self.ch()) |c| {
+ if (c == '.') {
+ self.advance();
+ while (self.ch()) |c2| {
+ if (!isDigit(c2) and c2 != '_') break;
+ self.advance();
+ }
+ }
+ if (self.ch()) |c2| {
+ if (c2 == 'e' or c2 == 'E') {
+ return self.scanExponent(start);
+ }
+ }
+ if (self.ch()) |c2| {
+ if (c2 == 'n') {
+ self.advance();
+ return .{
+ .kind = .bigint,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ }
+ }
+ }
+
+ return .{
+ .kind = .number,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanDecimalAfterInt(self: *Self, start: usize) Token {
+ while (self.ch()) |c| {
+ if (!isDigit(c) and c != '_') break;
+ self.advance();
+ }
+ if (self.ch()) |c| {
+ if (c == '.') {
+ self.advance();
+ while (self.ch()) |c2| {
+ if (!isDigit(c2) and c2 != '_') break;
+ self.advance();
+ }
+ }
+ if (self.ch()) |c2| {
+ if (c2 == 'e' or c2 == 'E') {
+ return self.scanExponent(start);
+ }
+ }
+ if (self.ch()) |c2| {
+ if (c2 == 'n') {
+ self.advance();
+ return .{
+ .kind = .bigint,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ }
+ }
+ }
+ return .{
+ .kind = .number,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanExponent(self: *Self, start: usize) Token {
+ self.advance();
+ if (self.ch()) |c| {
+ if (c == '+' or c == '-') self.advance();
+ }
+ while (self.ch()) |c| {
+ if (!isDigit(c) and c != '_') break;
+ self.advance();
+ }
+ return .{
+ .kind = .number,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanHex(self: *Self, start: usize) Token {
+ self.advance();
+ while (self.ch()) |c| {
+ if (!isHexDigit(c) and c != '_') break;
+ self.advance();
+ }
+ if (self.ch()) |c| {
+ if (c == 'n') {
+ self.advance();
+ return .{
+ .kind = .bigint,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ }
+ }
+ return .{
+ .kind = .number,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanBinary(self: *Self, start: usize) Token {
+ self.advance();
+ while (self.ch()) |c| {
+ if (c != '0' and c != '1' and c != '_') break;
+ self.advance();
+ }
+ if (self.ch()) |c| {
+ if (c == 'n') {
+ self.advance();
+ return .{
+ .kind = .bigint,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ }
+ }
+ return .{
+ .kind = .number,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanOctal(self: *Self, start: usize) Token {
+ self.advance();
+ while (self.ch()) |c| {
+ if (!isOctalDigit(c) and c != '_') break;
+ self.advance();
+ }
+ if (self.ch()) |c| {
+ if (c == 'n') {
+ self.advance();
+ return .{
+ .kind = .bigint,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start .. self.pos - 1],
+ };
+ }
+ }
+ return .{
+ .kind = .number,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanIdentifierOrKeyword(self: *Self) Token {
+ const start = self.pos;
+ while (self.ch()) |c| {
+ if (!isIdContinue(c)) break;
+ self.advance();
+ }
+
+ const slice = self.source[start..self.pos];
+ const kind = keywordFromString(slice);
+
+ return .{
+ .kind = kind,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = slice,
+ };
+ }
+
+ fn scanPrivateIdentifier(self: *Self) Token {
+ const start = self.pos;
+ self.advance();
+ while (self.ch()) |c| {
+ if (!isIdContinue(c)) break;
+ self.advance();
+ }
+ return .{
+ .kind = .private_identifier,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanRegex(self: *Self) Token {
+ const start = self.pos;
+ self.advance();
+
+ var in_class = false;
+ while (self.ch()) |c| {
+ if (c == '\\') {
+ self.advance();
+ if (self.ch()) |_| self.advance();
+ } else if (c == '[') {
+ in_class = true;
+ self.advance();
+ } else if (c == ']') {
+ in_class = false;
+ self.advance();
+ } else if (c == '/' and !in_class) {
+ self.advance();
+ break;
+ } else if (isLineTerminator(c)) {
+ break;
+ } else {
+ self.advance();
+ }
+ }
+
+ while (self.ch()) |c| {
+ if (!isIdContinue(c)) break;
+ self.advance();
+ }
+
+ return .{
+ .kind = .regex,
+ .loc = .{ .start = start, .end = self.pos },
+ .slice = self.source[start..self.pos],
+ };
+ }
+
+ fn scanPunctuator(self: *Self) Token {
+ const start = self.pos;
+ const c = self.ch().?;
+
+ switch (c) {
+ '{' => {
+ self.advance();
+ return simple(.lbrace, start);
+ },
+ '}' => {
+ self.advance();
+ return simple(.rbrace, start);
+ },
+ '(' => {
+ self.advance();
+ return simple(.lparen, start);
+ },
+ ')' => {
+ self.advance();
+ return simple(.rparen, start);
+ },
+ '[' => {
+ self.advance();
+ return simple(.lbracket, start);
+ },
+ ']' => {
+ self.advance();
+ return simple(.rbracket, start);
+ },
+ ';' => {
+ self.advance();
+ return simple(.semicolon, start);
+ },
+ ',' => {
+ self.advance();
+ return simple(.comma, start);
+ },
+ ':' => {
+ self.advance();
+ return simple(.@":", start);
+ },
+ '?' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '?') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@"??=", start);
+ }
+ }
+ return simple(.@"??", start);
+ }
+ if (n == '.') {
+ if (self.chAt(1)) |n2| {
+ if (!isDigit(n2)) {
+ self.advance();
+ return simple(.@"?.", start);
+ }
+ } else {
+ self.advance();
+ return simple(.@"?.", start);
+ }
+ }
+ }
+ return simple(.@"?", start);
+ },
+ '~' => {
+ self.advance();
+ return simple(.@"~", start);
+ },
+ '.' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '.') {
+ if (self.chAt(1)) |n2| {
+ if (n2 == '.') {
+ self.advance();
+ self.advance();
+ return simple(.@"...", start);
+ }
+ }
+ }
+ }
+ return simple(.@".", start);
+ },
+ '#' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (isIdStart(n)) {
+ return self.scanPrivateIdentifier();
+ }
+ }
+ return simple(.@"#", start);
+ },
+ '+' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '+') {
+ self.advance();
+ return simple(.@"++", start);
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@"+=", start);
+ }
+ }
+ return simple(.@"+", start);
+ },
+ '-' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '-') {
+ self.advance();
+ return simple(.@"--", start);
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@"-=", start);
+ }
+ }
+ return simple(.@"-", start);
+ },
+ '*' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '*') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@"**=", start);
+ }
+ }
+ return simple(.@"**", start);
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@"*=", start);
+ }
+ }
+ return simple(.@"*", start);
+ },
+ '%' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '=') {
+ self.advance();
+ return simple(.@"%=", start);
+ }
+ }
+ return simple(.@"%", start);
+ },
+ '=' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '=') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@"===", start);
+ }
+ }
+ return simple(.@"==", start);
+ }
+ if (n == '>') {
+ self.advance();
+ return simple(.@"=>", start);
+ }
+ }
+ return simple(.@"=", start);
+ },
+ '!' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '=') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@"!==", start);
+ }
+ }
+ return simple(.@"!=", start);
+ }
+ }
+ return simple(.@"!", start);
+ },
+ '<' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '<') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@"<<=", start);
+ }
+ }
+ return simple(.@"<<", start);
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@"<=", start);
+ }
+ }
+ return simple(.@"<", start);
+ },
+ '>' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '>') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '>') {
+ self.advance();
+ if (self.ch()) |n3| {
+ if (n3 == '=') {
+ self.advance();
+ return simple(.@">>>=", start);
+ }
+ }
+ return simple(.@">>>", start);
+ }
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@">>=", start);
+ }
+ }
+ return simple(.@">>", start);
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@">=", start);
+ }
+ }
+ return simple(.@">", start);
+ },
+ '&' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '&') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@"&&=", start);
+ }
+ }
+ return simple(.@"&&", start);
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@"&=", start);
+ }
+ }
+ return simple(.@"&", start);
+ },
+ '|' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '|') {
+ self.advance();
+ if (self.ch()) |n2| {
+ if (n2 == '=') {
+ self.advance();
+ return simple(.@"||=", start);
+ }
+ }
+ return simple(.@"||", start);
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@"|=", start);
+ }
+ }
+ return simple(.@"|", start);
+ },
+ '^' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '=') {
+ self.advance();
+ return simple(.@"^=", start);
+ }
+ }
+ return simple(.@"^", start);
+ },
+ '`' => {
+ self.advance();
+ return self.scanTemplateRest(start);
+ },
+ '\'' => return self.scanString('\''),
+ '"' => return self.scanString('"'),
+ '/' => {
+ self.advance();
+ if (self.ch()) |n| {
+ if (n == '/') {
+ self.skipSingleLineComment();
+ return self.next();
+ }
+ if (n == '*') {
+ self.skipMultiLineComment();
+ return self.next();
+ }
+ if (n == '=') {
+ self.advance();
+ return simple(.@"/=", start);
+ }
+ }
+ return simple(.@"/", start);
+ },
+ else => {
+ if (isLineTerminator(c) or isWhiteSpace(c)) {
+ self.skipWhiteSpace();
+ return self.next();
+ }
+ if (isDigit(c)) return self.scanNumber();
+ if (isIdStart(c)) return self.scanIdentifierOrKeyword();
+ if (c == '\\') {
+ self.advance();
+ return self.scanIdentifierOrKeyword();
+ }
+ self.advance();
+ return simple(.unknown, start);
+ },
+ }
+ }
+
+ fn simple(kind: TokenType, start: usize) Token {
+ return .{ .kind = kind, .loc = .{ .start = start, .end = start }, .slice = "" };
+ }
+
+ fn simpleWithSlice(comptime kind: TokenType, start: usize, slice: []const u8) Token {
+ return .{ .kind = kind, .loc = .{ .start = start, .end = start }, .slice = slice };
+ }
+
+ pub fn next(self: *Self) Token {
+ if (self.ch()) |c| {
+ _ = c;
+ // Handle hashbang at beginning
+ if (self.pos == 0) {
+ if (self.ch()) |c2| {
+ if (c2 == '#') {
+ self.skipHashbang();
+ return self.next();
+ }
+ }
+ }
+ return self.scanPunctuator();
+ }
+ return simple(.eof, self.pos);
+ }
+
+ fn keywordFromString(s: []const u8) TokenType {
+ const keywords = comptime keywords: {
+ const arr = struct {
+ const data = [_]struct { key: []const u8, val: TokenType }{
+ .{ .key = "await", .val = .await },
+ .{ .key = "break", .val = .@"break" },
+ .{ .key = "case", .val = .case },
+ .{ .key = "catch", .val = .@"catch" },
+ .{ .key = "class", .val = .class },
+ .{ .key = "const", .val = .@"const" },
+ .{ .key = "continue", .val = .@"continue" },
+ .{ .key = "debugger", .val = .debugger },
+ .{ .key = "default", .val = .default },
+ .{ .key = "delete", .val = .delete },
+ .{ .key = "do", .val = .do },
+ .{ .key = "else", .val = .@"else" },
+ .{ .key = "enum", .val = .@"enum" },
+ .{ .key = "export", .val = .@"export" },
+ .{ .key = "extends", .val = .extends },
+ .{ .key = "false", .val = .false },
+ .{ .key = "finally", .val = .finally },
+ .{ .key = "for", .val = .@"for" },
+ .{ .key = "function", .val = .function },
+ .{ .key = "if", .val = .@"if" },
+ .{ .key = "import", .val = .import },
+ .{ .key = "in", .val = .in },
+ .{ .key = "instanceof", .val = .instanceof },
+ .{ .key = "let", .val = .let },
+ .{ .key = "new", .val = .new },
+ .{ .key = "null", .val = .null },
+ .{ .key = "return", .val = .@"return" },
+ .{ .key = "super", .val = .super },
+ .{ .key = "switch", .val = .@"switch" },
+ .{ .key = "this", .val = .this },
+ .{ .key = "throw", .val = .throw },
+ .{ .key = "true", .val = .true },
+ .{ .key = "try", .val = .@"try" },
+ .{ .key = "typeof", .val = .typeof },
+ .{ .key = "var", .val = .@"var" },
+ .{ .key = "void", .val = .void },
+ .{ .key = "while", .val = .@"while" },
+ .{ .key = "with", .val = .with },
+ .{ .key = "yield", .val = .yield },
+ .{ .key = "using", .val = .using },
+ .{ .key = "async", .val = .async },
+ .{ .key = "static", .val = .static },
+ .{ .key = "get", .val = .get },
+ .{ .key = "set", .val = .set },
+ .{ .key = "of", .val = .of },
+ .{ .key = "from", .val = .from },
+ };
+ };
+ break :keywords arr.data;
+ };
+ inline for (keywords) |entry| {
+ if (std.mem.eql(u8, s, entry.key)) return entry.val;
+ }
+ return .identifier;
+ }
+
+ pub fn tokenizeComptime(comptime source: []const u8) []const Token {
+ comptime {
+ return tokenize(source);
+ }
+ }
+};
diff --git a/src/z/parser/js/root.zig b/src/z/parser/js/root.zig
new file mode 100644
index 0000000..565d572
--- /dev/null
+++ b/src/z/parser/js/root.zig
@@ -0,0 +1,85 @@
+const std = @import("std");
+
+pub const lexical_grammar = @import("lexical_grammar.zig");
+pub const ast = @import("ast.zig");
+
+test "simple literal" {
+ comptime {
+ _ = try ast.Program.parse("42;");
+ }
+}
+
+test "variable declaration" {
+ comptime {
+ _ = try ast.Program.parse("var x = 1;");
+ }
+}
+
+test "function declaration" {
+ comptime {
+ _ = try ast.Program.parse("function foo() { return 1; }");
+ }
+}
+
+test "if statement" {
+ comptime {
+ _ = try ast.Program.parse("if (x > 0) { x = 1; } else { x = 2; }");
+ }
+}
+
+test "binary expression" {
+ comptime {
+ _ = try ast.Program.parse("a + b * c;");
+ }
+}
+
+test "arrow function" {
+ comptime {
+ _ = try ast.Program.parse("const f = (x) => x + 1;");
+ }
+}
+
+test "class declaration" {
+ comptime {
+ _ = try ast.Program.parse("class Foo { constructor() { } }");
+ }
+}
+
+test "for loop" {
+ comptime {
+ _ = try ast.Program.parse("for (var i = 0; i < 10; i++) { break; }");
+ }
+}
+
+test "try catch" {
+ comptime {
+ _ = try ast.Program.parse("try { x; } catch (e) { y; }");
+ }
+}
+
+test "multiple statements" {
+ comptime {
+ _ = try ast.Program.parse("var a = 1; var b = 2; var c = a + b;");
+ }
+}
+
+test "comprehensive fixture" {
+ comptime {
+ _ = try ast.Program.parse(@embedFile("test_fixture.js"));
+ }
+}
+
+test "format fixture" {
+ comptime {
+ var buf: [65536]u8 = undefined;
+ const ast1 = try ast.Program.parse(@embedFile("test_fixture.js"));
+ var f = ast.Formatter{ .buf = buf[0..], .pos = 0, .indent_level = 0, .options = .{} };
+ ast1.fmt(&f);
+ const formatted = buf[0..f.pos];
+ try std.testing.expect(formatted.len > 0);
+ }
+}
+
+test {
+ _ = std.testing.refAllDecls(@This());
+}
diff --git a/src/z/parser/js/test_fixture.js b/src/z/parser/js/test_fixture.js
new file mode 100644
index 0000000..378ceb3
--- /dev/null
+++ b/src/z/parser/js/test_fixture.js
@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// comment line
+/* block
+ comment */
+var x = 42;
+let y = "hello";
+const z = `template ${x} literal`;
+let a = 0b1010;
+let b = 0xFF;
+let c = 0o77;
+let d = 123n;
+let e = /pattern/gi;
+let f = true;
+let g = null;
+function hello(a, b) {
+ if (a > b) {
+ return a;
+ } else {
+ return b;
+ }
+}
+const arrow = (x) => x * 2;
+const obj = {
+ a: 1,
+ b: "two",
+ c,
+ [d]: 4,
+ method() { return 5; },
+ get prop() { return 6; },
+ set prop(v) { },
+};
+const arr = [1, 2, ...rest, 4];
+for (var i = 0; i < 10; i++) {
+ continue;
+}
+for (const key in obj) {
+ break;
+}
+for (const val of arr) {
+ ;
+}
+while (x < 10) {
+ x++;
+}
+do {
+ x--;
+} while (x > 0);
+try {
+ throw "err";
+} catch (e) {
+ console.log(e);
+} finally {
+ cleanup();
+}
+switch (x) {
+ case 1:
+ break;
+ case 2:
+ return;
+ default:
+ break;
+}
+class Foo extends Bar {
+ constructor() { super(); }
+ static method() { }
+ get prop() { return 1; }
+ set prop(v) { }
+}
+const { a: p, b: q } = obj;
+const [head, ...tail] = arr;
+import { something } from "module";
+export default x;
+export const named = 1;
+export function exported() { }
+import "side-effect";
+import * as ns from "module";
+export { x as y } from "module";
+export * from "module";
+delete obj.a;
+typeof x;
+void x;
+x ?? y;
+x?.y?.z;
+x ??= y;
+x &&= y;
+x ||= y;
generated by cgit v1.2.3-70-g09d2 (git 2.53.0) at 2026-09-16 11:57:59 +0000