aboutsummaryrefslogtreecommitdiff
path: root/src/z/js
diff options
context:
space:
mode:
Diffstat (limited to 'src/z/js')
-rw-r--r--src/z/js/parser/ast.zig3334
-rw-r--r--src/z/js/parser/lexical_grammar.zig1137
-rw-r--r--src/z/js/parser/parser.zig68
-rw-r--r--src/z/js/parser/result.zig3
-rw-r--r--src/z/js/parser/root.zig89
-rw-r--r--src/z/js/parser/test_fixture.js86
6 files changed, 0 insertions, 4717 deletions
diff --git a/src/z/js/parser/ast.zig b/src/z/js/parser/ast.zig
deleted file mode 100644
index 3dc29a3..0000000
--- a/src/z/js/parser/ast.zig
+++ /dev/null
@@ -1,3334 +0,0 @@
-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/js/parser/lexical_grammar.zig b/src/z/js/parser/lexical_grammar.zig
deleted file mode 100644
index 2211fbe..0000000
--- a/src/z/js/parser/lexical_grammar.zig
+++ /dev/null
@@ -1,1137 +0,0 @@
-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/js/parser/parser.zig b/src/z/js/parser/parser.zig
deleted file mode 100644
index 050f8c1..0000000
--- a/src/z/js/parser/parser.zig
+++ /dev/null
@@ -1,68 +0,0 @@
-const std = @import("std");
-
-const root = @import("root.zig");
-const Result = root.Result;
-
-pub fn Parser(T: type) type {
- const R = Result(T);
-
- return struct {
- parse: *const fn ([]const u8) anyerror!R,
-
- pub fn parseAll(self: *const @This(), buffer: []const u8) !T {
- const value, const next = try self.parse(buffer);
-
- if (next.len > 0) {
- return error.NotExhaustive;
- }
-
- return value;
- }
-
- pub fn fromType(P: type) @This() {
- return .{ .parse = P.parse };
- }
-
- pub fn variants(V: type) @This() {
- if (@typeInfo(T) != .@"union") {
- @compileError("variants is only allowed with an union as result type");
- }
-
- return .{
- .parse = struct {
- fn parse(buffer: []const u8) !R {
- inline for (std.meta.fields(T)) |field| {
- if (@field(V, field.name).parse(buffer)) |result| {
- const value, const next = result;
- return .{
- @unionInit(T, field.name, value),
- next,
- };
- } else |_| {}
- }
-
- return error.Variants;
- }
- }.parse,
- };
- }
-
- pub fn any(P: type, comptime parsers: []const struct { Parser(P), T }) @This() {
- return .{
- .parse = struct {
- fn parse(buffer: []const u8) !R {
- inline for (parsers) |pair| {
- const parser, const value = pair;
-
- if (parser.parse(buffer)) |result| {
- _, const next = result;
- return .{ value, next };
- } else |_| {}
- }
- return error.Any;
- }
- }.parse,
- };
- }
- };
-}
diff --git a/src/z/js/parser/result.zig b/src/z/js/parser/result.zig
deleted file mode 100644
index 106dabe..0000000
--- a/src/z/js/parser/result.zig
+++ /dev/null
@@ -1,3 +0,0 @@
-pub fn Result(T: type) type {
- return struct { T, []const u8 };
-}
diff --git a/src/z/js/parser/root.zig b/src/z/js/parser/root.zig
deleted file mode 100644
index af0a67d..0000000
--- a/src/z/js/parser/root.zig
+++ /dev/null
@@ -1,89 +0,0 @@
-const std = @import("std");
-
-pub const lexical_grammar = @import("lexical_grammar.zig");
-pub const ast = @import("ast.zig");
-
-
-pub const Result = @import("result.zig").Result;
-pub const Parser = @import("parser.zig").Parser;
-
-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/js/parser/test_fixture.js b/src/z/js/parser/test_fixture.js
deleted file mode 100644
index 378ceb3..0000000
--- a/src/z/js/parser/test_fixture.js
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/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:58:30 +0000