jsx wip

Author: srijan-paul

src/js/parser.zig

@@ -107,6 +107,7 @@ const ParseError = error{
     /// Invalid expression or pattern inside '(...)'
     InvalidExpressionInsideParens,
     // TODO: remove these two errors
+    JsxExpectedTagName,
     JsxNotImplemented,
     TypeScriptNotImplemented,
     // The parser instance has already been used
@@ -155,15 +156,19 @@ pub const SourceType = enum { script, module };
 pub const Config = struct {
     /// Whether we're parsing a script or a module.
     source_type: SourceType = .module,
-    /// Enable strict mode by default
+    /// Enable strict mode in the entire file
     strict_mode: bool = false,
     /// Enable JSX support
     jsx: bool = false,
     /// Enable typescript support
     typescript: bool = false,
     /// Add a special ast node for expressions wrapped in '()'.
-    /// Parses `(a)` as `parenthesized_expression {  identifier }` instead of  { identifier }
+    /// Parses `(a)` as `parenthesized_expression {  identifier }` instead of  '{ identifier }'
     preserve_parens: bool = true,
+
+    pub fn isTsx(self: Config) bool {
+        return self.jsx and self.typescript;
+    }
 };
 
 allocator: std.mem.Allocator,
@@ -596,21 +601,22 @@ fn defaultImportSpecifier(self: *Self) Error!Node.Index {
 }
 
 fn importSpecifier(self: *Self) Error!Node.Index {
-    var name_token: TokenWithId = undefined; // assigned in the 'blk' block
-    const name = blk: {
+    const name, const name_token = blk: {
         if (self.isAtToken(.string_literal)) {
-            name_token = try self.next();
-            break :blk try self.stringLiteralFromToken(name_token.id);
+            const name_tok = try self.next();
+            break :blk .{ try self.stringLiteralFromToken(name_tok.id), name_tok };
         }
 
-        name_token = try self.expectIdOrKeyword();
+        const name_tok = try self.expectIdOrKeyword();
 
         // `import {foo as bar }` // <- `foo` is an identifier node
         // `import { foo }` // <- `foo` is a BINDING identifier node
-        break :blk try if (self.isAtToken(.kw_as))
-            self.identifier(name_token.id)
+        const name_node = try if (self.isAtToken(.kw_as))
+            self.identifier(name_tok.id)
         else
-            self.bindingIdentifier(name_token.id);
+            self.bindingIdentifier(name_tok.id);
+
+        break :blk .{ name_node, name_tok };
     };
 
     if (self.isAtToken(.kw_as) or !self.isIdentifier(name_token.token.tag)) {
@@ -637,6 +643,8 @@ fn importSpecifier(self: *Self) Error!Node.Index {
     );
 }
 
+/// A string literal or an identifier reference.
+/// https://262.ecma-international.org/15.0/index.html#prod-ModuleExportName
 fn moduleExportName(self: *Self) Error!Node.Index {
     if (self.isAtToken(.string_literal))
         return self.stringLiteral();
@@ -964,6 +972,9 @@ fn labeledOrExpressionStatement(self: *Self) Error!Node.Index {
     return self.expressionStatement();
 }
 
+/// https://262.ecma-international.org/15.0/index.html#prod-LabelledStatement
+/// LabeledStatement:
+///     LabelIdentifier ':' LabelledItem
 fn labeledStatement(self: *Self) Error!Node.Index {
     const label = try self.next();
     _ = try self.expectToken(.@":");
@@ -988,6 +999,10 @@ fn labeledStatement(self: *Self) Error!Node.Index {
     );
 }
 
+/// https://262.ecma-international.org/15.0/index.html#prod-LabelledItem
+/// LabelledItem:
+///     Statement
+///     FunctionDeclaration
 fn labeledItem(self: *Self) Error!Node.Index {
     if (self.isAtToken(.kw_function)) {
         const lookahead = try self.lookAhead();
@@ -1498,7 +1513,7 @@ fn forLoopIterator(self: *Self) Error!struct { ForLoopKind, ast.Node.Index } {
     // for (var/let/const x = 0; x < 10; x++)
     // for (var/let/const x in y)
     // for (var/let/const x of y)
-    const maybe_decl_kw = blk: {
+    const maybe_vardecl_keyword = blk: {
         const curr = self.current.token.tag;
         if (curr == .kw_var or curr == .kw_const) {
             break :blk try self.next();
@@ -1512,7 +1527,7 @@ fn forLoopIterator(self: *Self) Error!struct { ForLoopKind, ast.Node.Index } {
         break :blk null;
     };
 
-    if (maybe_decl_kw) |decl_kw| {
+    if (maybe_vardecl_keyword) |decl_kw| {
         var loop_kind = ForLoopKind.basic;
         const iterator = try self.completeVarDeclLoopIterator(
             lpar.id,
@@ -1976,6 +1991,11 @@ fn catchClause(self: *Self) Error!Node.Index {
     }, catch_kw.id, self.nodeSpan(body).end);
 }
 
+/// https://262.ecma-international.org/15.0/index.html#prod-CatchParameter
+///
+/// CatchParameter:
+///     BindingIdentifier
+///     BindingPattern
 fn catchParameter(self: *Self) Error!?Node.Index {
     if (!self.isAtToken(.@"(")) return null;
     _ = try self.nextToken();
@@ -2033,12 +2053,8 @@ fn caseBlock(self: *Self) Error!ast.SubRange {
                 .kw_case => break :blk try self.caseClause(),
                 .kw_default => {
                     if (saw_default) {
-                        try self.emitDiagnostic(
-                            self.current.token.startCoord(self.source),
-                            "Multiple 'default' clauses are not allowed in a switch statement",
-                            .{},
-                        );
-                        return Error.MultipleDefaults;
+                        // TODO: emit this error and keep going. No need to stop parsing.
+                        return self.errorOnToken(self.current.token, ParseError.MultipleDefaults);
                     }
 
                     saw_default = true;
@@ -2521,6 +2537,7 @@ fn errorMessage(err: ParseError) []const u8 {
         ParseError.ExpectedImportSpecifier => "Expected an import specifier, '*', or file path",
         ParseError.InvalidExpressionInsideParens => "Invalid expression or pattern inside (...)",
         ParseError.RestElementNotLastInParams => "Rest element must be the last item in a function parameter list",
+        ParseError.JsxExpectedTagName => "Expected a tag name after '<' in JSX code",
     };
 }
 
@@ -2804,15 +2821,35 @@ fn expect2(self: *Self, tag1: Token.Tag, tag2: Token.Tag) Error!TokenWithId {
     return Error.UnexpectedToken;
 }
 
-/// Consume the next token from the lexer, skipping all comments.
+/// Consume the next token from the lexer, skipping all comments and whitespaces.
+/// Returns the CURRENT token which was consumed in the previous call to 'next',
+/// and advances the pointer to the next token.
 fn next(self: *Self) Error!TokenWithId {
     var next_token = try self.tokenizer.next();
-    while (next_token.tag == .comment or
-        next_token.tag == .whitespace) : (next_token = try self.tokenizer.next())
-    {
+    while (next_token.tag == .comment or next_token.tag == .whitespace) {
+        try self.saveToken(next_token);
+        next_token = try self.tokenizer.next();
+    }
+
+    return self.advanceToToken(next_token);
+}
+
+/// Consume the next JSX token from the lexer, skipping all comments and whitespaces.
+///
+/// [is_inside_jsx_tags]: Whether we are currently inside JSX tags (i.e. between '<' and '>').
+fn nextJsx(self: *Self, is_inside_jsx_tags: bool) Error!TokenWithId {
+    var next_token = try self.tokenizer.nextJsx(is_inside_jsx_tags);
+    while (next_token.tag == .comment or next_token.tag == .whitespace) {
         try self.saveToken(next_token);
+        next_token = try self.tokenizer.nextJsx(is_inside_jsx_tags);
     }
 
+    return self.advanceToToken(next_token);
+}
+
+/// Set [next_token] as the current token, and update `self.current`, and `self.prev_token_line`
+/// Returns the newly saved token along with its ID.
+fn advanceToToken(self: *Self, next_token: Token) error{OutOfMemory}!TokenWithId {
     try self.saveToken(next_token);
 
     const current = self.current.token;
@@ -2821,6 +2858,7 @@ fn next(self: *Self) Error!TokenWithId {
     self.current.token = next_token;
     self.current.id = @enumFromInt(self.tokens.items.len - 1);
     self.prev_token_line = current.line;
+
     return TokenWithId{ .token = current, .id = current_id };
 }
 
@@ -2847,7 +2885,7 @@ inline fn nextToken(self: *Self) Error!Token {
 /// without consuming it, or advancing in the source.
 ///
 /// NOTE: The token returned by this function should only be used for
-/// inspection, and never added to the AST.
+/// inspection, and should not be added to the AST.
 fn lookAhead(self: *Self) Error!Token {
     const line = self.tokenizer.line;
     const index = self.tokenizer.index;
@@ -2862,7 +2900,7 @@ fn lookAhead(self: *Self) Error!Token {
     return next_token;
 }
 
-inline fn peek(self: *Self) Token {
+fn peek(self: *Self) Token {
     return self.current.token;
 }
 
@@ -4288,7 +4326,10 @@ fn primaryExpression(self: *Self) Error!Node.Index {
         .@"(" => return self.groupingExprOrArrowParameters(&token),
         .kw_async => return self.asyncExpression(&token),
         .kw_function => return self.functionExpression(token.id, .{}),
-        else => {},
+        .@"<" => {},
+        else => {
+            // TODO: JSX
+        },
     }
 
     if (self.isKeywordIdentifier(token.token.tag)) {
@@ -4312,6 +4353,25 @@ fn primaryExpression(self: *Self) Error!Node.Index {
     return Error.UnexpectedToken;
 }
 
+fn jsxExpression(self: *Self) Error!void {
+    assert(self.current.token.tag == .@"<");
+    _ = try self.nextJsx(true);
+
+    if (self.isAtToken(.@">")) {
+        // TODO: implement jsx fragment
+        unreachable;
+    }
+
+    const jsx_identifier = try self.nextJsx(true);
+    if (jsx_identifier.token.tag != .jsx_identifier) {
+        return self.errorOnToken(jsx_identifier.token, ParseError.JsxExpectedTagName);
+    }
+}
+
+fn jsxFragment(_: *Self) Error!void {}
+fn jsxElement(_: *Self) Error!void {}
+fn jsxClosingElement(_: *Self) Error!void {}
+
 /// Check whether a numeric literal is valid in strict mode.
 /// Decimals and legacy octal literals are not allowed (e.g: 01, 09, 023127, etc.).
 fn isValidStrictModeNumber(self: *const Self, token: *const Token) bool {

src/js/token.zig

@@ -199,6 +199,8 @@ pub const JsTokenTag = enum(u32) {
     kw_from = 145 | Mask.ContextualKeyword,
     kw_of = 146 | Mask.ContextualKeyword,
 
+    jsx_text = 147,
+
     eof = 149,
 
     pub fn is(self: JsTokenTag, mask: u32) bool {