From ae90b3deea27f16c1e9d3d791f1cf21e342e45b5 Mon Sep 17 00:00:00 2001
From: Jarred Sumner <jarred@jarredsumner.com>
Date: Sat, 8 May 2021 20:48:20 -0700
Subject: Use try for errors during parsing so that backtracking can happen

Former-commit-id: 7d3b0e7daa374577b59f9b53c7663d767df2077d
---
 src/js_lexer.zig            |  509 ++++++++---------
 src/js_parser/js_parser.zig | 1263 ++++++++++++++++++++++---------------------
 src/json_parser.zig         |   42 +-
 3 files changed, 932 insertions(+), 882 deletions(-)

(limited to 'src')

diff --git a/src/js_lexer.zig b/src/js_lexer.zig
index 0cae6b0b4..4c758c6a4 100644
--- a/src/js_lexer.zig
+++ b/src/js_lexer.zig
@@ -34,6 +34,15 @@ pub const JSONOptions = struct {
 pub const Lexer = struct {
     const LexerType = @This();
 
+    pub const Error = error{
+        UTF8Fail,
+        OutOfMemory,
+        SyntaxError,
+        UnexpectedSyntax,
+        JSONStringsMustUseDoubleQuotes,
+        ParserError,
+    };
+
     // pub const Error = error{
     //     UnexpectedToken,
     //     EndOfFile,
@@ -80,26 +89,28 @@ pub const Lexer = struct {
         return logger.usize2Loc(self.start);
     }
 
-    fn nextCodepointSlice(it: *LexerType) callconv(.Inline) ?[]const u8 {
+    fn nextCodepointSlice(it: *LexerType) callconv(.Inline) !?[]const u8 {
         if (it.current >= it.source.contents.len) {
             // without this line, strings cut off one before the last characte
             it.end = it.current;
             return null;
         }
 
-        const cp_len = unicode.utf8ByteSequenceLength(it.source.contents[it.current]) catch unreachable;
+        const cp_len = unicode.utf8ByteSequenceLength(it.source.contents[it.current]) catch return Error.UTF8Fail;
         it.end = it.current;
         it.current += cp_len;
 
         return it.source.contents[it.current - cp_len .. it.current];
     }
 
-    pub fn syntaxError(self: *LexerType) void {
+    pub fn syntaxError(self: *LexerType) !void {
         self.addError(self.start, "Syntax Error!!", .{}, true);
+        return Error.SyntaxError;
     }
 
-    pub fn addDefaultError(self: *LexerType, msg: []const u8) void {
+    pub fn addDefaultError(self: *LexerType, msg: []const u8) !void {
         self.addError(self.start, "{s}", .{msg}, true);
+        return Error.SyntaxError;
     }
 
     pub fn addError(self: *LexerType, _loc: usize, comptime format: []const u8, args: anytype, panic: bool) void {
@@ -114,7 +125,7 @@ pub const Lexer = struct {
         msg.formatNoWriter(Global.panic);
     }
 
-    pub fn addRangeError(self: *LexerType, r: logger.Range, comptime format: []const u8, args: anytype, panic: bool) void {
+    pub fn addRangeError(self: *LexerType, r: logger.Range, comptime format: []const u8, args: anytype, panic: bool) !void {
         if (self.prev_error_loc.eql(r.loc)) {
             return;
         }
@@ -124,12 +135,7 @@ pub const Lexer = struct {
         self.prev_error_loc = r.loc;
 
         if (panic) {
-            var fixedBuffer = [_]u8{0} ** 8096;
-            var stream = std.io.fixedBufferStream(&fixedBuffer);
-            const writer = stream.writer();
-            self.log.print(writer) catch unreachable;
-
-            Global.panic("{s}", .{fixedBuffer[0..stream.pos]});
+            return Error.ParserError;
         }
     }
 
@@ -145,8 +151,8 @@ pub const Lexer = struct {
         return @intCast(CodePoint, a) == self.code_point;
     }
 
-    fn nextCodepoint(it: *LexerType) callconv(.Inline) CodePoint {
-        const slice = it.nextCodepointSlice() orelse return @as(CodePoint, -1);
+    fn nextCodepoint(it: *LexerType) callconv(.Inline) !CodePoint {
+        const slice = (try it.nextCodepointSlice()) orelse return @as(CodePoint, -1);
 
         switch (slice.len) {
             1 => return @as(CodePoint, slice[0]),
@@ -159,14 +165,14 @@ pub const Lexer = struct {
 
     /// Look ahead at the next n codepoints without advancing the iterator.
     /// If fewer than n codepoints are available, then return the remainder of the string.
-    fn peek(it: *LexerType, n: usize) []const u8 {
+    fn peek(it: *LexerType, n: usize) !string {
         const original_i = it.current;
         defer it.current = original_i;
 
         var end_ix = original_i;
         var found: usize = 0;
         while (found < n) : (found += 1) {
-            const next_codepoint = it.nextCodepointSlice() orelse return it.source.contents[original_i..];
+            const next_codepoint = (try it.nextCodepointSlice()) orelse return it.source.contents[original_i..];
             end_ix += next_codepoint.len;
         }
 
@@ -185,7 +191,7 @@ pub const Lexer = struct {
         }
     }
 
-    fn parseStringLiteral(lexer: *LexerType) void {
+    fn parseStringLiteral(lexer: *LexerType) !void {
         var quote: CodePoint = lexer.code_point;
         var needs_slow_path = false;
         var suffixLen: usize = 1;
@@ -197,19 +203,19 @@ pub const Lexer = struct {
         } else {
             lexer.token = T.t_no_substitution_template_literal;
         }
-        lexer.step();
+        try lexer.step();
 
         stringLiteral: while (true) {
             switch (lexer.code_point) {
                 '\\' => {
                     needs_slow_path = true;
-                    lexer.step();
+                    try lexer.step();
 
                     // Handle Windows CRLF
                     if (lexer.code_point == '\r' and lexer.json_options != null) {
-                        lexer.step();
+                        try lexer.step();
                         if (lexer.code_point == '\n') {
-                            lexer.step();
+                            try lexer.step();
                         }
                         continue :stringLiteral;
                     }
@@ -217,12 +223,12 @@ pub const Lexer = struct {
                 // This indicates the end of the file
 
                 -1 => {
-                    lexer.addDefaultError("Unterminated string literal");
+                    try lexer.addDefaultError("Unterminated string literal");
                 },
 
                 '\r' => {
                     if (quote != '`') {
-                        lexer.addDefaultError("Unterminated string literal");
+                        try lexer.addDefaultError("Unterminated string literal");
                     }
 
                     // Template literals require newline normalization
@@ -231,16 +237,16 @@ pub const Lexer = struct {
 
                 '\n' => {
                     if (quote != '`') {
-                        lexer.addDefaultError("Unterminated string literal");
+                        try lexer.addDefaultError("Unterminated string literal");
                     }
                 },
 
                 '$' => {
                     if (quote == '`') {
-                        lexer.step();
+                        try lexer.step();
                         if (lexer.code_point == '{') {
                             suffixLen = 2;
-                            lexer.step();
+                            try lexer.step();
                             if (lexer.rescan_close_brace_as_template_token) {
                                 lexer.token = T.t_template_middle;
                             } else {
@@ -254,18 +260,18 @@ pub const Lexer = struct {
 
                 else => {
                     if (quote == lexer.code_point) {
-                        lexer.step();
+                        try lexer.step();
                         break :stringLiteral;
                     }
                     // Non-ASCII strings need the slow path
                     if (lexer.code_point >= 0x80) {
                         needs_slow_path = true;
                     } else if (lexer.json_options != null and lexer.code_point < 0x20) {
-                        lexer.syntaxError();
+                        try lexer.syntaxError();
                     }
                 },
             }
-            lexer.step();
+            try lexer.step();
         }
 
         // Reset string literal
@@ -283,7 +289,7 @@ pub const Lexer = struct {
         }
 
         if (quote == '\'' and lexer.json_options != null) {
-            lexer.addRangeError(lexer.range(), "JSON strings must use double quotes", .{}, true);
+            try lexer.addRangeError(lexer.range(), "JSON strings must use double quotes", .{}, true);
         }
         // for (text)
         // // if (needs_slow_path) {
@@ -296,8 +302,8 @@ pub const Lexer = struct {
         // // }
     }
 
-    fn step(lexer: *LexerType) void {
-        lexer.code_point = lexer.nextCodepoint();
+    fn step(lexer: *LexerType) !void {
+        lexer.code_point = try lexer.nextCodepoint();
 
         // Track the approximate number of newlines in the file so we can preallocate
         // the line offset table in the printer for source maps. The line offset table
@@ -310,29 +316,29 @@ pub const Lexer = struct {
         }
     }
 
-    pub fn expect(self: *LexerType, comptime token: T) void {
+    pub fn expect(self: *LexerType, comptime token: T) !void {
         if (self.token != token) {
-            self.expected(token);
+            try self.expected(token);
         }
 
-        self.next();
+        try self.next();
     }
 
-    pub fn expectOrInsertSemicolon(lexer: *LexerType) void {
+    pub fn expectOrInsertSemicolon(lexer: *LexerType) !void {
         if (lexer.token == T.t_semicolon or (!lexer.has_newline_before and
             lexer.token != T.t_close_brace and lexer.token != T.t_end_of_file))
         {
-            lexer.expect(T.t_semicolon);
+            try lexer.expect(T.t_semicolon);
         }
     }
 
-    pub fn addUnsupportedSyntaxError(self: *LexerType, msg: []const u8) void {
+    pub fn addUnsupportedSyntaxError(self: *LexerType, msg: []const u8) !void {
         self.addError(self.end, "Unsupported syntax: {s}", .{msg}, true);
+        return Error.SyntaxError;
     }
 
-    pub fn scanIdentifierWithEscapes(self: *LexerType) void {
-        self.addUnsupportedSyntaxError("escape sequence");
-        return;
+    pub fn scanIdentifierWithEscapes(self: *LexerType) !void {
+        try self.addUnsupportedSyntaxError("escape sequence");
     }
 
     pub fn debugInfo(self: *LexerType) void {
@@ -348,7 +354,7 @@ pub const Lexer = struct {
         }
     }
 
-    pub fn expectContextualKeyword(self: *LexerType, comptime keyword: string) void {
+    pub fn expectContextualKeyword(self: *LexerType, comptime keyword: string) !void {
         if (!self.isContextualKeyword(keyword)) {
             if (std.builtin.mode == std.builtin.Mode.Debug) {
                 self.addError(self.start, "Expected \"{s}\" but found \"{s}\" (token: {s})", .{
@@ -359,45 +365,46 @@ pub const Lexer = struct {
             } else {
                 self.addError(self.start, "Expected \"{s}\" but found \"{s}\"", .{ keyword, self.raw() }, true);
             }
+            return Error.UnexpectedSyntax;
         }
-        self.next();
+        try self.next();
     }
 
-    pub fn maybeExpandEquals(lexer: *LexerType) void {
+    pub fn maybeExpandEquals(lexer: *LexerType) !void {
         switch (lexer.code_point) {
             '>' => {
                 // "=" + ">" = "=>"
                 lexer.token = .t_equals_greater_than;
-                lexer.step();
+                try lexer.step();
             },
             '=' => {
                 // "=" + "=" = "=="
                 lexer.token = .t_equals_equals;
-                lexer.step();
+                try lexer.step();
 
                 if (lexer.code_point == '=') {
                     // "=" + "==" = "==="
                     lexer.token = .t_equals_equals_equals;
-                    lexer.step();
+                    try lexer.step();
                 }
             },
             else => {},
         }
     }
 
-    pub fn expectLessThan(lexer: *LexerType, is_inside_jsx_element: bool) void {
+    pub fn expectLessThan(lexer: *LexerType, is_inside_jsx_element: bool) !void {
         switch (lexer.token) {
             .t_less_than => {
                 if (is_inside_jsx_element) {
-                    lexer.nextInsideJSXElement();
+                    try lexer.nextInsideJSXElement();
                 } else {
-                    lexer.next();
+                    try lexer.next();
                 }
             },
             .t_less_than_equals => {
                 lexer.token = .t_equals;
                 lexer.start += 1;
-                lexer.maybeExpandEquals();
+                try lexer.maybeExpandEquals();
             },
             .t_less_than_less_than => {
                 lexer.token = .t_less_than;
@@ -408,7 +415,7 @@ pub const Lexer = struct {
                 lexer.start += 1;
             },
             else => {
-                lexer.expected(.t_less_than);
+                try lexer.expected(.t_less_than);
             },
         }
     }
@@ -419,13 +426,13 @@ pub const Lexer = struct {
                 if (is_inside_jsx_element) {
                     try lexer.nextInsideJSXElement();
                 } else {
-                    lexer.next();
+                    try lexer.next();
                 }
             },
             .t_greater_than_equals => {
                 lexer.token = .t_equals;
                 lexer.start += 1;
-                lexer.maybeExpandEquals();
+                try lexer.maybeExpandEquals();
             },
             .t_greater_than_greater_than => {
                 lexer.token = .t_greater_than;
@@ -440,12 +447,12 @@ pub const Lexer = struct {
                 lexer.start += 1;
             },
             else => {
-                lexer.expected(.t_greater_than);
+                try lexer.expected(.t_greater_than);
             },
         }
     }
 
-    pub fn next(lexer: *LexerType) void {
+    pub fn next(lexer: *LexerType) !void {
         lexer.has_newline_before = lexer.end == 0;
 
         lex: while (true) {
@@ -459,23 +466,23 @@ pub const Lexer = struct {
 
                 '#' => {
                     if (lexer.start == 0 and lexer.source.contents[1] == '!') {
-                        lexer.addUnsupportedSyntaxError("#!hashbang is not supported yet.");
+                        try lexer.addUnsupportedSyntaxError("#!hashbang is not supported yet.");
                         return;
                     }
 
-                    lexer.step();
+                    try lexer.step();
                     if (!isIdentifierStart(lexer.code_point)) {
-                        lexer.syntaxError();
+                        try lexer.syntaxError();
                     }
-                    lexer.step();
+                    try lexer.step();
 
                     if (isIdentifierStart(lexer.code_point)) {
-                        lexer.step();
+                        try lexer.step();
                         while (isIdentifierContinue(lexer.code_point)) {
-                            lexer.step();
+                            try lexer.step();
                         }
                         if (lexer.code_point == '\\') {
-                            lexer.scanIdentifierWithEscapes();
+                            try lexer.scanIdentifierWithEscapes();
                             lexer.token = T.t_private_identifier;
                             // lexer.Identifier, lexer.Token = lexer.scanIdentifierWithEscapes(normalIdentifier);
                         } else {
@@ -486,67 +493,67 @@ pub const Lexer = struct {
                     }
                 },
                 '\r', '\n', 0x2028, 0x2029 => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.has_newline_before = true;
                     continue;
                 },
                 '\t', ' ' => {
-                    lexer.step();
+                    try lexer.step();
                     continue;
                 },
                 '(' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_open_paren;
                 },
                 ')' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_close_paren;
                 },
                 '[' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_open_bracket;
                 },
                 ']' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_close_bracket;
                 },
                 '{' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_open_brace;
                 },
                 '}' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_close_brace;
                 },
                 ',' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_comma;
                 },
                 ':' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_colon;
                 },
                 ';' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_semicolon;
                 },
                 '@' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_at;
                 },
                 '~' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = T.t_tilde;
                 },
                 '?' => {
                     // '?' or '?.' or '??' or '??='
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '?' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_question_question_equals;
                                 },
                                 else => {
@@ -564,7 +571,7 @@ pub const Lexer = struct {
                             if (current < contents.len) {
                                 const c = contents[current];
                                 if (c < '0' or c > '9') {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_question_dot;
                                 }
                             }
@@ -576,10 +583,10 @@ pub const Lexer = struct {
                 },
                 '%' => {
                     // '%' or '%='
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_percent_equals;
                         },
 
@@ -591,18 +598,18 @@ pub const Lexer = struct {
 
                 '&' => {
                     // '&' or '&=' or '&&' or '&&='
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_ampersand_equals;
                         },
 
                         '&' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_ampersand_ampersand_equals;
                                 },
 
@@ -620,17 +627,17 @@ pub const Lexer = struct {
                 '|' => {
 
                     // '|' or '|=' or '||' or '||='
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_bar_equals;
                         },
                         '|' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_bar_bar_equals;
                                 },
 
@@ -647,10 +654,10 @@ pub const Lexer = struct {
 
                 '^' => {
                     // '^' or '^='
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_caret_equals;
                         },
 
@@ -662,15 +669,15 @@ pub const Lexer = struct {
 
                 '+' => {
                     // '+' or '+=' or '++'
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_plus_equals;
                         },
 
                         '+' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_plus_plus;
                         },
 
@@ -682,18 +689,18 @@ pub const Lexer = struct {
 
                 '-' => {
                     // '+' or '+=' or '++'
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_minus_equals;
                         },
 
                         '-' => {
-                            lexer.step();
+                            try lexer.step();
 
                             if (lexer.code_point == '>' and lexer.has_newline_before) {
-                                lexer.step();
+                                try lexer.step();
                                 lexer.log.addRangeWarning(lexer.source, lexer.range(), "Treating \"-->\" as the start of a legacy HTML single-line comment") catch unreachable;
 
                                 singleLineHTMLCloseComment: while (true) {
@@ -706,7 +713,7 @@ pub const Lexer = struct {
                                         },
                                         else => {},
                                     }
-                                    lexer.step();
+                                    try lexer.step();
                                 }
                                 continue;
                             }
@@ -723,17 +730,17 @@ pub const Lexer = struct {
                 '*' => {
                     // '*' or '*=' or '**' or '**='
 
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = .t_asterisk_equals;
                         },
                         '*' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = .t_asterisk_asterisk_equals;
                                 },
                                 else => {
@@ -748,7 +755,7 @@ pub const Lexer = struct {
                 },
                 '/' => {
                     // '/' or '/=' or '//' or '/* ... */'
-                    lexer.step();
+                    try lexer.step();
 
                     if (lexer.for_global_name) {
                         lexer.token = .t_slash;
@@ -756,13 +763,13 @@ pub const Lexer = struct {
                     }
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = .t_slash_equals;
                         },
                         '/' => {
-                            lexer.step();
+                            try lexer.step();
                             singleLineComment: while (true) {
-                                lexer.step();
+                                try lexer.step();
                                 switch (lexer.code_point) {
                                     '\r', '\n', 0x2028, 0x2029 => {
                                         break :singleLineComment;
@@ -776,7 +783,7 @@ pub const Lexer = struct {
 
                             if (lexer.json_options) |json| {
                                 if (!json.allow_comments) {
-                                    lexer.addRangeError(lexer.range(), "JSON does not support comments", .{}, true);
+                                    try lexer.addRangeError(lexer.range(), "JSON does not support comments", .{}, true);
                                     return;
                                 }
                             }
@@ -784,19 +791,19 @@ pub const Lexer = struct {
                             continue;
                         },
                         '*' => {
-                            lexer.step();
+                            try lexer.step();
 
                             multiLineComment: while (true) {
                                 switch (lexer.code_point) {
                                     '*' => {
-                                        lexer.step();
+                                        try lexer.step();
                                         if (lexer.code_point == '/') {
-                                            lexer.step();
+                                            try lexer.step();
                                             break :multiLineComment;
                                         }
                                     },
                                     '\r', '\n', 0x2028, 0x2029 => {
-                                        lexer.step();
+                                        try lexer.step();
                                         lexer.has_newline_before = true;
                                     },
                                     -1 => {
@@ -804,13 +811,13 @@ pub const Lexer = struct {
                                         lexer.addError(lexer.start, "Expected \"*/\" to terminate multi-line comment", .{}, true);
                                     },
                                     else => {
-                                        lexer.step();
+                                        try lexer.step();
                                     },
                                 }
                             }
                             if (lexer.json_options) |json| {
                                 if (!json.allow_comments) {
-                                    lexer.addRangeError(lexer.range(), "JSON does not support comments", .{}, true);
+                                    try lexer.addRangeError(lexer.range(), "JSON does not support comments", .{}, true);
                                     return;
                                 }
                             }
@@ -825,18 +832,18 @@ pub const Lexer = struct {
 
                 '=' => {
                     // '=' or '=>' or '==' or '==='
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '>' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_equals_greater_than;
                         },
 
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_equals_equals_equals;
                                 },
 
@@ -854,18 +861,18 @@ pub const Lexer = struct {
 
                 '<' => {
                     // '<' or '<<' or '<=' or '<<=' or '<!--'
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_less_than_equals;
                         },
 
                         '<' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_less_than_less_than_equals;
                                 },
 
@@ -876,8 +883,8 @@ pub const Lexer = struct {
                         },
                         // Handle legacy HTML-style comments
                         '!' => {
-                            if (strings.eqlComptime(lexer.peek("--".len), "--")) {
-                                lexer.addUnsupportedSyntaxError("Legacy HTML comments not implemented yet!");
+                            if (strings.eqlComptime(try lexer.peek("--".len), "--")) {
+                                try lexer.addUnsupportedSyntaxError("Legacy HTML comments not implemented yet!");
                                 return;
                             }
 
@@ -892,25 +899,25 @@ pub const Lexer = struct {
 
                 '>' => {
                     // '>' or '>>' or '>>>' or '>=' or '>>=' or '>>>='
-                    lexer.step();
+                    try lexer.step();
 
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             lexer.token = T.t_greater_than_equals;
                         },
                         '>' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_greater_than_greater_than_equals;
                                 },
                                 '>' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     switch (lexer.code_point) {
                                         '=' => {
-                                            lexer.step();
+                                            try lexer.step();
                                             lexer.token = T.t_greater_than_greater_than_greater_than_equals;
                                         },
                                         else => {
@@ -931,13 +938,13 @@ pub const Lexer = struct {
 
                 '!' => {
                     // '!' or '!=' or '!=='
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '=' => {
-                            lexer.step();
+                            try lexer.step();
                             switch (lexer.code_point) {
                                 '=' => {
-                                    lexer.step();
+                                    try lexer.step();
                                     lexer.token = T.t_exclamation_equals_equals;
                                 },
 
@@ -953,17 +960,17 @@ pub const Lexer = struct {
                 },
 
                 '\'', '"', '`' => {
-                    lexer.parseStringLiteral();
+                    try lexer.parseStringLiteral();
                 },
 
                 '_', '$', 'a'...'z', 'A'...'Z' => {
-                    lexer.step();
+                    try lexer.step();
                     while (isIdentifierContinue(lexer.code_point)) {
-                        lexer.step();
+                        try lexer.step();
                     }
 
                     if (lexer.code_point == '\\') {
-                        lexer.scanIdentifierWithEscapes();
+                        try lexer.scanIdentifierWithEscapes();
                     } else {
                         const contents = lexer.raw();
                         lexer.identifier = contents;
@@ -973,24 +980,24 @@ pub const Lexer = struct {
 
                 '\\' => {
                     // TODO: normal
-                    lexer.scanIdentifierWithEscapes();
+                    try lexer.scanIdentifierWithEscapes();
                 },
 
                 '.', '0'...'9' => {
-                    lexer.parseNumericLiteralOrDot();
+                    try lexer.parseNumericLiteralOrDot();
                 },
 
                 else => {
                     // Check for unusual whitespace characters
                     if (isWhitespace(lexer.code_point)) {
-                        lexer.step();
+                        try lexer.step();
                         continue;
                     }
 
                     if (isIdentifierStart(lexer.code_point)) {
-                        lexer.step();
+                        try lexer.step();
                         while (isIdentifierContinue(lexer.code_point)) {
-                            lexer.step();
+                            try lexer.step();
                         }
                         if (lexer.code_point == '\\') {
 
@@ -1011,15 +1018,15 @@ pub const Lexer = struct {
         }
     }
 
-    pub fn expected(self: *LexerType, token: T) void {
+    pub fn expected(self: *LexerType, token: T) !void {
         if (tokenToString.get(token).len > 0) {
-            self.expectedString(tokenToString.get(token));
+            try self.expectedString(tokenToString.get(token));
         } else {
-            self.unexpected();
+            try self.unexpected();
         }
     }
 
-    pub fn unexpected(lexer: *LexerType) void {
+    pub fn unexpected(lexer: *LexerType) !void {
         const found = finder: {
             if (lexer.start == lexer.source.contents.len) {
                 break :finder "end of file";
@@ -1028,7 +1035,7 @@ pub const Lexer = struct {
             }
         };
 
-        lexer.addRangeError(lexer.range(), "Unexpected {s}", .{found}, true);
+        try lexer.addRangeError(lexer.range(), "Unexpected {s}", .{found}, true);
     }
 
     pub fn raw(self: *LexerType) []const u8 {
@@ -1039,7 +1046,7 @@ pub const Lexer = struct {
         return self.token == .t_identifier and strings.eqlComptime(self.raw(), keyword);
     }
 
-    pub fn expectedString(self: *LexerType, text: string) void {
+    pub fn expectedString(self: *LexerType, text: string) !void {
         const found = finder: {
             if (self.source.contents.len != self.start) {
                 break :finder self.raw();
@@ -1048,7 +1055,7 @@ pub const Lexer = struct {
             }
         };
 
-        self.addRangeError(self.range(), "Expected {s} but found {s}", .{ text, found }, true);
+        try self.addRangeError(self.range(), "Expected {s} but found {s}", .{ text, found }, true);
     }
 
     pub fn scanCommentText(lexer: *LexerType) void {
@@ -1100,8 +1107,8 @@ pub const Lexer = struct {
             .comments_to_preserve_before = std.ArrayList(js_ast.G.Comment).init(allocator),
             .for_global_name = true,
         };
-        lex.step();
-        lex.next();
+        try lex.step();
+        try lex.next();
 
         return lex;
     }
@@ -1122,8 +1129,8 @@ pub const Lexer = struct {
                 .allow_trailing_commas = true,
             },
         };
-        lex.step();
-        lex.next();
+        try lex.step();
+        try lex.next();
 
         return lex;
     }
@@ -1143,8 +1150,8 @@ pub const Lexer = struct {
                 .allow_trailing_commas = false,
             },
         };
-        lex.step();
-        lex.next();
+        try lex.step();
+        try lex.next();
 
         return lex;
     }
@@ -1161,37 +1168,37 @@ pub const Lexer = struct {
             .allocator = allocator,
             .comments_to_preserve_before = std.ArrayList(js_ast.G.Comment).init(allocator),
         };
-        lex.step();
-        lex.next();
+        try lex.step();
+        try lex.next();
 
         return lex;
     }
 
-    pub fn scanRegExp(lexer: *LexerType) void {
+    pub fn scanRegExp(lexer: *LexerType) !void {
         while (true) {
             switch (lexer.code_point) {
                 '/' => {
-                    lexer.step();
+                    try lexer.step();
                     while (isIdentifierContinue(lexer.code_point)) {
                         switch (lexer.code_point) {
                             'g', 'i', 'm', 's', 'u', 'y' => {
-                                lexer.step();
+                                try lexer.step();
                             },
                             else => {
-                                lexer.syntaxError();
+                                try lexer.syntaxError();
                             },
                         }
                     }
                 },
                 '[' => {
-                    lexer.step();
+                    try lexer.step();
                     while (lexer.code_point != ']') {
-                        lexer.scanRegExpValidateAndStep();
+                        try lexer.scanRegExpValidateAndStep();
                     }
-                    lexer.step();
+                    try lexer.step();
                 },
                 else => {
-                    lexer.scanRegExpValidateAndStep();
+                    try lexer.scanRegExpValidateAndStep();
                 },
             }
         }
@@ -1229,47 +1236,47 @@ pub const Lexer = struct {
                     lexer.token = .t_end_of_file;
                 },
                 '\r', '\n', 0x2028, 0x2029 => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.has_newline_before = true;
                     continue;
                 },
                 '\t', ' ' => {
-                    lexer.step();
+                    try lexer.step();
                     continue;
                 },
                 '.' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_dot;
                 },
                 '=' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_equals;
                 },
                 '{' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_open_brace;
                 },
                 '}' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_close_brace;
                 },
                 '<' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_less_than;
                 },
                 '>' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_greater_than;
                 },
                 '/' => {
                     // '/' or '//' or '/* ... */'
 
-                    lexer.step();
+                    try lexer.step();
                     switch (lexer.code_point) {
                         '/' => {
                             single_line_comment: {
                                 while (true) {
-                                    lexer.step();
+                                    try lexer.step();
                                     switch (lexer.code_point) {
                                         '\r', '\n', 0x2028, 0x2029 => {
                                             break :single_line_comment;
@@ -1284,20 +1291,20 @@ pub const Lexer = struct {
                             }
                         },
                         '*' => {
-                            lexer.step();
+                            try lexer.step();
                             const start_range = lexer.range();
                             multi_line_comment: {
                                 while (true) {
                                     switch (lexer.code_point) {
                                         '*' => {
-                                            lexer.step();
+                                            try lexer.step();
                                             if (lexer.code_point == '/') {
-                                                lexer.step();
+                                                try lexer.step();
                                                 break :multi_line_comment;
                                             }
                                         },
                                         '\r', '\n', 0x2028, 0x2029 => {
-                                            lexer.step();
+                                            try lexer.step();
                                             lexer.has_newline_before = true;
                                         },
                                         -1 => {
@@ -1305,7 +1312,7 @@ pub const Lexer = struct {
                                             lexer.addError(lexer.start, "Expected \"*/\" to terminate multi-line comment", .{}, true);
                                         },
                                         else => {
-                                            lexer.step();
+                                            try lexer.step();
                                         },
                                     }
                                 }
@@ -1318,23 +1325,23 @@ pub const Lexer = struct {
                     }
                 },
                 '\'' => {
-                    lexer.step();
+                    try lexer.step();
                     try lexer.parseJSXStringLiteral('\'');
                 },
                 '"' => {
-                    lexer.step();
+                    try lexer.step();
                     try lexer.parseJSXStringLiteral('"');
                 },
                 else => {
                     if (isWhitespace(lexer.code_point)) {
-                        lexer.step();
+                        try lexer.step();
                         continue;
                     }
 
                     if (isIdentifierStart(lexer.code_point)) {
-                        lexer.step();
+                        try lexer.step();
                         while (isIdentifierContinue(lexer.code_point) or lexer.code_point == '-') {
-                            lexer.step();
+                            try lexer.step();
                         }
 
                         // Parse JSX namespaces. These are not supported by React or TypeScript
@@ -1342,11 +1349,11 @@ pub const Lexer = struct {
                         // them. A namespaced name is just always turned into a string so you
                         // can't use this feature to reference JavaScript identifiers.
                         if (lexer.code_point == ':') {
-                            lexer.step();
+                            try lexer.step();
 
                             if (isIdentifierStart(lexer.code_point)) {
                                 while (isIdentifierStart(lexer.code_point) or lexer.code_point == '-') {
-                                    lexer.step();
+                                    try lexer.step();
                                 }
                             } else {
                                 lexer.addError(lexer.range().endI(), "Expected identifier after \"{s}\" in namespaced JSX name", .{lexer.raw()}, true);
@@ -1373,17 +1380,17 @@ pub const Lexer = struct {
         string_literal: while (true) {
             switch (lexer.code_point) {
                 -1 => {
-                    lexer.syntaxError();
+                    try lexer.syntaxError();
                 },
                 '&' => {
                     needs_decode = true;
-                    lexer.step();
+                    try lexer.step();
                 },
                 '\\' => {
                     backslash = logger.Range{ .loc = logger.Loc{
                         .start = @intCast(i32, lexer.end),
                     }, .len = 1 };
-                    lexer.step();
+                    try lexer.step();
                     continue;
                 },
                 quote => {
@@ -1391,7 +1398,7 @@ pub const Lexer = struct {
                         backslash.len += 1;
                         lexer.previous_backslash_quote_in_jsx = backslash;
                     }
-                    lexer.step();
+                    try lexer.step();
                     // not sure about this!
                     break :string_literal;
                 },
@@ -1400,7 +1407,7 @@ pub const Lexer = struct {
                     if (lexer.code_point >= 0x80) {
                         needs_decode = true;
                     }
-                    lexer.step();
+                    try lexer.step();
                 },
             }
             backslash = logger.Range.None;
@@ -1421,7 +1428,7 @@ pub const Lexer = struct {
 
     pub fn expectJSXElementChild(lexer: *LexerType, token: T) !void {
         if (lexer.token != token) {
-            lexer.expected(token);
+            try lexer.expected(token);
         }
 
         try lexer.nextJSXElementChild();
@@ -1440,11 +1447,11 @@ pub const Lexer = struct {
                     lexer.token = .t_end_of_file;
                 },
                 '{' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_open_brace;
                 },
                 '<' => {
-                    lexer.step();
+                    try lexer.step();
                     lexer.token = .t_less_than;
                 },
                 else => {
@@ -1453,11 +1460,11 @@ pub const Lexer = struct {
                     string_literal: while (true) {
                         switch (lexer.code_point) {
                             -1 => {
-                                lexer.syntaxError();
+                                try lexer.syntaxError();
                             },
                             '&', '\r', '\n', 0x2028, 0x2029 => {
                                 needs_fixing = true;
-                                lexer.step();
+                                try lexer.step();
                             },
                             '{', '<' => {
                                 break :string_literal;
@@ -1467,7 +1474,7 @@ pub const Lexer = struct {
                                 if (lexer.code_point >= 0x80) {
                                     needs_fixing = true;
                                 }
-                                lexer.step();
+                                try lexer.step();
                             },
                         }
                     }
@@ -1596,41 +1603,41 @@ pub const Lexer = struct {
     }
     pub fn expectInsideJSXElement(lexer: *LexerType, token: T) !void {
         if (lexer.token != token) {
-            lexer.expected(token);
+            try lexer.expected(token);
         }
 
         try lexer.nextInsideJSXElement();
     }
 
-    fn scanRegExpValidateAndStep(lexer: *LexerType) void {
+    fn scanRegExpValidateAndStep(lexer: *LexerType) !void {
         if (lexer.code_point == '\\') {
-            lexer.step();
+            try lexer.step();
         }
 
         switch (lexer.code_point) {
             '\r', '\n', 0x2028, 0x2029 => {
                 // Newlines aren't allowed in regular expressions
-                lexer.syntaxError();
+                try lexer.syntaxError();
             },
             -1 => { // EOF
-                lexer.syntaxError();
+                try lexer.syntaxError();
             },
             else => {
-                lexer.step();
+                try lexer.step();
             },
         }
     }
 
-    pub fn rescanCloseBraceAsTemplateToken(lexer: *LexerType) void {
+    pub fn rescanCloseBraceAsTemplateToken(lexer: *LexerType) !void {
         if (lexer.token != .t_close_brace) {
-            lexer.expected(.t_close_brace);
+            try lexer.expected(.t_close_brace);
         }
 
         lexer.rescan_close_brace_as_template_token = true;
         lexer.code_point = '`';
         lexer.current = lexer.end;
         lexer.end -= 1;
-        lexer.next();
+        try lexer.next();
         lexer.rescan_close_brace_as_template_token = false;
     }
 
@@ -1684,10 +1691,10 @@ pub const Lexer = struct {
         return bytes.toOwnedSliceLength(end + 1);
     }
 
-    fn parseNumericLiteralOrDot(lexer: *LexerType) void {
+    fn parseNumericLiteralOrDot(lexer: *LexerType) !void {
         // Number or dot;
         var first = lexer.code_point;
-        lexer.step();
+        try lexer.step();
 
         // Dot without a digit after it;
         if (first == '.' and (lexer.code_point < '0' or lexer.code_point > '9')) {
@@ -1696,8 +1703,8 @@ pub const Lexer = struct {
                 lexer.current < lexer.source.contents.len) and
                 lexer.source.contents[lexer.current] == '.')
             {
-                lexer.step();
-                lexer.step();
+                try lexer.step();
+                try lexer.step();
                 lexer.token = T.t_dot_dot_dot;
                 return;
             }
@@ -1745,7 +1752,7 @@ pub const Lexer = struct {
             var isInvalidLegacyOctalLiteral = false;
             lexer.number = 0;
             if (!lexer.is_legacy_octal_literal) {
-                lexer.step();
+                try lexer.step();
             }
 
             integerLiteral: while (true) {
@@ -1753,12 +1760,12 @@ pub const Lexer = struct {
                     '_' => {
                         // Cannot have multiple underscores in a row;
                         if (lastUnderscoreEnd > 0 and lexer.end == lastUnderscoreEnd + 1) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
 
                         // The first digit must exist;
                         if (isFirst or lexer.is_legacy_octal_literal) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
 
                         lastUnderscoreEnd = lexer.end;
@@ -1771,7 +1778,7 @@ pub const Lexer = struct {
 
                     '2', '3', '4', '5', '6', '7' => {
                         if (base == 2) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
                         lexer.number = lexer.number * base + float64(lexer.code_point - '0');
                     },
@@ -1779,34 +1786,34 @@ pub const Lexer = struct {
                         if (lexer.is_legacy_octal_literal) {
                             isInvalidLegacyOctalLiteral = true;
                         } else if (base < 10) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
                         lexer.number = lexer.number * base + float64(lexer.code_point - '0');
                     },
                     'A', 'B', 'C', 'D', 'E', 'F' => {
                         if (base != 16) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
                         lexer.number = lexer.number * base + float64(lexer.code_point + 10 - 'A');
                     },
 
                     'a', 'b', 'c', 'd', 'e', 'f' => {
                         if (base != 16) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
                         lexer.number = lexer.number * base + float64(lexer.code_point + 10 - 'a');
                     },
                     else => {
                         // The first digit must exist;
                         if (isFirst) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
 
                         break :integerLiteral;
                     },
                 }
 
-                lexer.step();
+                try lexer.step();
                 isFirst = false;
             }
 
@@ -1818,7 +1825,7 @@ pub const Lexer = struct {
 
                 // Can't use a leading zero for bigint literals;
                 if (isBigIntegerLiteral and lexer.is_legacy_octal_literal) {
-                    lexer.syntaxError();
+                    try lexer.syntaxError();
                 }
 
                 // Filter out underscores;
@@ -1857,18 +1864,18 @@ pub const Lexer = struct {
 
                     // Cannot have multiple underscores in a row;
                     if (lastUnderscoreEnd > 0 and lexer.end == lastUnderscoreEnd + 1) {
-                        lexer.syntaxError();
+                        try lexer.syntaxError();
                     }
 
                     // The specification forbids underscores in this case;
                     if (isInvalidLegacyOctalLiteral) {
-                        lexer.syntaxError();
+                        try lexer.syntaxError();
                     }
 
                     lastUnderscoreEnd = lexer.end;
                     underscoreCount += 1;
                 }
-                lexer.step();
+                try lexer.step();
             }
 
             // Fractional digits;
@@ -1876,13 +1883,13 @@ pub const Lexer = struct {
                 // An underscore must not come last;
                 if (lastUnderscoreEnd > 0 and lexer.end == lastUnderscoreEnd + 1) {
                     lexer.end -= 1;
-                    lexer.syntaxError();
+                    try lexer.syntaxError();
                 }
 
                 hasDotOrExponent = true;
-                lexer.step();
+                try lexer.step();
                 if (lexer.code_point == '_') {
-                    lexer.syntaxError();
+                    try lexer.syntaxError();
                 }
                 while (true) {
                     if (lexer.code_point < '0' or lexer.code_point > '9') {
@@ -1892,13 +1899,13 @@ pub const Lexer = struct {
 
                         // Cannot have multiple underscores in a row;
                         if (lastUnderscoreEnd > 0 and lexer.end == lastUnderscoreEnd + 1) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
 
                         lastUnderscoreEnd = lexer.end;
                         underscoreCount += 1;
                     }
-                    lexer.step();
+                    try lexer.step();
                 }
             }
 
@@ -1907,16 +1914,16 @@ pub const Lexer = struct {
                 // An underscore must not come last;
                 if (lastUnderscoreEnd > 0 and lexer.end == lastUnderscoreEnd + 1) {
                     lexer.end -= 1;
-                    lexer.syntaxError();
+                    try lexer.syntaxError();
                 }
 
                 hasDotOrExponent = true;
-                lexer.step();
+                try lexer.step();
                 if (lexer.code_point == '+' or lexer.code_point == '-') {
-                    lexer.step();
+                    try lexer.step();
                 }
                 if (lexer.code_point < '0' or lexer.code_point > '9') {
-                    lexer.syntaxError();
+                    try lexer.syntaxError();
                 }
                 while (true) {
                     if (lexer.code_point < '0' or lexer.code_point > '9') {
@@ -1926,13 +1933,13 @@ pub const Lexer = struct {
 
                         // Cannot have multiple underscores in a row;
                         if (lastUnderscoreEnd > 0 and lexer.end == lastUnderscoreEnd + 1) {
-                            lexer.syntaxError();
+                            try lexer.syntaxError();
                         }
 
                         lastUnderscoreEnd = lexer.end;
                         underscoreCount += 1;
                     }
-                    lexer.step();
+                    try lexer.step();
                 }
             }
 
@@ -1959,7 +1966,7 @@ pub const Lexer = struct {
             if (lexer.code_point == 'n' and !hasDotOrExponent) {
                 // The only bigint literal that can start with 0 is "0n"
                 if (text.len > 1 and first == '0') {
-                    lexer.syntaxError();
+                    try lexer.syntaxError();
                 }
 
                 // Store bigints as text to avoid precision loss;
@@ -1984,18 +1991,18 @@ pub const Lexer = struct {
         // An underscore must not come last;
         if (lastUnderscoreEnd > 0 and lexer.end == lastUnderscoreEnd + 1) {
             lexer.end -= 1;
-            lexer.syntaxError();
+            try lexer.syntaxError();
         }
 
         // Handle bigint literals after the underscore-at-end check above;
         if (lexer.code_point == 'n' and !hasDotOrExponent) {
             lexer.token = T.t_big_integer_literal;
-            lexer.step();
+            try lexer.step();
         }
 
         // Identifiers can't occur immediately after numbers;
         if (isIdentifierStart(lexer.code_point)) {
-            lexer.syntaxError();
+            try lexer.syntaxError();
         }
     }
 };
@@ -2163,7 +2170,7 @@ fn test_lexer(contents: []const u8) Lexer {
 
 //     const source = logger.Source.initPathString("index.js", "for (let i = 0; i < 100; i++) { console.log('hi'); }", std.heap.page_allocator);
 //     var lex = try LexerType.init(log, source, alloc.dynamic);
-//     lex.next();
+//    try  lex.next();
 // }
 
 fn expectStr(lexer: *Lexer, expected: string, actual: string) void {
@@ -2183,27 +2190,27 @@ fn expectStr(lexer: *Lexer, expected: string, actual: string) void {
 test "Lexer.next() simple" {
     var lex = test_lexer("for (let i = 0; i < 100; i++) { }");
     expectStr(&lex, "\"for\"", tokenToString.get(lex.token));
-    lex.next();
+    try lex.next();
     expectStr(&lex, "\"(\"", tokenToString.get(lex.token));
-    lex.next();
+    try lex.next();
     expectStr(&lex, "let", lex.raw());
-    lex.next();
+    try lex.next();
     expectStr(&lex, "i", lex.raw());
-    lex.next();
+    try lex.next();
     expectStr(&lex, "=", lex.raw());
-    lex.next();
+    try lex.next();
     expectStr(&lex, "0", lex.raw());
-    lex.next();
+    try lex.next();
     expectStr(&lex, ";", lex.raw());
-    lex.next();
+    try lex.next();
     expectStr(&lex, "i", lex.raw());
-    lex.next();
+    try lex.next();
     std.testing.expect(lex.number == 0.0);
     expectStr(&lex, "<", lex.raw());
-    lex.next();
+    try lex.next();
     std.testing.expect(lex.number == 100.0);
     expectStr(&lex, "100", lex.raw());
-    lex.next();
+    try lex.next();
 }
 
 pub fn test_stringLiteralEquals(expected: string, source_text: string) void {
@@ -2221,7 +2228,7 @@ pub fn test_stringLiteralEquals(expected: string, source_text: string) void {
 
     var lex = try Lexer.init(&log, &source, std.heap.page_allocator);
     while (!lex.token.isString() and lex.token != .t_end_of_file) {
-        lex.next();
+        try lex.next();
     }
 
     var lit = std.unicode.utf16leToUtf8Alloc(std.heap.page_allocator, lex.string_literal) catch unreachable;
diff --git a/src/js_parser/js_parser.zig b/src/js_parser/js_parser.zig
index 5d353121d..962ffb810 100644
--- a/src/js_parser/js_parser.zig
+++ b/src/js_parser/js_parser.zig
@@ -1,5 +1,7 @@
 usingnamespace @import("imports.zig");
 
+const TemplatePartTuple = std.meta.Tuple(&[_]type{ []E.TemplatePart, logger.Loc });
+
 pub fn ExpressionTransposer(comptime ctx: type, visitor: fn (ptr: *ctx, arg: Expr, state: anytype) Expr) type {
     return struct {
         context: *Context,
@@ -2463,7 +2465,7 @@ pub const P = struct {
 
         if (is_generator) {
             // p.markSyntaxFeature(compat.Generator, p.lexer.Range())
-            p.lexer.next();
+            try p.lexer.next();
         } else if (is_async) {
             // p.markLoweredSyntaxFeature(compat.AsyncAwait, asyncRange, compat.Generator)
         }
@@ -2489,7 +2491,7 @@ pub const P = struct {
         if (!opts.is_name_optional or p.lexer.token == T.t_identifier) {
             var nameLoc = p.lexer.loc();
             nameText = p.lexer.identifier;
-            p.lexer.expect(T.t_identifier);
+            try p.lexer.expect(T.t_identifier);
             // Difference
             const ref = try p.newSymbol(Symbol.Kind.other, nameText);
             name = js_ast.LocRef{
@@ -2511,7 +2513,7 @@ pub const P = struct {
         }
 
         var scopeIndex = try p.pushScopeForParsePass(js_ast.Scope.Kind.function_args, p.lexer.loc());
-        var func = p.parseFn(name, FnOrArrowDataParse{
+        var func = try p.parseFn(name, FnOrArrowDataParse{
             .async_range = asyncRange,
             .allow_await = if (is_async) AwaitOrYield.allow_expr else AwaitOrYield.allow_ident,
             .allow_yield = if (is_generator) AwaitOrYield.allow_expr else AwaitOrYield.allow_ident,
@@ -2585,7 +2587,7 @@ pub const P = struct {
         _ = children.popOrNull();
     }
 
-    pub fn parseFn(p: *P, name: ?js_ast.LocRef, opts: FnOrArrowDataParse) G.Fn {
+    pub fn parseFn(p: *P, name: ?js_ast.LocRef, opts: FnOrArrowDataParse) anyerror!G.Fn {
         // if data.allowAwait and data.allowYield {
         // 	p.markSyntaxFeature(compat.AsyncGenerator, data.asyncRange)
         // }
@@ -2601,7 +2603,7 @@ pub const P = struct {
             .arguments_ref = null,
             .open_parens_loc = p.lexer.loc(),
         };
-        p.lexer.expect(T.t_open_paren);
+        try p.lexer.expect(T.t_open_paren);
 
         // Await and yield are not allowed in function arguments
         var old_fn_or_arrow_data = opts;
@@ -2614,34 +2616,34 @@ pub const P = struct {
         while (p.lexer.token != T.t_close_paren) {
             // Skip over "this" type annotations
             if (p.options.ts and p.lexer.token == T.t_this) {
-                p.lexer.next();
+                try p.lexer.next();
                 if (p.lexer.token == T.t_colon) {
-                    p.lexer.next();
+                    try p.lexer.next();
                     p.skipTypescriptType(js_ast.Op.Level.lowest);
                 }
                 if (p.lexer.token != T.t_comma) {
                     break;
                 }
 
-                p.lexer.next();
+                try p.lexer.next();
                 continue;
             }
 
             var ts_decorators: []ExprNodeIndex = undefined;
             if (opts.allow_ts_decorators) {
-                ts_decorators = p.parseTypeScriptDecorators();
+                ts_decorators = try p.parseTypeScriptDecorators();
             }
 
             if (!func.flags.has_rest_arg and p.lexer.token == T.t_dot_dot_dot) {
                 // p.markSyntaxFeature
-                p.lexer.next();
+                try p.lexer.next();
                 func.flags.has_rest_arg = true;
             }
 
             var is_typescript_ctor_field = false;
             var is_identifier = p.lexer.token == T.t_identifier;
             var text = p.lexer.identifier;
-            var arg = p.parseBinding();
+            var arg = try p.parseBinding();
 
             if (p.options.ts and is_identifier and opts.is_constructor) {
                 // Skip over TypeScript accessibility modifiers, which turn this argument
@@ -2658,12 +2660,12 @@ pub const P = struct {
 
                             // TypeScript requires an identifier binding
                             if (p.lexer.token != .t_identifier) {
-                                p.lexer.expect(.t_identifier);
+                                try p.lexer.expect(.t_identifier);
                             }
                             text = p.lexer.identifier;
 
                             // Re-parse the binding (the current binding is the TypeScript keyword)
-                            arg = p.parseBinding();
+                            arg = try p.parseBinding();
                         },
                         else => {
                             break;
@@ -2673,12 +2675,12 @@ pub const P = struct {
 
                 // "function foo(a?) {}"
                 if (p.lexer.token == .t_question) {
-                    p.lexer.next();
+                    try p.lexer.next();
                 }
 
                 // "function foo(a: any) {}"
                 if (p.lexer.token == .t_colon) {
-                    p.lexer.next();
+                    try p.lexer.next();
                     p.skipTypescriptType(.lowest);
                 }
             }
@@ -2689,8 +2691,8 @@ pub const P = struct {
             var default_value: ?ExprNodeIndex = null;
             if (!func.flags.has_rest_arg and p.lexer.token == .t_equals) {
                 // p.markSyntaxFeature
-                p.lexer.next();
-                default_value = p.parseExpr(.comma);
+                try p.lexer.next();
+                default_value = try p.parseExpr(.comma);
             }
 
             args.append(G.Arg{
@@ -2710,15 +2712,15 @@ pub const P = struct {
                 // JavaScript does not allow a comma after a rest argument
                 if (opts.is_typescript_declare) {
                     // TypeScript does allow a comma after a rest argument in a "declare" context
-                    p.lexer.next();
+                    try p.lexer.next();
                 } else {
-                    p.lexer.expect(.t_close_paren);
+                    try p.lexer.expect(.t_close_paren);
                 }
 
                 break;
             }
 
-            p.lexer.next();
+            try p.lexer.next();
         }
         func.args = args.toOwnedSlice();
 
@@ -2731,22 +2733,22 @@ pub const P = struct {
             p.symbols.items[func.arguments_ref.?.inner_index].must_not_be_renamed = true;
         }
 
-        p.lexer.expect(.t_close_paren);
+        try p.lexer.expect(.t_close_paren);
         p.fn_or_arrow_data_parse = old_fn_or_arrow_data;
 
         // "function foo(): any {}"
         if (p.options.ts and p.lexer.token == .t_colon) {
-            p.lexer.next();
+            try p.lexer.next();
             p.skipTypescriptReturnType();
         }
 
         // "function foo(): any;"
         if (opts.allow_missing_body_for_type_script and p.lexer.token != .t_open_brace) {
-            p.lexer.expectOrInsertSemicolon();
+            try p.lexer.expectOrInsertSemicolon();
             return func;
         }
         var tempOpts = opts;
-        func.body = p.parseFnBody(&tempOpts) catch unreachable;
+        func.body = try p.parseFnBody(&tempOpts);
 
         return func;
     }
@@ -2759,14 +2761,14 @@ pub const P = struct {
     }
 
     // TODO:
-    pub fn parseTypeScriptDecorators(p: *P) []ExprNodeIndex {
+    pub fn parseTypeScriptDecorators(p: *P) ![]ExprNodeIndex {
         if (!p.options.ts) {
             return &([_]ExprNodeIndex{});
         }
 
         var decorators = List(ExprNodeIndex).init(p.allocator);
         while (p.lexer.token == T.t_at) {
-            p.lexer.next();
+            try p.lexer.next();
 
             // Parse a new/call expression with "exprFlagTSDecorator" so we ignore
             // EIndex expressions, since they may be part of a computed property:
@@ -2776,7 +2778,7 @@ pub const P = struct {
             //   }
             //
             // This matches the behavior of the TypeScript compiler.
-            decorators.append(p.parseExprWithFlags(.new, Expr.EFlags.ts_decorator)) catch unreachable;
+            try decorators.append(try p.parseExprWithFlags(.new, Expr.EFlags.ts_decorator));
         }
 
         return decorators.toOwnedSlice();
@@ -2787,6 +2789,47 @@ pub const P = struct {
         notimpl();
     }
 
+    pub const TypescriptIdentifier = enum {
+        pub const Map = std.ComptimeStringMap(Kind, .{
+            .{ "unique", .unique },
+            .{ "abstract", .abstract },
+            .{ "asserts", .asserts },
+            .{ "keyof", .prefix },
+            .{ "readonly", .prefix },
+            .{ "infer", .prefix },
+            .{ "any", .primitive },
+            .{ "never", .primitive },
+            .{ "unknown", .primitive },
+            .{ "undefined", .primitive },
+            .{ "object", .primitive },
+            .{ "number", .primitive },
+            .{ "string", .primitive },
+            .{ "boolean", .primitive },
+            .{ "bigint", .primitive },
+            .{ "symbol", .primitive },
+        });
+        pub const Kind = enum {
+            normal,
+            unique,
+            abstract,
+            asserts,
+            prefix,
+            primitive,
+        };
+    };
+
+    pub fn skipTypeScriptBinding(p: *P) !void {
+        switch (p.lexer.token) {
+            .t_identifier, .t_this => {},
+            .t_open_bracket => {},
+            .t_open_brace => {},
+        }
+    }
+
+    pub fn skipTypescriptTypeWithOptions(p: *P, level: js_ast.Op.Level) void {
+        notimpl();
+    }
+
     // TODO:
     pub fn skipTypescriptTypeParameters(p: *P) void {
         notimpl();
@@ -2828,18 +2871,18 @@ pub const P = struct {
         }
 
         const name = LocRef{ .loc = p.lexer.loc(), .ref = try p.storeNameInRef(p.lexer.identifier) };
-        p.lexer.next();
+        try p.lexer.next();
         return name;
     }
 
-    pub fn parseClassStmt(p: *P, loc: logger.Loc, opts: *ParseStatementOptions) Stmt {
+    pub fn parseClassStmt(p: *P, loc: logger.Loc, opts: *ParseStatementOptions) !Stmt {
         var name: ?js_ast.LocRef = null;
         var class_keyword = p.lexer.range();
         if (p.lexer.token == .t_class) {
             //marksyntaxfeature
-            p.lexer.next();
+            try p.lexer.next();
         } else {
-            p.lexer.expected(.t_class);
+            try p.lexer.expected(.t_class);
         }
 
         var is_identifier = p.lexer.token == .t_identifier;
@@ -2849,10 +2892,10 @@ pub const P = struct {
             var name_loc = p.lexer.loc();
             var name_text = p.lexer.identifier;
             if (is_strict_modereserved_word) {
-                p.lexer.unexpected();
+                try p.lexer.unexpected();
             }
 
-            p.lexer.expect(.t_identifier);
+            try p.lexer.expect(.t_identifier);
             name = LocRef{ .loc = name_loc, .ref = null };
             if (!opts.is_typescript_declare) {
                 (name orelse unreachable).ref = p.declareSymbol(.class, name_loc, name_text) catch unreachable;
@@ -2872,7 +2915,7 @@ pub const P = struct {
         }
 
         var scope_index = p.pushScopeForParsePass(.class_name, loc) catch unreachable;
-        var class = p.parseClass(class_keyword, name, class_opts);
+        var class = try p.parseClass(class_keyword, name, class_opts);
 
         if (opts.is_typescript_declare) {
             p.popAndDiscardScope(scope_index);
@@ -2890,12 +2933,12 @@ pub const P = struct {
         }, loc);
     }
 
-    pub fn parseStmt(p: *P, opts: *ParseStatementOptions) !Stmt {
+    pub fn parseStmt(p: *P, opts: *ParseStatementOptions) anyerror!Stmt {
         var loc = p.lexer.loc();
 
         switch (p.lexer.token) {
             .t_semicolon => {
-                p.lexer.next();
+                try p.lexer.next();
                 return Stmt.empty();
             },
 
@@ -2904,9 +2947,9 @@ pub const P = struct {
                 if (opts.is_module_scope) {
                     p.es6_export_keyword = p.lexer.range();
                 } else if (!opts.is_namespace_scope) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
-                p.lexer.next();
+                try p.lexer.next();
 
                 // TypeScript decorators only work on class declarations
                 // "@decorator export class Foo {}"
@@ -2916,7 +2959,7 @@ pub const P = struct {
                 // "@decorator export declare class Foo {}"
                 // "@decorator export declare abstract class Foo {}"
                 if (opts.ts_decorators != null and p.lexer.token != js_lexer.T.t_class and p.lexer.token != js_lexer.T.t_default and !p.lexer.isContextualKeyword("abstract") and !p.lexer.isContextualKeyword("declare")) {
-                    p.lexer.expected(js_lexer.T.t_class);
+                    try p.lexer.expected(js_lexer.T.t_class);
                 }
 
                 switch (p.lexer.token) {
@@ -2932,12 +2975,12 @@ pub const P = struct {
                             return p.parseStmt(opts);
                         }
 
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                     },
 
                     T.t_enum => {
                         if (!p.options.ts) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                         }
 
                         opts.is_export = true;
@@ -2952,22 +2995,22 @@ pub const P = struct {
 
                         if (opts.is_typescript_declare and p.lexer.isContextualKeyword("as")) {
                             // "export as namespace ns;"
-                            p.lexer.next();
-                            p.lexer.expectContextualKeyword("namespace");
-                            p.lexer.expect(T.t_identifier);
-                            p.lexer.expectOrInsertSemicolon();
+                            try p.lexer.next();
+                            try p.lexer.expectContextualKeyword("namespace");
+                            try p.lexer.expect(T.t_identifier);
+                            try p.lexer.expectOrInsertSemicolon();
 
                             return p.s(S.TypeScript{}, loc);
                         }
 
                         if (p.lexer.isContextualKeyword("async")) {
                             var asyncRange = p.lexer.range();
-                            p.lexer.next();
+                            try p.lexer.next();
                             if (p.lexer.has_newline_before) {
                                 try p.log.addRangeError(p.source, asyncRange, "Unexpected newline after \"async\"");
                             }
 
-                            p.lexer.expect(T.t_function);
+                            try p.lexer.expect(T.t_function);
                             opts.is_export = true;
                             return try p.parseFnStmt(loc, opts, asyncRange);
                         }
@@ -2988,32 +3031,32 @@ pub const P = struct {
                             // }
                         }
 
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                         lexerpanic();
                     },
 
                     T.t_default => {
                         if (!opts.is_module_scope and (!opts.is_namespace_scope or !opts.is_typescript_declare)) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                             lexerpanic();
                         }
 
                         var defaultLoc = p.lexer.loc();
-                        p.lexer.next();
+                        try p.lexer.next();
 
                         // TypeScript decorators only work on class declarations
                         // "@decorator export default class Foo {}"
                         // "@decorator export default abstract class Foo {}"
                         if (opts.ts_decorators != null and p.lexer.token != T.t_class and !p.lexer.isContextualKeyword("abstract")) {
-                            p.lexer.expected(T.t_class);
+                            try p.lexer.expected(T.t_class);
                         }
 
                         if (p.lexer.isContextualKeyword("async")) {
                             var async_range = p.lexer.range();
-                            p.lexer.next();
+                            try p.lexer.next();
                             var defaultName: js_ast.LocRef = undefined;
                             if (p.lexer.token == T.t_function and !p.lexer.has_newline_before) {
-                                p.lexer.next();
+                                try p.lexer.next();
                                 var stmtOpts = ParseStatementOptions{
                                     .is_name_optional = true,
                                     .lexical_decl = .allow_all,
@@ -3037,8 +3080,8 @@ pub const P = struct {
                             defaultName = try createDefaultName(p, loc);
 
                             const prefix_expr = try p.parseAsyncPrefixExpr(async_range, Level.comma);
-                            var expr = p.parseSuffix(prefix_expr, Level.comma, null, Expr.EFlags.none);
-                            p.lexer.expectOrInsertSemicolon();
+                            var expr = try p.parseSuffix(prefix_expr, Level.comma, null, Expr.EFlags.none);
+                            try p.lexer.expectOrInsertSemicolon();
                             // this is probably a panic
                             var value = js_ast.StmtOrExpr{ .expr = expr };
                             return p.s(S.ExportDefault{ .default_name = defaultName, .value = value }, loc);
@@ -3050,7 +3093,7 @@ pub const P = struct {
                                 .is_name_optional = true,
                                 .lexical_decl = .allow_all,
                             };
-                            var stmt = p.parseStmt(&_opts) catch unreachable;
+                            var stmt = try p.parseStmt(&_opts);
 
                             const default_name: js_ast.LocRef = default_name_getter: {
                                 switch (stmt.data) {
@@ -3083,7 +3126,7 @@ pub const P = struct {
 
                         const is_identifier = p.lexer.token == .t_identifier;
                         const name = p.lexer.identifier;
-                        var expr = p.parseExpr(.comma);
+                        var expr = try p.parseExpr(.comma);
 
                         // Handle the default export of an abstract class in TypeScript
                         if (p.options.ts and is_identifier and (p.lexer.token == .t_class or opts.ts_decorators != null) and strings.eqlComptime(name, "abstract")) {
@@ -3093,7 +3136,7 @@ pub const P = struct {
                                         .ts_decorators = opts.ts_decorators,
                                         .is_name_optional = true,
                                     };
-                                    const stmt: Stmt = p.parseClassStmt(loc, &stmtOpts);
+                                    const stmt: Stmt = try p.parseClassStmt(loc, &stmtOpts);
 
                                     // Use the statement name if present, since it's a better name
                                     const default_name: js_ast.LocRef = default_name_getter: {
@@ -3127,15 +3170,15 @@ pub const P = struct {
                             }
                         }
 
-                        p.lexer.expectOrInsertSemicolon();
+                        try p.lexer.expectOrInsertSemicolon();
                         return p.s(S.ExportDefault{ .default_name = createDefaultName(p, loc) catch unreachable, .value = js_ast.StmtOrExpr{ .expr = expr } }, loc);
                     },
                     T.t_asterisk => {
                         if (!opts.is_module_scope and !(opts.is_namespace_scope or !opts.is_typescript_declare)) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                         }
 
-                        p.lexer.next();
+                        try p.lexer.next();
                         var namespace_ref: js_ast.Ref = undefined;
                         var alias: ?js_ast.G.ExportStarAlias = null;
                         var path_loc: logger.Loc = undefined;
@@ -3147,18 +3190,18 @@ pub const P = struct {
                             namespace_ref = p.storeNameInRef(name) catch unreachable;
                             alias = G.ExportStarAlias{ .loc = p.lexer.loc(), .original_name = name };
                             if (!p.lexer.isIdentifierOrKeyword()) {
-                                p.lexer.expect(.t_identifier);
+                                try p.lexer.expect(.t_identifier);
                             }
                             p.checkForNonBMPCodePoint((alias orelse unreachable).loc, name);
-                            p.lexer.next();
-                            p.lexer.expectContextualKeyword("from");
-                            const parsedPath = p.parsePath();
+                            try p.lexer.next();
+                            try p.lexer.expectContextualKeyword("from");
+                            const parsedPath = try p.parsePath();
                             path_loc = parsedPath.loc;
                             path_text = parsedPath.text;
                         } else {
                             // "export * from 'path'"
-                            p.lexer.expectContextualKeyword("from");
-                            const parsedPath = p.parsePath();
+                            try p.lexer.expectContextualKeyword("from");
+                            const parsedPath = try p.parsePath();
                             path_loc = parsedPath.loc;
                             path_text = parsedPath.text;
                             var path_name = fs.PathName.init(strings.append(p.allocator, path_text, "_star") catch unreachable);
@@ -3166,7 +3209,7 @@ pub const P = struct {
                         }
 
                         var import_record_index = p.addImportRecord(ImportKind.stmt, path_loc, path_text);
-                        p.lexer.expectOrInsertSemicolon();
+                        try p.lexer.expectOrInsertSemicolon();
                         return p.s(S.ExportStar{
                             .namespace_ref = namespace_ref,
                             .alias = alias,
@@ -3175,20 +3218,20 @@ pub const P = struct {
                     },
                     T.t_open_brace => {
                         if (!opts.is_module_scope and !(opts.is_namespace_scope or !opts.is_typescript_declare)) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                         }
 
                         const export_clause = try p.parseExportClause();
                         if (p.lexer.isContextualKeyword("from")) {
-                            p.lexer.expectContextualKeyword("from");
-                            const parsedPath = p.parsePath();
+                            try p.lexer.expectContextualKeyword("from");
+                            const parsedPath = try p.parsePath();
                             const import_record_index = p.addImportRecord(.stmt, parsedPath.loc, parsedPath.text);
                             var path_name = fs.PathName.init(strings.append(p.allocator, "import_", parsedPath.text) catch unreachable);
                             const namespace_ref = p.storeNameInRef(path_name.nonUniqueNameString(p.allocator) catch unreachable) catch unreachable;
-                            p.lexer.expectOrInsertSemicolon();
+                            try p.lexer.expectOrInsertSemicolon();
                             return p.s(S.ExportFrom{ .items = export_clause.clauses, .is_single_line = export_clause.is_single_line, .namespace_ref = namespace_ref, .import_record_index = import_record_index }, loc);
                         }
-                        p.lexer.expectOrInsertSemicolon();
+                        try p.lexer.expectOrInsertSemicolon();
                         return p.s(S.ExportClause{ .items = export_clause.clauses, .is_single_line = export_clause.is_single_line }, loc);
                     },
                     T.t_equals => {
@@ -3196,28 +3239,28 @@ pub const P = struct {
 
                         p.es6_export_keyword = previousExportKeyword; // This wasn't an ESM export statement after all
                         if (p.options.ts) {
-                            p.lexer.next();
-                            var value = p.parseExpr(.lowest);
-                            p.lexer.expectOrInsertSemicolon();
+                            try p.lexer.next();
+                            var value = try p.parseExpr(.lowest);
+                            try p.lexer.expectOrInsertSemicolon();
                             return p.s(S.ExportEquals{ .value = value }, loc);
                         }
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                         return Stmt.empty();
                     },
                     else => {
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                         return Stmt.empty();
                     },
                 }
             },
 
             .t_function => {
-                p.lexer.next();
-                return p.parseFnStmt(loc, opts, null);
+                try p.lexer.next();
+                return try p.parseFnStmt(loc, opts, null);
             },
             .t_enum => {
                 if (!p.options.ts) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
                 return p.parseTypescriptEnumStmt(loc, opts);
             },
@@ -3225,7 +3268,7 @@ pub const P = struct {
                 // Parse decorators before class statements, which are potentially exported
                 if (p.options.ts) {
                     const scope_index = p.scopes_in_order.items.len;
-                    const ts_decorators = p.parseTypeScriptDecorators();
+                    const ts_decorators = try p.parseTypeScriptDecorators();
 
                     // If this turns out to be a "declare class" statement, we need to undo the
                     // scopes that were potentially pushed while parsing the decorator arguments.
@@ -3252,7 +3295,7 @@ pub const P = struct {
                     // "@decorator export default class Foo {}"
                     // "@decorator export default abstract class Foo {}"
                     if (p.lexer.token != .t_class and p.lexer.token != .t_export and !p.lexer.isContextualKeyword("abstract") and !p.lexer.isContextualKeyword("declare")) {
-                        p.lexer.expected(.t_class);
+                        try p.lexer.expected(.t_class);
                     }
 
                     return p.parseStmt(opts);
@@ -3264,12 +3307,12 @@ pub const P = struct {
                     try p.forbidLexicalDecl(loc);
                 }
 
-                return p.parseClassStmt(loc, opts);
+                return try p.parseClassStmt(loc, opts);
             },
             .t_var => {
-                p.lexer.next();
-                const decls = p.parseAndDeclareDecls(.hoisted, opts);
-                p.lexer.expectOrInsertSemicolon();
+                try p.lexer.next();
+                const decls = try p.parseAndDeclareDecls(.hoisted, opts);
+                try p.lexer.expectOrInsertSemicolon();
                 return p.s(S.Local{ .kind = .k_var, .decls = decls, .is_export = opts.is_export }, loc);
             },
             .t_const => {
@@ -3278,14 +3321,14 @@ pub const P = struct {
                 }
                 // p.markSyntaxFeature(compat.Const, p.lexer.Range())
 
-                p.lexer.next();
+                try p.lexer.next();
 
                 if (p.options.ts and p.lexer.token == T.t_enum) {
                     return p.parseTypescriptEnumStmt(loc, opts);
                 }
 
-                const decls = p.parseAndDeclareDecls(.cconst, opts);
-                p.lexer.expectOrInsertSemicolon();
+                const decls = try p.parseAndDeclareDecls(.cconst, opts);
+                try p.lexer.expectOrInsertSemicolon();
 
                 if (!opts.is_typescript_declare) {
                     try p.requireInitializers(decls);
@@ -3294,21 +3337,21 @@ pub const P = struct {
                 return p.s(S.Local{ .kind = .k_const, .decls = decls, .is_export = opts.is_export }, loc);
             },
             .t_if => {
-                p.lexer.next();
-                p.lexer.expect(.t_open_paren);
-                const test_ = p.parseExpr(.lowest);
-                p.lexer.expect(.t_close_paren);
+                try p.lexer.next();
+                try p.lexer.expect(.t_open_paren);
+                const test_ = try p.parseExpr(.lowest);
+                try p.lexer.expect(.t_close_paren);
                 var stmtOpts = ParseStatementOptions{
                     .lexical_decl = .allow_fn_inside_if,
                 };
-                const yes = p.parseStmt(&stmtOpts) catch unreachable;
+                const yes = try p.parseStmt(&stmtOpts);
                 var no: ?Stmt = null;
                 if (p.lexer.token == .t_else) {
-                    p.lexer.next();
+                    try p.lexer.next();
                     stmtOpts = ParseStatementOptions{
                         .lexical_decl = .allow_fn_inside_if,
                     };
-                    no = p.parseStmt(&stmtOpts) catch unreachable;
+                    no = try p.parseStmt(&stmtOpts);
                 }
 
                 return p.s(S.If{
@@ -3318,30 +3361,30 @@ pub const P = struct {
                 }, loc);
             },
             .t_do => {
-                p.lexer.next();
+                try p.lexer.next();
                 var stmtOpts = ParseStatementOptions{};
-                const body = p.parseStmt(&stmtOpts) catch unreachable;
-                p.lexer.expect(.t_while);
-                p.lexer.expect(.t_open_paren);
-                const test_ = p.parseExpr(.lowest);
-                p.lexer.expect(.t_close_paren);
+                const body = try p.parseStmt(&stmtOpts);
+                try p.lexer.expect(.t_while);
+                try p.lexer.expect(.t_open_paren);
+                const test_ = try p.parseExpr(.lowest);
+                try p.lexer.expect(.t_close_paren);
 
                 // This is a weird corner case where automatic semicolon insertion applies
                 // even without a newline present
                 if (p.lexer.token == .t_semicolon) {
-                    p.lexer.next();
+                    try p.lexer.next();
                 }
                 return p.s(S.DoWhile{ .body = body, .test_ = test_ }, loc);
             },
             .t_while => {
-                p.lexer.next();
+                try p.lexer.next();
 
-                p.lexer.expect(.t_open_paren);
-                const test_ = p.parseExpr(.lowest);
-                p.lexer.expect(.t_close_paren);
+                try p.lexer.expect(.t_open_paren);
+                const test_ = try p.parseExpr(.lowest);
+                try p.lexer.expect(.t_close_paren);
 
                 var stmtOpts = ParseStatementOptions{};
-                const body = p.parseStmt(&stmtOpts) catch unreachable;
+                const body = try p.parseStmt(&stmtOpts);
 
                 return p.s(S.While{
                     .body = body,
@@ -3349,24 +3392,24 @@ pub const P = struct {
                 }, loc);
             },
             .t_with => {
-                p.lexer.next();
-                p.lexer.expect(.t_open_paren);
-                const test_ = p.parseExpr(.lowest);
+                try p.lexer.next();
+                try p.lexer.expect(.t_open_paren);
+                const test_ = try p.parseExpr(.lowest);
                 const body_loc = p.lexer.loc();
-                p.lexer.expect(.t_close_paren);
+                try p.lexer.expect(.t_close_paren);
             },
             .t_switch => {
-                p.lexer.next();
+                try p.lexer.next();
 
-                p.lexer.expect(.t_open_paren);
-                const test_ = p.parseExpr(.lowest);
-                p.lexer.expect(.t_close_paren);
+                try p.lexer.expect(.t_open_paren);
+                const test_ = try p.parseExpr(.lowest);
+                try p.lexer.expect(.t_close_paren);
 
                 const body_loc = p.lexer.loc();
                 _ = try p.pushScopeForParsePass(.block, body_loc);
                 defer p.popScope();
 
-                p.lexer.expect(.t_open_brace);
+                try p.lexer.expect(.t_open_brace);
                 var cases = List(js_ast.Case).init(p.allocator);
                 var foundDefault = false;
                 var stmtOpts = ParseStatementOptions{ .lexical_decl = .allow_all };
@@ -3381,12 +3424,12 @@ pub const P = struct {
                         }
 
                         foundDefault = true;
-                        p.lexer.next();
-                        p.lexer.expect(.t_colon);
+                        try p.lexer.next();
+                        try p.lexer.expect(.t_colon);
                     } else {
-                        p.lexer.expect(.t_case);
-                        value = p.parseExpr(.lowest);
-                        p.lexer.expect(.t_colon);
+                        try p.lexer.expect(.t_case);
+                        value = try p.parseExpr(.lowest);
+                        try p.lexer.expect(.t_colon);
                     }
 
                     caseBody: while (true) {
@@ -3396,24 +3439,24 @@ pub const P = struct {
                             },
                             else => {
                                 stmtOpts = ParseStatementOptions{ .lexical_decl = .allow_all };
-                                try body.append(p.parseStmt(&stmtOpts) catch unreachable);
+                                try body.append(try p.parseStmt(&stmtOpts));
                             },
                         }
                     }
                     try cases.append(js_ast.Case{ .value = value, .body = body.toOwnedSlice(), .loc = logger.Loc.Empty });
                 }
-                p.lexer.expect(.t_close_brace);
+                try p.lexer.expect(.t_close_brace);
                 return p.s(S.Switch{ .test_ = test_, .body_loc = body_loc, .cases = cases.toOwnedSlice() }, loc);
             },
             .t_try => {
-                p.lexer.next();
+                try p.lexer.next();
                 const body_loc = p.lexer.loc();
-                p.lexer.expect(.t_open_brace);
+                try p.lexer.expect(.t_open_brace);
                 _ = try p.pushScopeForParsePass(.block, loc);
                 var stmtOpts = ParseStatementOptions{};
-                const body = p.parseStmtsUpTo(.t_close_brace, &stmtOpts) catch unreachable;
+                const body = try p.parseStmtsUpTo(.t_close_brace, &stmtOpts);
                 p.popScope();
-                p.lexer.next();
+                try p.lexer.next();
 
                 var catch_: ?js_ast.Catch = null;
                 var finally: ?js_ast.Finally = null;
@@ -3421,22 +3464,22 @@ pub const P = struct {
                 if (p.lexer.token == .t_catch) {
                     const catch_loc = p.lexer.loc();
                     _ = try p.pushScopeForParsePass(.block, catch_loc);
-                    p.lexer.next();
+                    try p.lexer.next();
                     var binding: ?js_ast.Binding = null;
 
                     // The catch binding is optional, and can be omitted
                     // jarred: TIL!
                     if (p.lexer.token != .t_open_brace) {
-                        p.lexer.expect(.t_open_paren);
-                        const value = p.parseBinding();
+                        try p.lexer.expect(.t_open_paren);
+                        const value = try p.parseBinding();
 
                         // Skip over types
                         if (p.options.ts and p.lexer.token == .t_colon) {
-                            p.lexer.expect(.t_colon);
+                            try p.lexer.expect(.t_colon);
                             p.skipTypescriptType(.lowest);
                         }
 
-                        p.lexer.expect(.t_close_paren);
+                        try p.lexer.expect(.t_close_paren);
 
                         // Bare identifiers are a special case
                         var kind = Symbol.Kind.other;
@@ -3450,10 +3493,10 @@ pub const P = struct {
                         try p.declareBinding(kind, value, &stmtOpts);
                     }
 
-                    p.lexer.expect(.t_open_brace);
+                    try p.lexer.expect(.t_open_brace);
                     stmtOpts = ParseStatementOptions{};
-                    const stmts = p.parseStmtsUpTo(.t_close_brace, &stmtOpts) catch unreachable;
-                    p.lexer.next();
+                    const stmts = try p.parseStmtsUpTo(.t_close_brace, &stmtOpts);
+                    try p.lexer.next();
                     catch_ = js_ast.Catch{
                         .loc = catch_loc,
                         .binding = binding,
@@ -3465,11 +3508,11 @@ pub const P = struct {
                 if (p.lexer.token == .t_finally or catch_ == null) {
                     const finally_loc = p.lexer.loc();
                     _ = try p.pushScopeForParsePass(.block, finally_loc);
-                    p.lexer.expect(.t_finally);
-                    p.lexer.expect(.t_open_brace);
+                    try p.lexer.expect(.t_finally);
+                    try p.lexer.expect(.t_open_brace);
                     stmtOpts = ParseStatementOptions{};
-                    const stmts = p.parseStmtsUpTo(.t_close_brace, &stmtOpts) catch unreachable;
-                    p.lexer.next();
+                    const stmts = try p.parseStmtsUpTo(.t_close_brace, &stmtOpts);
+                    try p.lexer.next();
                     finally = js_ast.Finally{ .loc = finally_loc, .stmts = stmts };
                     p.popScope();
                 }
@@ -3483,7 +3526,7 @@ pub const P = struct {
                 _ = try p.pushScopeForParsePass(.block, loc);
                 defer p.popScope();
 
-                p.lexer.next();
+                try p.lexer.next();
 
                 // "for await (let x of y) {}"
                 var isForAwait = p.lexer.isContextualKeyword("await");
@@ -3500,10 +3543,10 @@ pub const P = struct {
                             // p.markSyntaxFeature(compat.TopLevelAwait, awaitRange)
                         }
                     }
-                    p.lexer.next();
+                    try p.lexer.next();
                 }
 
-                p.lexer.expect(.t_open_paren);
+                try p.lexer.expect(.t_open_paren);
 
                 var init_: ?Stmt = null;
                 var test_: ?Expr = null;
@@ -3524,16 +3567,16 @@ pub const P = struct {
                     // for (var )
                     .t_var => {
                         is_var = true;
-                        p.lexer.next();
+                        try p.lexer.next();
                         var stmtOpts = ParseStatementOptions{};
-                        decls = p.parseAndDeclareDecls(.hoisted, &stmtOpts);
+                        decls = try p.parseAndDeclareDecls(.hoisted, &stmtOpts);
                         init_ = p.s(S.Local{ .kind = .k_const, .decls = decls }, init_loc);
                     },
                     // for (const )
                     .t_const => {
-                        p.lexer.next();
+                        try p.lexer.next();
                         var stmtOpts = ParseStatementOptions{};
-                        decls = p.parseAndDeclareDecls(.cconst, &stmtOpts);
+                        decls = try p.parseAndDeclareDecls(.cconst, &stmtOpts);
                         init_ = p.s(S.Local{ .kind = .k_const, .decls = decls }, init_loc);
                     },
                     // for (;)
@@ -3568,29 +3611,29 @@ pub const P = struct {
 
                     if (isForAwait and !p.lexer.isContextualKeyword("of")) {
                         if (init_) |init_stmt| {
-                            p.lexer.expectedString("\"of\"");
+                            try p.lexer.expectedString("\"of\"");
                         } else {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                         }
                     }
 
                     try p.forbidInitializers(decls, "of", false);
-                    p.lexer.next();
-                    const value = p.parseExpr(.comma);
-                    p.lexer.expect(.t_close_paren);
+                    try p.lexer.next();
+                    const value = try p.parseExpr(.comma);
+                    try p.lexer.expect(.t_close_paren);
                     var stmtOpts = ParseStatementOptions{};
-                    const body = p.parseStmt(&stmtOpts) catch unreachable;
+                    const body = try p.parseStmt(&stmtOpts);
                     return p.s(S.ForOf{ .is_await = isForAwait, .init = init_ orelse unreachable, .value = value, .body = body }, loc);
                 }
 
                 // Detect for-in loops
                 if (p.lexer.token == .t_in) {
                     try p.forbidInitializers(decls, "in", false);
-                    p.lexer.next();
-                    const value = p.parseExpr(.comma);
-                    p.lexer.expect(.t_close_paren);
+                    try p.lexer.next();
+                    const value = try p.parseExpr(.comma);
+                    try p.lexer.expect(.t_close_paren);
                     var stmtOpts = ParseStatementOptions{};
-                    const body = p.parseStmt(&stmtOpts) catch unreachable;
+                    const body = try p.parseStmt(&stmtOpts);
                     return p.s(S.ForIn{ .init = init_ orelse unreachable, .value = value, .body = body }, loc);
                 }
 
@@ -3606,20 +3649,20 @@ pub const P = struct {
                     }
                 }
 
-                p.lexer.expect(.t_semicolon);
+                try p.lexer.expect(.t_semicolon);
                 if (p.lexer.token != .t_semicolon) {
-                    test_ = p.parseExpr(.lowest);
+                    test_ = try p.parseExpr(.lowest);
                 }
 
-                p.lexer.expect(.t_semicolon);
+                try p.lexer.expect(.t_semicolon);
 
                 if (p.lexer.token != .t_close_paren) {
-                    update = p.parseExpr(.lowest);
+                    update = try p.parseExpr(.lowest);
                 }
 
-                p.lexer.expect(.t_close_paren);
+                try p.lexer.expect(.t_close_paren);
                 var stmtOpts = ParseStatementOptions{};
-                const body = p.parseStmt(&stmtOpts) catch unreachable;
+                const body = try p.parseStmt(&stmtOpts);
                 return p.s(
                     S.For{ .init = init_, .test_ = test_, .update = update, .body = body },
                     loc,
@@ -3628,7 +3671,7 @@ pub const P = struct {
             .t_import => {
                 const previous_import_keyword = p.es6_import_keyword;
                 p.es6_import_keyword = p.lexer.range();
-                p.lexer.next();
+                try p.lexer.next();
                 var stmt: S.Import = S.Import{
                     .namespace_ref = undefined,
                     .import_record_index = std.math.maxInt(u32),
@@ -3637,7 +3680,7 @@ pub const P = struct {
 
                 // "export import foo = bar"
                 if ((opts.is_export or (opts.is_namespace_scope and !opts.is_typescript_declare)) and p.lexer.token != .t_identifier) {
-                    p.lexer.expected(.t_identifier);
+                    try p.lexer.expected(.t_identifier);
                 }
 
                 switch (p.lexer.token) {
@@ -3645,8 +3688,8 @@ pub const P = struct {
                     // "import.meta"
                     .t_open_paren, .t_dot => {
                         p.es6_import_keyword = previous_import_keyword; // this wasn't an esm import statement after all
-                        const expr = p.parseSuffix(p.parseImportExpr(loc, .lowest), .lowest, null, Expr.EFlags.none);
-                        p.lexer.expectOrInsertSemicolon();
+                        const expr = try p.parseSuffix(try p.parseImportExpr(loc, .lowest), .lowest, null, Expr.EFlags.none);
+                        try p.lexer.expectOrInsertSemicolon();
                         return p.s(S.SExpr{
                             .value = expr,
                         }, loc);
@@ -3654,7 +3697,7 @@ pub const P = struct {
                     .t_string_literal, .t_no_substitution_template_literal => {
                         // "import 'path'"
                         if (!opts.is_module_scope and (!opts.is_namespace_scope or !opts.is_typescript_declare)) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                             fail();
                         }
                         was_originally_bare_import = true;
@@ -3662,24 +3705,24 @@ pub const P = struct {
                     .t_asterisk => {
                         // "import * as ns from 'path'"
                         if (!opts.is_module_scope and (!opts.is_namespace_scope or !opts.is_typescript_declare)) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                             fail();
                         }
 
-                        p.lexer.next();
-                        p.lexer.expectContextualKeyword("as");
+                        try p.lexer.next();
+                        try p.lexer.expectContextualKeyword("as");
                         stmt = S.Import{
                             .namespace_ref = try p.storeNameInRef(p.lexer.identifier),
                             .star_name_loc = p.lexer.loc(),
                             .import_record_index = std.math.maxInt(u32),
                         };
-                        p.lexer.expect(.t_identifier);
-                        p.lexer.expectContextualKeyword("from");
+                        try p.lexer.expect(.t_identifier);
+                        try p.lexer.expectContextualKeyword("from");
                     },
                     .t_open_brace => {
                         // "import {item1, item2} from 'path'"
                         if (!opts.is_module_scope and (!opts.is_namespace_scope or !opts.is_typescript_declare)) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                             fail();
                         }
                         var importClause = try p.parseImportClause();
@@ -3689,13 +3732,13 @@ pub const P = struct {
                             .items = importClause.items,
                             .is_single_line = importClause.is_single_line,
                         };
-                        p.lexer.expectContextualKeyword("from");
+                        try p.lexer.expectContextualKeyword("from");
                     },
                     .t_identifier => {
                         // "import defaultItem from 'path'"
                         // "import foo = bar"
                         if (!opts.is_module_scope and (!opts.is_namespace_scope)) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                             fail();
                         }
 
@@ -3704,7 +3747,7 @@ pub const P = struct {
                             .loc = p.lexer.loc(),
                             .ref = try p.storeNameInRef(default_name),
                         } };
-                        p.lexer.next();
+                        try p.lexer.next();
 
                         if (p.options.ts) {
                             // Skip over type-only imports
@@ -3713,30 +3756,30 @@ pub const P = struct {
                                     .t_identifier => {
                                         if (!strings.eqlComptime(p.lexer.identifier, "from")) {
                                             // "import type foo from 'bar';"
-                                            p.lexer.next();
-                                            p.lexer.expectContextualKeyword("from");
-                                            _ = p.parsePath();
-                                            p.lexer.expectOrInsertSemicolon();
+                                            try p.lexer.next();
+                                            try p.lexer.expectContextualKeyword("from");
+                                            _ = try p.parsePath();
+                                            try p.lexer.expectOrInsertSemicolon();
                                             return p.s(S.TypeScript{}, loc);
                                         }
                                     },
                                     .t_asterisk => {
                                         // "import type * as foo from 'bar';"
-                                        p.lexer.next();
-                                        p.lexer.expectContextualKeyword("as");
-                                        p.lexer.expect(.t_identifier);
-                                        p.lexer.expectContextualKeyword("from");
-                                        _ = p.parsePath();
-                                        p.lexer.expectOrInsertSemicolon();
+                                        try p.lexer.next();
+                                        try p.lexer.expectContextualKeyword("as");
+                                        try p.lexer.expect(.t_identifier);
+                                        try p.lexer.expectContextualKeyword("from");
+                                        _ = try p.parsePath();
+                                        try p.lexer.expectOrInsertSemicolon();
                                         return p.s(S.TypeScript{}, loc);
                                     },
 
                                     .t_open_brace => {
                                         // "import type {foo} from 'bar';"
                                         _ = try p.parseImportClause();
-                                        p.lexer.expectContextualKeyword("from");
-                                        _ = p.parsePath();
-                                        p.lexer.expectOrInsertSemicolon();
+                                        try p.lexer.expectContextualKeyword("from");
+                                        _ = try p.parsePath();
+                                        try p.lexer.expectOrInsertSemicolon();
                                         return p.s(S.TypeScript{}, loc);
                                     },
                                     else => {},
@@ -3749,16 +3792,16 @@ pub const P = struct {
                         }
 
                         if (p.lexer.token == .t_comma) {
-                            p.lexer.next();
+                            try p.lexer.next();
 
                             switch (p.lexer.token) {
                                 // "import defaultItem, * as ns from 'path'"
                                 .t_asterisk => {
-                                    p.lexer.next();
-                                    p.lexer.expectContextualKeyword("as");
+                                    try p.lexer.next();
+                                    try p.lexer.expectContextualKeyword("as");
                                     stmt.namespace_ref = try p.storeNameInRef(p.lexer.identifier);
                                     stmt.star_name_loc = p.lexer.loc();
-                                    p.lexer.expect(.t_identifier);
+                                    try p.lexer.expect(.t_identifier);
                                 },
                                 // "import defaultItem, {item1, item2} from 'path'"
                                 .t_open_brace => {
@@ -3767,23 +3810,23 @@ pub const P = struct {
                                     stmt.is_single_line = importClause.is_single_line;
                                 },
                                 else => {
-                                    p.lexer.unexpected();
+                                    try p.lexer.unexpected();
                                 },
                             }
                         }
 
-                        p.lexer.expectContextualKeyword("from");
+                        try p.lexer.expectContextualKeyword("from");
                     },
                     else => {
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                         fail();
                     },
                 }
 
-                const path = p.parsePath();
+                const path = try p.parsePath();
                 stmt.import_record_index = p.addImportRecord(.stmt, path.loc, path.text);
                 p.import_records.items[stmt.import_record_index].was_originally_bare_import = was_originally_bare_import;
-                p.lexer.expectOrInsertSemicolon();
+                try p.lexer.expectOrInsertSemicolon();
 
                 if (stmt.star_name_loc) |star| {
                     stmt.namespace_ref = try p.declareSymbol(.import, star, p.loadNameFromRef(stmt.namespace_ref));
@@ -3822,56 +3865,56 @@ pub const P = struct {
                 return p.s(stmt, loc);
             },
             .t_break => {
-                p.lexer.next();
+                try p.lexer.next();
                 const name = try p.parseLabelName();
-                p.lexer.expectOrInsertSemicolon();
+                try p.lexer.expectOrInsertSemicolon();
                 return p.s(S.Break{ .label = name }, loc);
             },
             .t_continue => {
-                p.lexer.next();
+                try p.lexer.next();
                 const name = try p.parseLabelName();
-                p.lexer.expectOrInsertSemicolon();
+                try p.lexer.expectOrInsertSemicolon();
                 return p.s(S.Continue{ .label = name }, loc);
             },
             .t_return => {
-                p.lexer.next();
+                try p.lexer.next();
                 var value: ?Expr = null;
                 if ((p.lexer.token != .t_semicolon and
                     !p.lexer.has_newline_before and
                     p.lexer.token != .t_close_brace and
                     p.lexer.token != .t_end_of_file))
                 {
-                    value = p.parseExpr(.lowest);
+                    value = try p.parseExpr(.lowest);
                 }
                 p.latest_return_had_semicolon = p.lexer.token == .t_semicolon;
-                p.lexer.expectOrInsertSemicolon();
+                try p.lexer.expectOrInsertSemicolon();
 
                 return p.s(S.Return{ .value = value }, loc);
             },
             .t_throw => {
-                p.lexer.next();
+                try p.lexer.next();
                 if (p.lexer.has_newline_before) {
                     try p.log.addError(p.source, logger.Loc{
                         .start = loc.start + 5,
                     }, "Unexpected newline after \"throw\"");
                     fail();
                 }
-                const expr = p.parseExpr(.lowest);
-                p.lexer.expectOrInsertSemicolon();
+                const expr = try p.parseExpr(.lowest);
+                try p.lexer.expectOrInsertSemicolon();
                 return p.s(S.Throw{ .value = expr }, loc);
             },
             .t_debugger => {
-                p.lexer.next();
-                p.lexer.expectOrInsertSemicolon();
+                try p.lexer.next();
+                try p.lexer.expectOrInsertSemicolon();
                 return p.s(S.Debugger{}, loc);
             },
             .t_open_brace => {
                 _ = try p.pushScopeForParsePass(.block, loc);
                 defer p.popScope();
-                p.lexer.next();
+                try p.lexer.next();
                 var stmtOpts = ParseStatementOptions{};
-                const stmts = p.parseStmtsUpTo(.t_close_brace, &stmtOpts) catch unreachable;
-                p.lexer.next();
+                const stmts = try p.parseStmtsUpTo(.t_close_brace, &stmtOpts);
+                try p.lexer.next();
                 return p.s(S.Block{
                     .stmts = stmts,
                 }, loc);
@@ -3885,18 +3928,18 @@ pub const P = struct {
                 var expr: Expr = Expr{ .loc = loc, .data = Expr.Data{ .e_missing = &emiss } };
                 if (is_identifier and strings.eqlComptime(p.lexer.raw(), "async")) {
                     var async_range = p.lexer.range();
-                    p.lexer.next();
+                    try p.lexer.next();
                     if (p.lexer.token == .t_function and !p.lexer.has_newline_before) {
-                        p.lexer.next();
+                        try p.lexer.next();
                         return try p.parseFnStmt(async_range.loc, opts, async_range);
                     }
 
-                    expr = p.parseSuffix(try p.parseAsyncPrefixExpr(async_range, .lowest), .lowest, null, Expr.EFlags.none);
+                    expr = try p.parseSuffix(try p.parseAsyncPrefixExpr(async_range, .lowest), .lowest, null, Expr.EFlags.none);
                 } else {
                     const exprOrLet = try p.parseExprOrLetStmt(opts);
                     switch (exprOrLet.stmt_or_expr) {
                         .stmt => |stmt| {
-                            p.lexer.expectOrInsertSemicolon();
+                            try p.lexer.expectOrInsertSemicolon();
                             return stmt;
                         },
                         .expr => |_expr| {
@@ -3912,7 +3955,7 @@ pub const P = struct {
                                 defer p.popScope();
 
                                 // Parse a labeled statement
-                                p.lexer.next();
+                                try p.lexer.next();
 
                                 const _name = LocRef{ .loc = expr.loc, .ref = ident.ref };
                                 var nestedOpts = ParseStatementOptions{};
@@ -3923,7 +3966,7 @@ pub const P = struct {
                                     },
                                     else => {},
                                 }
-                                var stmt = p.parseStmt(&nestedOpts) catch unreachable;
+                                var stmt = try p.parseStmt(&nestedOpts);
                                 return p.s(S.Label{ .name = _name, .stmt = stmt }, loc);
                             }
                         },
@@ -3961,15 +4004,15 @@ pub const P = struct {
                                 },
                                 .ts_stmt_abstract => {
                                     if (p.lexer.token == .t_class or opts.ts_decorators != null) {
-                                        return p.parseClassStmt(loc, opts);
+                                        return try p.parseClassStmt(loc, opts);
                                     }
                                 },
                                 .ts_stmt_global => {
                                     // "declare module 'fs' { global { namespace NodeJS {} } }"
                                     if (opts.is_namespace_scope and opts.is_typescript_declare and p.lexer.token == .t_open_brace) {
-                                        p.lexer.next();
-                                        _ = p.parseStmtsUpTo(.t_close_brace, opts) catch unreachable;
-                                        p.lexer.next();
+                                        try p.lexer.next();
+                                        _ = try p.parseStmtsUpTo(.t_close_brace, opts);
+                                        try p.lexer.next();
                                         return p.s(S.TypeScript{}, loc);
                                     }
                                 },
@@ -3980,20 +4023,20 @@ pub const P = struct {
                                     // "@decorator declare class Foo {}"
                                     // "@decorator declare abstract class Foo {}"
                                     if (opts.ts_decorators != null and p.lexer.token != .t_class and !p.lexer.isContextualKeyword("abstract")) {
-                                        p.lexer.expected(.t_class);
+                                        try p.lexer.expected(.t_class);
                                     }
 
                                     // "declare global { ... }"
                                     if (p.lexer.isContextualKeyword("global")) {
-                                        p.lexer.next();
-                                        p.lexer.expect(.t_open_brace);
-                                        _ = p.parseStmtsUpTo(.t_close_brace, opts) catch unreachable;
-                                        p.lexer.next();
+                                        try p.lexer.next();
+                                        try p.lexer.expect(.t_open_brace);
+                                        _ = try p.parseStmtsUpTo(.t_close_brace, opts);
+                                        try p.lexer.next();
                                         return p.s(S.TypeScript{}, loc);
                                     }
 
                                     // "declare const x: any"
-                                    const stmt = p.parseStmt(opts) catch unreachable;
+                                    const stmt = try p.parseStmt(opts);
                                     if (opts.ts_decorators) |decs| {
                                         p.discardScopesUpTo(decs.scope_index);
                                     }
@@ -4047,7 +4090,7 @@ pub const P = struct {
                     }
                 }
                 // Output.print("\n\nmVALUE {s}:{s}\n", .{ expr, name });
-                p.lexer.expectOrInsertSemicolon();
+                try p.lexer.expectOrInsertSemicolon();
                 return p.s(S.SExpr{ .value = expr }, loc);
             },
         }
@@ -4113,7 +4156,7 @@ pub const P = struct {
 
         // The alias may be a keyword
         if (!p.lexer.isIdentifierOrKeyword()) {
-            p.lexer.expect(.t_identifier);
+            try p.lexer.expect(.t_identifier);
         }
 
         const alias = p.lexer.identifier;
@@ -4125,7 +4168,7 @@ pub const P = struct {
         p: *P,
     ) !ImportClause {
         var items = List(js_ast.ClauseItem).init(p.allocator);
-        p.lexer.expect(.t_open_brace);
+        try p.lexer.expect(.t_open_brace);
         var is_single_line = !p.lexer.has_newline_before;
 
         while (p.lexer.token != .t_close_brace) {
@@ -4135,16 +4178,16 @@ pub const P = struct {
             const alias = try p.parseClauseAlias("import");
             var name = LocRef{ .loc = alias_loc, .ref = try p.storeNameInRef(alias) };
             var original_name = alias;
-            p.lexer.next();
+            try p.lexer.next();
 
             if (p.lexer.isContextualKeyword("as")) {
-                p.lexer.next();
+                try p.lexer.next();
                 original_name = p.lexer.identifier;
                 name = LocRef{ .loc = alias_loc, .ref = try p.storeNameInRef(original_name) };
-                p.lexer.expect(.t_identifier);
+                try p.lexer.expect(.t_identifier);
             } else if (!isIdentifier) {
                 // An import where the name is a keyword must have an alias
-                p.lexer.expectedString("\"as\"");
+                try p.lexer.expectedString("\"as\"");
             }
 
             // Reject forbidden names
@@ -4168,7 +4211,7 @@ pub const P = struct {
                 is_single_line = false;
             }
 
-            p.lexer.next();
+            try p.lexer.next();
 
             if (p.lexer.has_newline_before) {
                 is_single_line = false;
@@ -4179,7 +4222,7 @@ pub const P = struct {
             is_single_line = false;
         }
 
-        p.lexer.expect(.t_close_brace);
+        try p.lexer.expect(.t_close_brace);
         return ImportClause{ .items = items.toOwnedSlice(), .is_single_line = is_single_line };
     }
 
@@ -4205,10 +4248,10 @@ pub const P = struct {
         var raw = p.lexer.raw();
         if (p.lexer.token != .t_identifier or !strings.eql(raw, "let")) {
             // Output.print("HI", .{});
-            return ExprOrLetStmt{ .stmt_or_expr = js_ast.StmtOrExpr{ .expr = p.parseExpr(.lowest) } };
+            return ExprOrLetStmt{ .stmt_or_expr = js_ast.StmtOrExpr{ .expr = try p.parseExpr(.lowest) } };
         }
 
-        p.lexer.next();
+        try p.lexer.next();
 
         switch (p.lexer.token) {
             .t_identifier, .t_open_bracket, .t_open_brace => {
@@ -4217,7 +4260,7 @@ pub const P = struct {
                         try p.forbidLexicalDecl(let_range.loc);
                     }
 
-                    const decls = p.parseAndDeclareDecls(.other, opts);
+                    const decls = try p.parseAndDeclareDecls(.other, opts);
                     return ExprOrLetStmt{
                         .stmt_or_expr = js_ast.StmtOrExpr{
                             .stmt = p.s(S.Local{
@@ -4235,7 +4278,7 @@ pub const P = struct {
 
         const ref = p.storeNameInRef(raw) catch unreachable;
         const expr = p.e(E.Identifier{ .ref = ref }, let_range.loc);
-        return ExprOrLetStmt{ .stmt_or_expr = js_ast.StmtOrExpr{ .expr = p.parseSuffix(expr, .lowest, null, Expr.EFlags.none) } };
+        return ExprOrLetStmt{ .stmt_or_expr = js_ast.StmtOrExpr{ .expr = try p.parseSuffix(expr, .lowest, null, Expr.EFlags.none) } };
     }
 
     pub fn requireInitializers(p: *P, decls: []G.Decl) !void {
@@ -4255,7 +4298,7 @@ pub const P = struct {
         }
     }
 
-    pub fn parseBinding(p: *P) Binding {
+    pub fn parseBinding(p: *P) anyerror!Binding {
         var loc = p.lexer.loc();
 
         switch (p.lexer.token) {
@@ -4267,11 +4310,11 @@ pub const P = struct {
                 }
 
                 const ref = p.storeNameInRef(name) catch unreachable;
-                p.lexer.next();
+                try p.lexer.next();
                 return p.b(B.Identifier{ .ref = ref }, loc);
             },
             .t_open_bracket => {
-                p.lexer.next();
+                try p.lexer.next();
                 var is_single_line = !p.lexer.has_newline_before;
                 var items = List(js_ast.ArrayBinding).init(p.allocator);
                 var has_spread = false;
@@ -4286,7 +4329,7 @@ pub const P = struct {
                         }) catch unreachable;
                     } else {
                         if (p.lexer.token == .t_dot_dot_dot) {
-                            p.lexer.next();
+                            try p.lexer.next();
                             has_spread = true;
 
                             // This was a bug in the ES2015 spec that was fixed in ES2016
@@ -4296,12 +4339,12 @@ pub const P = struct {
                             }
                         }
 
-                        const binding = p.parseBinding();
+                        const binding = try p.parseBinding();
 
                         var default_value: ?Expr = null;
                         if (!has_spread and p.lexer.token == .t_equals) {
-                            p.lexer.next();
-                            default_value = p.parseExpr(.comma);
+                            try p.lexer.next();
+                            default_value = try p.parseExpr(.comma);
                         }
 
                         items.append(js_ast.ArrayBinding{ .binding = binding, .default_value = default_value }) catch unreachable;
@@ -4320,7 +4363,7 @@ pub const P = struct {
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
                     }
-                    p.lexer.next();
+                    try p.lexer.next();
 
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
@@ -4331,7 +4374,7 @@ pub const P = struct {
                 if (p.lexer.has_newline_before) {
                     is_single_line = false;
                 }
-                p.lexer.expect(.t_close_bracket);
+                try p.lexer.expect(.t_close_bracket);
                 return p.b(B.Array{
                     .items = items.toOwnedSlice(),
                     .has_spread = has_spread,
@@ -4340,7 +4383,7 @@ pub const P = struct {
             },
             .t_open_brace => {
                 // p.markSyntaxFeature(compat.Destructuring, p.lexer.Range())
-                p.lexer.next();
+                try p.lexer.next();
                 var is_single_line = false;
                 var properties = List(js_ast.B.Property).init(p.allocator);
 
@@ -4349,7 +4392,7 @@ pub const P = struct {
                 p.allow_in = true;
 
                 while (p.lexer.token != .t_close_brace) {
-                    var property = p.parsePropertyBinding();
+                    var property = try p.parsePropertyBinding();
                     properties.append(property) catch unreachable;
 
                     // Commas after spread elements are not allowed
@@ -4365,7 +4408,7 @@ pub const P = struct {
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
                     }
-                    p.lexer.next();
+                    try p.lexer.next();
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
                     }
@@ -4376,7 +4419,7 @@ pub const P = struct {
                 if (p.lexer.has_newline_before) {
                     is_single_line = false;
                 }
-                p.lexer.expect(.t_close_brace);
+                try p.lexer.expect(.t_close_brace);
 
                 return p.b(B.Object{
                     .properties = properties.toOwnedSlice(),
@@ -4386,21 +4429,21 @@ pub const P = struct {
             else => {},
         }
 
-        p.lexer.expect(.t_identifier);
+        try p.lexer.expect(.t_identifier);
         return Binding{ .loc = loc, .data = Prefill.Data.BMissing };
     }
 
-    pub fn parsePropertyBinding(p: *P) B.Property {
+    pub fn parsePropertyBinding(p: *P) anyerror!B.Property {
         var key: js_ast.Expr = undefined;
         var is_computed = false;
 
         switch (p.lexer.token) {
             .t_dot_dot_dot => {
-                p.lexer.next();
+                try p.lexer.next();
                 const value = p.b(B.Identifier{
                     .ref = p.storeNameInRef(p.lexer.identifier) catch unreachable,
                 }, p.lexer.loc());
-                p.lexer.expect(.t_identifier);
+                try p.lexer.expect(.t_identifier);
                 return B.Property{
                     // This "key" diverges from esbuild, but is due to Go always having a zero value.
                     .key = Expr{ .data = Prefill.Data.EMissing, .loc = logger.Loc{} },
@@ -4414,33 +4457,33 @@ pub const P = struct {
                     .value = p.lexer.number,
                 }, p.lexer.loc());
                 // check for legacy octal literal
-                p.lexer.next();
+                try p.lexer.next();
             },
             .t_string_literal => {
-                key = p.parseStringLiteral();
+                key = try p.parseStringLiteral();
             },
             .t_big_integer_literal => {
                 key = p.e(E.BigInt{
                     .value = p.lexer.identifier,
                 }, p.lexer.loc());
                 // p.markSyntaxFeature(compat.BigInt, p.lexer.Range())
-                p.lexer.next();
+                try p.lexer.next();
             },
             .t_open_bracket => {
                 is_computed = true;
-                p.lexer.next();
-                key = p.parseExpr(.comma);
-                p.lexer.expect(.t_close_bracket);
+                try p.lexer.next();
+                key = try p.parseExpr(.comma);
+                try p.lexer.expect(.t_close_bracket);
             },
             else => {
                 const name = p.lexer.identifier;
                 const loc = p.lexer.loc();
 
                 if (!p.lexer.isIdentifierOrKeyword()) {
-                    p.lexer.expect(.t_identifier);
+                    try p.lexer.expect(.t_identifier);
                 }
 
-                p.lexer.next();
+                try p.lexer.next();
 
                 const ref = p.storeNameInRef(name) catch unreachable;
 
@@ -4452,8 +4495,8 @@ pub const P = struct {
                     const value = p.b(B.Identifier{ .ref = ref }, loc);
                     var default_value: ?Expr = null;
                     if (p.lexer.token == .t_equals) {
-                        p.lexer.next();
-                        default_value = p.parseExpr(.comma);
+                        try p.lexer.next();
+                        default_value = try p.parseExpr(.comma);
                     }
 
                     return B.Property{
@@ -4465,13 +4508,13 @@ pub const P = struct {
             },
         }
 
-        p.lexer.expect(.t_colon);
-        const value = p.parseBinding();
+        try p.lexer.expect(.t_colon);
+        const value = try p.parseBinding();
 
         var default_value: ?Expr = null;
         if (p.lexer.token == .t_equals) {
-            p.lexer.next();
-            default_value = p.parseExpr(.comma);
+            try p.lexer.next();
+            default_value = try p.parseExpr(.comma);
         }
 
         return B.Property{
@@ -4484,7 +4527,7 @@ pub const P = struct {
         };
     }
 
-    pub fn parseAndDeclareDecls(p: *P, kind: Symbol.Kind, opts: *ParseStatementOptions) []G.Decl {
+    pub fn parseAndDeclareDecls(p: *P, kind: Symbol.Kind, opts: *ParseStatementOptions) anyerror![]G.Decl {
         var decls = List(G.Decl).init(p.allocator);
 
         while (true) {
@@ -4494,7 +4537,7 @@ pub const P = struct {
             }
 
             var value: ?js_ast.Expr = null;
-            var local = p.parseBinding();
+            var local = try p.parseBinding();
             p.declareBinding(kind, local, opts) catch unreachable;
 
             // Skip over types
@@ -4502,19 +4545,19 @@ pub const P = struct {
                 // "let foo!"
                 var is_definite_assignment_assertion = p.lexer.token == .t_exclamation;
                 if (is_definite_assignment_assertion) {
-                    p.lexer.next();
+                    try p.lexer.next();
                 }
 
                 // "let foo: number"
                 if (is_definite_assignment_assertion or p.lexer.token == .t_colon) {
-                    p.lexer.expect(.t_colon);
+                    try p.lexer.expect(.t_colon);
                     p.skipTypescriptType(.lowest);
                 }
             }
 
             if (p.lexer.token == .t_equals) {
-                p.lexer.next();
-                value = p.parseExpr(.comma);
+                try p.lexer.next();
+                value = try p.parseExpr(.comma);
             }
 
             decls.append(G.Decl{
@@ -4525,7 +4568,7 @@ pub const P = struct {
             if (p.lexer.token != .t_comma) {
                 break;
             }
-            p.lexer.next();
+            try p.lexer.next();
         }
 
         return decls.items;
@@ -4539,7 +4582,7 @@ pub const P = struct {
     pub fn parseExportClause(p: *P) !ExportClauseResult {
         var items = List(js_ast.ClauseItem).initCapacity(p.allocator, 1) catch unreachable;
         var first_keyword_item_loc = logger.Loc{};
-        p.lexer.expect(.t_open_brace);
+        try p.lexer.expect(.t_open_brace);
         var is_single_line = !p.lexer.has_newline_before;
 
         while (p.lexer.token != .t_close_brace) {
@@ -4564,7 +4607,7 @@ pub const P = struct {
             //
             if (p.lexer.token != .t_identifier) {
                 if (!p.lexer.isIdentifierOrKeyword()) {
-                    p.lexer.expect(.t_identifier);
+                    try p.lexer.expect(.t_identifier);
                 }
                 if (first_keyword_item_loc.start < 0) {
                     first_keyword_item_loc = p.lexer.loc();
@@ -4572,14 +4615,14 @@ pub const P = struct {
             }
 
             p.checkForNonBMPCodePoint(alias_loc, alias);
-            p.lexer.next();
+            try p.lexer.next();
 
             if (p.lexer.isContextualKeyword("as")) {
-                p.lexer.next();
+                try p.lexer.next();
                 alias = try p.parseClauseAlias("export");
                 alias_loc = p.lexer.loc();
 
-                p.lexer.next();
+                try p.lexer.next();
             }
 
             items.append(js_ast.ClauseItem{
@@ -4597,7 +4640,7 @@ pub const P = struct {
             if (p.lexer.has_newline_before) {
                 is_single_line = false;
             }
-            p.lexer.next();
+            try p.lexer.next();
             if (p.lexer.has_newline_before) {
                 is_single_line = false;
             }
@@ -4606,13 +4649,13 @@ pub const P = struct {
         if (p.lexer.has_newline_before) {
             is_single_line = false;
         }
-        p.lexer.expect(.t_close_brace);
+        try p.lexer.expect(.t_close_brace);
 
         // Throw an error here if we found a keyword earlier and this isn't an
         // "export from" statement after all
         if (first_keyword_item_loc.start > -1 and !p.lexer.isContextualKeyword("from")) {
             const r = js_lexer.rangeOfIdentifier(p.source, first_keyword_item_loc);
-            p.lexer.addRangeError(r, "Expected identifier but found \"{s}\"", .{p.source.textForRange(r)}, true);
+            try p.lexer.addRangeError(r, "Expected identifier but found \"{s}\"", .{p.source.textForRange(r)}, true);
         }
 
         return ExportClauseResult{
@@ -4621,16 +4664,16 @@ pub const P = struct {
         };
     }
 
-    pub fn parsePath(p: *P) ParsedPath {
+    pub fn parsePath(p: *P) !ParsedPath {
         var path = ParsedPath{
             .loc = p.lexer.loc(),
             .text = p.lexer.string_literal_slice,
         };
 
         if (p.lexer.token == .t_no_substitution_template_literal) {
-            p.lexer.next();
+            try p.lexer.next();
         } else {
-            p.lexer.expect(.t_string_literal);
+            try p.lexer.expect(.t_string_literal);
         }
 
         return path;
@@ -4657,7 +4700,7 @@ pub const P = struct {
                 break;
             }
 
-            var stmt = p.parseStmt(opts) catch break :run;
+            var stmt = try p.parseStmt(opts);
 
             // Skip TypeScript types entirely
             if (p.options.ts) {
@@ -4877,11 +4920,11 @@ pub const P = struct {
     }
 
     pub fn parseFnExpr(p: *P, loc: logger.Loc, is_async: bool, async_range: logger.Range) !Expr {
-        p.lexer.next();
+        try p.lexer.next();
         const is_generator = p.lexer.token == T.t_asterisk;
         if (is_generator) {
             // p.markSyntaxFeature()
-            p.lexer.next();
+            try p.lexer.next();
         } else if (is_async) {
             // p.markLoweredSyntaxFeature(compat.AsyncAwait, asyncRange, compat.Generator)
         }
@@ -4903,14 +4946,14 @@ pub const P = struct {
                 (name orelse unreachable).ref = try p.newSymbol(.hoisted_function, p.lexer.identifier);
             }
             debug("FUNC NAME {s}", .{p.lexer.identifier});
-            p.lexer.next();
+            try p.lexer.next();
         }
 
         if (p.options.ts) {
             p.skipTypescriptTypeParameters();
         }
 
-        var func = p.parseFn(name, FnOrArrowDataParse{
+        var func = try p.parseFn(name, FnOrArrowDataParse{
             .async_range = async_range,
             .allow_await = if (is_async) .allow_expr else .allow_ident,
             .allow_yield = if (is_generator) .allow_expr else .allow_ident,
@@ -4933,10 +4976,10 @@ pub const P = struct {
         _ = try p.pushScopeForParsePass(Scope.Kind.function_body, p.lexer.loc());
         defer p.popScope();
 
-        p.lexer.expect(.t_open_brace);
+        try p.lexer.expect(.t_open_brace);
         var opts = ParseStatementOptions{};
-        const stmts = p.parseStmtsUpTo(.t_close_brace, &opts) catch unreachable;
-        p.lexer.next();
+        const stmts = try p.parseStmtsUpTo(.t_close_brace, &opts);
+        try p.lexer.next();
 
         p.allow_in = oldAllowIn;
         p.fn_or_arrow_data_parse = oldFnOrArrowData;
@@ -4952,7 +4995,7 @@ pub const P = struct {
             fail();
         }
 
-        p.lexer.expect(T.t_equals_greater_than);
+        try p.lexer.expect(T.t_equals_greater_than);
 
         for (args) |arg| {
             var opts = ParseStatementOptions{};
@@ -4974,7 +5017,7 @@ pub const P = struct {
         var old_fn_or_arrow_data = p.fn_or_arrow_data_parse;
 
         p.fn_or_arrow_data_parse = data.*;
-        var expr = p.parseExpr(Level.comma);
+        var expr = try p.parseExpr(Level.comma);
         p.fn_or_arrow_data_parse = old_fn_or_arrow_data;
 
         var stmts = try p.allocator.alloc(Stmt, 1);
@@ -5096,7 +5139,7 @@ pub const P = struct {
                             },
                             async_range.loc,
                         ) };
-                        p.lexer.next();
+                        try p.lexer.next();
 
                         _ = try p.pushScopeForParsePass(.function_args, async_range.loc);
                         defer p.popScope();
@@ -5113,7 +5156,7 @@ pub const P = struct {
                 // "async()"
                 // "async () => {}"
                 .t_open_paren => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     return p.parseParenExpr(async_range.loc, level, ParenExprOpts{ .is_async = true, .async_range = async_range });
                 },
 
@@ -5121,7 +5164,7 @@ pub const P = struct {
                 // "async <T>() => {}"
                 .t_less_than => {
                     if (p.options.ts and p.trySkipTypeScriptTypeParametersThenOpenParenWithBacktracking()) {
-                        p.lexer.next();
+                        try p.lexer.next();
                         return p.parseParenExpr(async_range.loc, level, ParenExprOpts{ .is_async = true, .async_range = async_range });
                     }
                 },
@@ -5142,21 +5185,21 @@ pub const P = struct {
         notimpl();
     }
 
-    pub fn parseExprOrBindings(p: *P, level: Level, errors: ?*DeferredErrors) Expr {
-        return p.parseExprCommon(level, errors, Expr.EFlags.none);
+    pub fn parseExprOrBindings(p: *P, level: Level, errors: ?*DeferredErrors) anyerror!Expr {
+        return try p.parseExprCommon(level, errors, Expr.EFlags.none);
     }
 
-    pub fn parseExpr(p: *P, level: Level) Expr {
-        return p.parseExprCommon(level, null, Expr.EFlags.none);
+    pub fn parseExpr(p: *P, level: Level) anyerror!Expr {
+        return try p.parseExprCommon(level, null, Expr.EFlags.none);
     }
 
-    pub fn parseExprWithFlags(p: *P, level: Level, flags: Expr.EFlags) Expr {
-        return p.parseExprCommon(level, null, flags);
+    pub fn parseExprWithFlags(p: *P, level: Level, flags: Expr.EFlags) anyerror!Expr {
+        return try p.parseExprCommon(level, null, flags);
     }
 
-    pub fn parseExprCommon(p: *P, level: Level, errors: ?*DeferredErrors, flags: Expr.EFlags) Expr {
+    pub fn parseExprCommon(p: *P, level: Level, errors: ?*DeferredErrors, flags: Expr.EFlags) anyerror!Expr {
         const had_pure_comment_before = p.lexer.has_pure_comment_before and !p.options.ignore_dce_annotations;
-        var expr = p.parsePrefix(level, errors, flags);
+        var expr = try p.parsePrefix(level, errors, flags);
 
         // There is no formal spec for "__PURE__" comments but from reverse-
         // engineering, it looks like they apply to the next CallExpression or
@@ -5164,7 +5207,7 @@ pub const P = struct {
         // to the expression "a().b()".
 
         if (had_pure_comment_before and level.lt(.call)) {
-            expr = p.parseSuffix(expr, @intToEnum(Level, @enumToInt(Level.call) - 1), errors, flags);
+            expr = try p.parseSuffix(expr, @intToEnum(Level, @enumToInt(Level.call) - 1), errors, flags);
             switch (expr.data) {
                 .e_call => |ex| {
                     ex.can_be_unwrapped_if_unused = true;
@@ -5176,7 +5219,7 @@ pub const P = struct {
             }
         }
 
-        return p.parseSuffix(expr, level, errors, flags);
+        return try p.parseSuffix(expr, level, errors, flags);
     }
 
     pub fn addImportRecord(p: *P, kind: ImportKind, loc: logger.Loc, name: string) u32 {
@@ -5273,9 +5316,9 @@ pub const P = struct {
 
         if (isStar) {
             if (p.lexer.has_newline_before) {
-                p.lexer.unexpected();
+                try p.lexer.unexpected();
             }
-            p.lexer.next();
+            try p.lexer.next();
         }
 
         var value: ?ExprNodeIndex = null;
@@ -5283,7 +5326,7 @@ pub const P = struct {
             .t_close_brace, .t_close_paren, .t_colon, .t_comma, .t_semicolon => {},
             else => {
                 if (isStar or !p.lexer.has_newline_before) {
-                    value = p.parseExpr(.yield);
+                    value = try p.parseExpr(.yield);
                 }
             },
         }
@@ -5294,7 +5337,7 @@ pub const P = struct {
         }, loc);
     }
 
-    pub fn parseProperty(p: *P, kind: Property.Kind, opts: *PropertyOpts, errors: ?*DeferredErrors) ?G.Property {
+    pub fn parseProperty(p: *P, kind: Property.Kind, opts: *PropertyOpts, errors: ?*DeferredErrors) anyerror!?G.Property {
         var key: Expr = undefined;
         var key_range = p.lexer.range();
         var is_computed = false;
@@ -5305,41 +5348,41 @@ pub const P = struct {
                     .value = p.lexer.number,
                 }, p.lexer.loc());
                 // p.checkForLegacyOctalLiteral()
-                p.lexer.next();
+                try p.lexer.next();
             },
             .t_string_literal => {
-                key = p.parseStringLiteral();
+                key = try p.parseStringLiteral();
             },
             .t_big_integer_literal => {
                 key = p.e(E.BigInt{ .value = p.lexer.identifier }, p.lexer.loc());
                 // markSyntaxFeature
-                p.lexer.next();
+                try p.lexer.next();
             },
             .t_private_identifier => {
                 if (!opts.is_class or opts.ts_decorators.len > 0) {
-                    p.lexer.expected(.t_identifier);
+                    try p.lexer.expected(.t_identifier);
                 }
 
                 key = p.e(E.PrivateIdentifier{ .ref = p.storeNameInRef(p.lexer.identifier) catch unreachable }, p.lexer.loc());
-                p.lexer.next();
+                try p.lexer.next();
             },
             .t_open_bracket => {
                 is_computed = true;
                 // p.markSyntaxFeature(compat.objectExtensions, p.lexer.range())
-                p.lexer.next();
+                try p.lexer.next();
                 const wasIdentifier = p.lexer.token == .t_identifier;
-                const expr = p.parseExpr(.comma);
+                const expr = try p.parseExpr(.comma);
 
                 // Handle index signatures
                 if (p.options.ts and p.lexer.token == .t_colon and wasIdentifier and opts.is_class) {
                     switch (expr.data) {
                         .e_identifier => |ident| {
-                            p.lexer.next();
+                            try p.lexer.next();
                             p.skipTypescriptType(.lowest);
-                            p.lexer.expect(.t_close_bracket);
-                            p.lexer.expect(.t_colon);
+                            try p.lexer.expect(.t_close_bracket);
+                            try p.lexer.expect(.t_colon);
                             p.skipTypescriptType(.lowest);
-                            p.lexer.expectOrInsertSemicolon();
+                            try p.lexer.expectOrInsertSemicolon();
 
                             // Skip this property entirely
                             return null;
@@ -5348,17 +5391,17 @@ pub const P = struct {
                     }
                 }
 
-                p.lexer.expect(.t_close_bracket);
+                try p.lexer.expect(.t_close_bracket);
                 key = expr;
             },
             .t_asterisk => {
                 if (kind != .normal or opts.is_generator) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
 
-                p.lexer.next();
+                try p.lexer.next();
                 opts.is_generator = true;
-                return p.parseProperty(.normal, opts, errors);
+                return try p.parseProperty(.normal, opts, errors);
             },
 
             else => {
@@ -5367,10 +5410,10 @@ pub const P = struct {
                 const name_range = p.lexer.range();
 
                 if (!p.lexer.isIdentifierOrKeyword()) {
-                    p.lexer.expect(.t_identifier);
+                    try p.lexer.expect(.t_identifier);
                 }
 
-                p.lexer.next();
+                try p.lexer.next();
 
                 // Support contextual keywords
                 if (kind == .normal and !opts.is_generator) {
@@ -5393,14 +5436,14 @@ pub const P = struct {
                                 .p_get => {
                                     if (!opts.is_async and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_static) == .p_get) {
                                         // p.markSyntaxFeautre(ObjectAccessors, name_range)
-                                        return p.parseProperty(.get, opts, null);
+                                        return try p.parseProperty(.get, opts, null);
                                     }
                                 },
 
                                 .p_set => {
                                     if (!opts.is_async and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_static) == .p_set) {
                                         // p.markSyntaxFeautre(ObjectAccessors, name_range)
-                                        return p.parseProperty(.set, opts, null);
+                                        return try p.parseProperty(.set, opts, null);
                                     }
                                 },
                                 .p_async => {
@@ -5409,19 +5452,19 @@ pub const P = struct {
                                         opts.async_range = name_range;
 
                                         // p.markSyntaxFeautre(ObjectAccessors, name_range)
-                                        return p.parseProperty(kind, opts, null);
+                                        return try p.parseProperty(kind, opts, null);
                                     }
                                 },
                                 .p_static => {
                                     if (!opts.is_static and !opts.is_async and opts.is_class and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_get) == .p_static) {
                                         opts.is_static = true;
-                                        return p.parseProperty(kind, opts, null);
+                                        return try p.parseProperty(kind, opts, null);
                                     }
                                 },
                                 .p_private, .p_protected, .p_public, .p_readonly, .p_abstract, .p_declare, .p_override => {
                                     // Skip over TypeScript keywords
                                     if (opts.is_class and p.options.ts and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_static) == keyword) {
-                                        return p.parseProperty(kind, opts, null);
+                                        return try p.parseProperty(kind, opts, null);
                                     }
                                 },
                             }
@@ -5447,8 +5490,8 @@ pub const P = struct {
                     var initializer: ?Expr = null;
                     if (errors != null and p.lexer.token == .t_equals) {
                         (errors orelse unreachable).invalid_expr_default_value = p.lexer.range();
-                        p.lexer.next();
-                        initializer = p.parseExpr(.comma);
+                        try p.lexer.next();
+                        initializer = try p.parseExpr(.comma);
                     }
 
                     return G.Property{
@@ -5466,7 +5509,7 @@ pub const P = struct {
             // "class X { foo?: number }"
             // "class X { foo!: number }"
             if (opts.is_class and (p.lexer.token == .t_question or p.lexer.token == .t_exclamation)) {
-                p.lexer.next();
+                try p.lexer.next();
             }
 
             // "class X { foo?<T>(): T }"
@@ -5493,13 +5536,13 @@ pub const P = struct {
 
             // Skip over types
             if (p.options.ts and p.lexer.token == .t_colon) {
-                p.lexer.next();
+                try p.lexer.next();
                 p.skipTypescriptType(.lowest);
             }
 
             if (p.lexer.token == .t_equals) {
-                p.lexer.next();
-                initializer = p.parseExpr(.comma);
+                try p.lexer.next();
+                initializer = try p.parseExpr(.comma);
             }
 
             // Special-case private identifiers
@@ -5521,7 +5564,7 @@ pub const P = struct {
                 else => {},
             }
 
-            p.lexer.expectOrInsertSemicolon();
+            try p.lexer.expectOrInsertSemicolon();
 
             return G.Property{
                 .ts_decorators = opts.ts_decorators,
@@ -5569,7 +5612,7 @@ pub const P = struct {
                 }
             }
 
-            var func = p.parseFn(null, FnOrArrowDataParse{
+            var func = try p.parseFn(null, FnOrArrowDataParse{
                 .async_range = opts.async_range,
                 .allow_await = if (opts.is_async) AwaitOrYield.allow_expr else AwaitOrYield.allow_ident,
                 .allow_yield = if (opts.is_generator) AwaitOrYield.allow_expr else AwaitOrYield.allow_ident,
@@ -5666,9 +5709,9 @@ pub const P = struct {
             };
         }
 
-        p.lexer.expect(.t_colon);
+        try p.lexer.expect(.t_colon);
 
-        const value = p.parseExprOrBindings(.comma, errors);
+        const value = try p.parseExprOrBindings(.comma, errors);
 
         return G.Property{
             .ts_decorators = &[_]Expr{},
@@ -5683,12 +5726,12 @@ pub const P = struct {
 
     // By the time we call this, the identifier and type parameters have already
     // been parsed. We need to start parsing from the "extends" clause.
-    pub fn parseClass(p: *P, class_keyword: logger.Range, name: ?js_ast.LocRef, class_opts: ParseClassOptions) G.Class {
+    pub fn parseClass(p: *P, class_keyword: logger.Range, name: ?js_ast.LocRef, class_opts: ParseClassOptions) !G.Class {
         var extends: ?Expr = null;
 
         if (p.lexer.token == .t_extends) {
-            p.lexer.next();
-            extends = p.parseExpr(.new);
+            try p.lexer.next();
+            extends = try p.parseExpr(.new);
 
             // TypeScript's type argument parser inside expressions backtracks if the
             // first token after the end of the type parameter list is "{", so the
@@ -5703,19 +5746,19 @@ pub const P = struct {
         }
 
         if (p.options.ts and p.lexer.isContextualKeyword("implements")) {
-            p.lexer.next();
+            try p.lexer.next();
 
             while (true) {
                 p.skipTypescriptType(.lowest);
                 if (p.lexer.token != .t_comma) {
                     break;
                 }
-                p.lexer.next();
+                try p.lexer.next();
             }
         }
 
         var body_loc = p.lexer.loc();
-        p.lexer.expect(T.t_open_brace);
+        try p.lexer.expect(T.t_open_brace);
         var properties = List(G.Property).init(p.allocator);
 
         // Allow "in" and private fields inside class bodies
@@ -5730,7 +5773,7 @@ pub const P = struct {
         var opts = PropertyOpts{ .is_class = true, .allow_ts_decorators = class_opts.allow_ts_decorators, .class_has_extends = extends != null };
         while (p.lexer.token != T.t_close_brace) {
             if (p.lexer.token == .t_semicolon) {
-                p.lexer.next();
+                try p.lexer.next();
                 continue;
             }
 
@@ -5739,13 +5782,13 @@ pub const P = struct {
             // Parse decorators for this property
             const first_decorator_loc = p.lexer.loc();
             if (opts.allow_ts_decorators) {
-                opts.ts_decorators = p.parseTypeScriptDecorators();
+                opts.ts_decorators = try p.parseTypeScriptDecorators();
             } else {
                 opts.ts_decorators = &[_]Expr{};
             }
 
             // This property may turn out to be a type in TypeScript, which should be ignored
-            if (p.parseProperty(.normal, &opts, null)) |property| {
+            if (try p.parseProperty(.normal, &opts, null)) |property| {
                 properties.append(property) catch unreachable;
 
                 // Forbid decorators on class constructors
@@ -5771,7 +5814,7 @@ pub const P = struct {
         p.allow_in = old_allow_in;
         p.allow_private_identifiers = old_allow_private_identifiers;
 
-        p.lexer.expect(.t_close_brace);
+        try p.lexer.expect(.t_close_brace);
 
         return G.Class{
             .class_name = name,
@@ -5787,7 +5830,7 @@ pub const P = struct {
         notimpl();
     }
 
-    pub fn parseTemplateParts(p: *P, include_raw: bool) std.meta.Tuple(&[_]type{ []E.TemplatePart, logger.Loc }) {
+    pub fn parseTemplateParts(p: *P, include_raw: bool) anyerror!TemplatePartTuple {
         var parts = List(E.TemplatePart).initCapacity(p.allocator, 1) catch unreachable;
         // Allow "in" inside template literals
         var oldAllowIn = p.allow_in;
@@ -5795,10 +5838,10 @@ pub const P = struct {
         var legacy_octal_loc = logger.Loc.Empty;
 
         parseTemplatePart: while (true) {
-            p.lexer.next();
-            var value = p.parseExpr(.lowest);
+            try p.lexer.next();
+            var value = try p.parseExpr(.lowest);
             var tail_loc = p.lexer.loc();
-            p.lexer.rescanCloseBraceAsTemplateToken();
+            try p.lexer.rescanCloseBraceAsTemplateToken();
 
             var tail = p.lexer.stringLiteralUTF16();
             var tail_raw: string = "";
@@ -5817,7 +5860,7 @@ pub const P = struct {
             }) catch unreachable;
 
             if (p.lexer.token == .t_template_tail) {
-                p.lexer.next();
+                try p.lexer.next();
                 break :parseTemplatePart;
             }
             std.debug.assert(p.lexer.token != .t_end_of_file);
@@ -5825,11 +5868,11 @@ pub const P = struct {
 
         p.allow_in = oldAllowIn;
 
-        return .{ .@"0" = parts.toOwnedSlice(), .@"1" = legacy_octal_loc };
+        return TemplatePartTuple{ .@"0" = parts.toOwnedSlice(), .@"1" = legacy_octal_loc };
     }
 
     // This assumes the caller has already checked for TStringLiteral or TNoSubstitutionTemplateLiteral
-    pub fn parseStringLiteral(p: *P) Expr {
+    pub fn parseStringLiteral(p: *P) anyerror!Expr {
         var legacy_octal_loc: logger.Loc = logger.Loc.Empty;
         var loc = p.lexer.loc();
         if (p.lexer.legacy_octal_loc.start > loc.start) {
@@ -5841,7 +5884,7 @@ pub const P = struct {
                 .legacy_octal_loc = legacy_octal_loc,
                 .prefer_template = p.lexer.token == .t_no_substitution_template_literal,
             }, loc);
-            p.lexer.next();
+            try p.lexer.next();
             return expr;
         } else {
             const expr = p.e(E.String{
@@ -5849,28 +5892,28 @@ pub const P = struct {
                 .legacy_octal_loc = legacy_octal_loc,
                 .prefer_template = p.lexer.token == .t_no_substitution_template_literal,
             }, loc);
-            p.lexer.next();
+            try p.lexer.next();
             return expr;
         }
     }
 
-    pub fn parseCallArgs(p: *P) []Expr {
+    pub fn parseCallArgs(p: *P) anyerror![]Expr {
         // Allow "in" inside call arguments
         const old_allow_in = p.allow_in;
         p.allow_in = true;
         defer p.allow_in = old_allow_in;
 
         var args = List(Expr).init(p.allocator);
-        p.lexer.expect(.t_open_paren);
+        try p.lexer.expect(.t_open_paren);
 
         while (p.lexer.token != .t_close_paren) {
             const loc = p.lexer.loc();
             const is_spread = p.lexer.token == .t_dot_dot_dot;
             if (is_spread) {
                 // p.mark_syntax_feature(compat.rest_argument, p.lexer.range());
-                p.lexer.next();
+                try p.lexer.next();
             }
-            var arg = p.parseExpr(.comma);
+            var arg = try p.parseExpr(.comma);
             if (is_spread) {
                 arg = p.e(E.Spread{ .value = arg }, loc);
             }
@@ -5878,17 +5921,17 @@ pub const P = struct {
             if (p.lexer.token != .t_comma) {
                 break;
             }
-            p.lexer.next();
+            try p.lexer.next();
         }
 
-        p.lexer.expect(.t_close_paren);
+        try p.lexer.expect(.t_close_paren);
         return args.toOwnedSlice();
     }
 
-    pub fn parseSuffix(p: *P, left: Expr, level: Level, errors: ?*DeferredErrors, flags: Expr.EFlags) Expr {
+    pub fn parseSuffix(p: *P, left: Expr, level: Level, errors: ?*DeferredErrors, flags: Expr.EFlags) anyerror!Expr {
         return _parseSuffix(p, left, level, errors orelse &DeferredErrors.None, flags);
     }
-    pub fn _parseSuffix(p: *P, _left: Expr, level: Level, errors: *DeferredErrors, flags: Expr.EFlags) Expr {
+    pub fn _parseSuffix(p: *P, _left: Expr, level: Level, errors: *DeferredErrors, flags: Expr.EFlags) anyerror!Expr {
         var expr: Expr = undefined;
         var left = _left;
         var loc = p.lexer.loc();
@@ -5903,11 +5946,11 @@ pub const P = struct {
                                 return left;
                             }
 
-                            p.lexer.next();
+                            try p.lexer.next();
                             left = p.e(E.Binary{
                                 .op = .bin_comma,
                                 .left = left,
-                                .right = p.parseExpr(.comma),
+                                .right = try p.parseExpr(.comma),
                             }, left.loc);
                         },
                         else => {
@@ -5928,20 +5971,20 @@ pub const P = struct {
             optional_chain = null;
             switch (p.lexer.token) {
                 .t_dot => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     if (p.lexer.token == .t_private_identifier and p.allow_private_identifiers) {
                         // "a.#b"
                         // "a?.b.#c"
                         switch (left.data) {
                             .e_super => {
-                                p.lexer.expected(.t_identifier);
+                                try p.lexer.expected(.t_identifier);
                             },
                             else => {},
                         }
 
                         var name = p.lexer.identifier;
                         var name_loc = p.lexer.loc();
-                        p.lexer.next();
+                        try p.lexer.next();
                         const ref = p.storeNameInRef(name) catch unreachable;
                         left = p.e(E.Index{
                             .target = left,
@@ -5957,12 +6000,12 @@ pub const P = struct {
                         // "a.b"
                         // "a?.b.c"
                         if (!p.lexer.isIdentifierOrKeyword()) {
-                            p.lexer.expect(.t_identifier);
+                            try p.lexer.expect(.t_identifier);
                         }
 
                         var name = p.lexer.identifier;
                         var name_loc = p.lexer.loc();
-                        p.lexer.next();
+                        try p.lexer.next();
 
                         left = p.e(E.Dot{ .target = left, .name = name, .name_loc = name_loc, .optional_chain = old_optional_chain }, left.loc);
                     }
@@ -5970,7 +6013,7 @@ pub const P = struct {
                     optional_chain = old_optional_chain;
                 },
                 .t_question_dot => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     var optional_start = js_ast.OptionalChain.start;
 
                     // TODO: Remove unnecessary optional chains
@@ -5983,17 +6026,17 @@ pub const P = struct {
                     switch (p.lexer.token) {
                         .t_open_bracket => {
                             // "a?.[b]"
-                            p.lexer.next();
+                            try p.lexer.next();
 
                             // allow "in" inside the brackets;
                             const old_allow_in = p.allow_in;
                             p.allow_in = true;
 
-                            const index = p.parseExpr(.lowest);
+                            const index = try p.parseExpr(.lowest);
 
                             p.allow_in = old_allow_in;
 
-                            p.lexer.expect(.t_close_bracket);
+                            try p.lexer.expect(.t_close_bracket);
                             left = p.e(
                                 E.Index{ .target = left, .index = index, .optional_chain = optional_start },
                                 left.loc,
@@ -6008,19 +6051,19 @@ pub const P = struct {
 
                             left = p.e(E.Call{
                                 .target = left,
-                                .args = p.parseCallArgs(),
+                                .args = try p.parseCallArgs(),
                                 .optional_chain = optional_start,
                             }, left.loc);
                         },
                         .t_less_than => {
                             // "a?.<T>()"
                             if (!p.options.ts) {
-                                p.lexer.expected(.t_identifier);
+                                try p.lexer.expected(.t_identifier);
                             }
 
                             p.skipTypeScriptTypeArguments(false);
                             if (p.lexer.token != .t_open_paren) {
-                                p.lexer.expected(.t_open_paren);
+                                try p.lexer.expected(.t_open_paren);
                             }
 
                             if (level.gte(.call)) {
@@ -6028,7 +6071,7 @@ pub const P = struct {
                             }
 
                             left = p.e(
-                                E.Call{ .target = left, .args = p.parseCallArgs(), .optional_chain = optional_start },
+                                E.Call{ .target = left, .args = try p.parseCallArgs(), .optional_chain = optional_start },
                                 left.loc,
                             );
                         },
@@ -6037,7 +6080,7 @@ pub const P = struct {
                                 // "a?.#b"
                                 const name = p.lexer.identifier;
                                 const name_loc = p.lexer.loc();
-                                p.lexer.next();
+                                try p.lexer.next();
                                 const ref = p.storeNameInRef(name) catch unreachable;
                                 left = p.e(E.Index{
                                     .target = left,
@@ -6052,11 +6095,11 @@ pub const P = struct {
                             } else {
                                 // "a?.b"
                                 if (!p.lexer.isIdentifierOrKeyword()) {
-                                    p.lexer.expect(.t_identifier);
+                                    try p.lexer.expect(.t_identifier);
                                 }
                                 const name = p.lexer.identifier;
                                 const name_loc = p.lexer.loc();
-                                p.lexer.next();
+                                try p.lexer.next();
 
                                 left = p.e(E.Dot{
                                     .target = left,
@@ -6080,7 +6123,7 @@ pub const P = struct {
                     // p.markSyntaxFeature(compat.TemplateLiteral, p.lexer.Range());
                     const head = p.lexer.stringLiteralUTF16();
                     const head_raw = p.lexer.rawTemplateContents();
-                    p.lexer.next();
+                    try p.lexer.next();
                     left = p.e(E.Template{
                         .tag = left,
                         .head = head,
@@ -6095,8 +6138,8 @@ pub const P = struct {
                     // p.markSyntaxFeature(compat.TemplateLiteral, p.lexer.Range());
                     const head = p.lexer.stringLiteralUTF16();
                     const head_raw = p.lexer.rawTemplateContents();
-                    const partsGroup = p.parseTemplateParts(true);
-                    p.lexer.next();
+                    const partsGroup = try p.parseTemplateParts(true);
+                    try p.lexer.next();
                     const tag = left;
                     left = p.e(E.Template{ .tag = tag, .head = head, .head_raw = head_raw, .parts = partsGroup.@"0" }, left.loc);
                 },
@@ -6113,17 +6156,17 @@ pub const P = struct {
                         return left;
                     }
 
-                    p.lexer.next();
+                    try p.lexer.next();
 
                     // Allow "in" inside the brackets
                     const old_allow_in = p.allow_in;
                     p.allow_in = true;
 
-                    const index = p.parseExpr(.lowest);
+                    const index = try p.parseExpr(.lowest);
 
                     p.allow_in = old_allow_in;
 
-                    p.lexer.expect(.t_close_bracket);
+                    try p.lexer.expect(.t_close_bracket);
 
                     left = p.e(E.Index{
                         .target = left,
@@ -6140,7 +6183,7 @@ pub const P = struct {
                     left = p.e(
                         E.Call{
                             .target = left,
-                            .args = p.parseCallArgs(),
+                            .args = try p.parseCallArgs(),
                             .optional_chain = old_optional_chain,
                         },
                         left.loc,
@@ -6151,7 +6194,7 @@ pub const P = struct {
                     if (level.gte(.conditional)) {
                         return left;
                     }
-                    p.lexer.next();
+                    try p.lexer.next();
 
                     // Stop now if we're parsing one of these:
                     // "(a?) => {}"
@@ -6161,7 +6204,7 @@ pub const P = struct {
                         p.lexer.token == .t_close_paren or p.lexer.token == .t_comma))
                     {
                         if (errors.isEmpty()) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                         }
                         errors.invalid_expr_after_question = p.lexer.range();
                         return left;
@@ -6171,11 +6214,11 @@ pub const P = struct {
                     const old_allow_in = p.allow_in;
                     p.allow_in = true;
 
-                    const yes = p.parseExpr(.comma);
+                    const yes = try p.parseExpr(.comma);
 
                     p.allow_in = old_allow_in;
-                    p.lexer.expect(.t_colon);
-                    const no = p.parseExpr(.comma);
+                    try p.lexer.expect(.t_colon);
+                    const no = try p.parseExpr(.comma);
 
                     left = p.e(E.If{
                         .test_ = left,
@@ -6190,14 +6233,14 @@ pub const P = struct {
                     }
 
                     if (!p.options.ts) {
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                     }
 
                     if (level.gte(.postfix)) {
                         return left;
                     }
 
-                    p.lexer.next();
+                    try p.lexer.next();
                     optional_chain = old_optional_chain;
                 },
                 .t_minus_minus => {
@@ -6205,7 +6248,7 @@ pub const P = struct {
                         return left;
                     }
 
-                    p.lexer.next();
+                    try p.lexer.next();
                     left = p.e(E.Unary{ .op = .un_post_dec, .value = left }, left.loc);
                 },
                 .t_plus_plus => {
@@ -6213,7 +6256,7 @@ pub const P = struct {
                         return left;
                     }
 
-                    p.lexer.next();
+                    try p.lexer.next();
                     left = p.e(E.Unary{ .op = .un_post_inc, .value = left }, left.loc);
                 },
                 .t_comma => {
@@ -6221,136 +6264,136 @@ pub const P = struct {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_comma, .left = left, .right = p.parseExpr(.comma) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_comma, .left = left, .right = try p.parseExpr(.comma) }, left.loc);
                 },
                 .t_plus => {
                     if (level.gte(.add)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_add, .left = left, .right = p.parseExpr(.add) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_add, .left = left, .right = try p.parseExpr(.add) }, left.loc);
                 },
                 .t_plus_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_add_assign, .left = left, .right = p.parseExpr(@intToEnum(Op.Level, @enumToInt(Op.Level.assign) - 1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_add_assign, .left = left, .right = try p.parseExpr(@intToEnum(Op.Level, @enumToInt(Op.Level.assign) - 1)) }, left.loc);
                 },
                 .t_minus => {
                     if (level.gte(.add)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_sub, .left = left, .right = p.parseExpr(.add) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_sub, .left = left, .right = try p.parseExpr(.add) }, left.loc);
                 },
                 .t_minus_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_sub_assign, .left = left, .right = p.parseExpr(Op.Level.sub(Op.Level.assign, 1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_sub_assign, .left = left, .right = try p.parseExpr(Op.Level.sub(Op.Level.assign, 1)) }, left.loc);
                 },
                 .t_asterisk => {
                     if (level.gte(.multiply)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_mul, .left = left, .right = p.parseExpr(.multiply) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_mul, .left = left, .right = try p.parseExpr(.multiply) }, left.loc);
                 },
                 .t_asterisk_asterisk => {
                     if (level.gte(.exponentiation)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_pow, .left = left, .right = p.parseExpr(Op.Level.exponentiation.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_pow, .left = left, .right = try p.parseExpr(Op.Level.exponentiation.sub(1)) }, left.loc);
                 },
                 .t_asterisk_asterisk_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_pow_assign, .left = left, .right = p.parseExpr(Op.Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_pow_assign, .left = left, .right = try p.parseExpr(Op.Level.assign.sub(1)) }, left.loc);
                 },
                 .t_asterisk_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_mul_assign, .left = left, .right = p.parseExpr(Op.Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_mul_assign, .left = left, .right = try p.parseExpr(Op.Level.assign.sub(1)) }, left.loc);
                 },
                 .t_percent => {
                     if (level.gte(.multiply)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_rem, .left = left, .right = p.parseExpr(Op.Level.multiply) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_rem, .left = left, .right = try p.parseExpr(Op.Level.multiply) }, left.loc);
                 },
                 .t_percent_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_rem_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_rem_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_slash => {
                     if (level.gte(.multiply)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_div, .left = left, .right = p.parseExpr(Level.multiply) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_div, .left = left, .right = try p.parseExpr(Level.multiply) }, left.loc);
                 },
                 .t_slash_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_div_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_div_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_equals_equals => {
                     if (level.gte(.equals)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_loose_eq, .left = left, .right = p.parseExpr(Level.equals) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_loose_eq, .left = left, .right = try p.parseExpr(Level.equals) }, left.loc);
                 },
                 .t_exclamation_equals => {
                     if (level.gte(.equals)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_loose_ne, .left = left, .right = p.parseExpr(Level.equals) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_loose_ne, .left = left, .right = try p.parseExpr(Level.equals) }, left.loc);
                 },
                 .t_equals_equals_equals => {
                     if (level.gte(.equals)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_strict_eq, .left = left, .right = p.parseExpr(Level.equals) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_strict_eq, .left = left, .right = try p.parseExpr(Level.equals) }, left.loc);
                 },
                 .t_exclamation_equals_equals => {
                     if (level.gte(.equals)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_strict_ne, .left = left, .right = p.parseExpr(Level.equals) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_strict_ne, .left = left, .right = try p.parseExpr(Level.equals) }, left.loc);
                 },
                 .t_less_than => {
                     // TypeScript allows type arguments to be specified with angle brackets
@@ -6364,89 +6407,89 @@ pub const P = struct {
                     if (level.gte(.compare)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_lt, .left = left, .right = p.parseExpr(.compare) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_lt, .left = left, .right = try p.parseExpr(.compare) }, left.loc);
                 },
                 .t_less_than_equals => {
                     if (level.gte(.compare)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_le, .left = left, .right = p.parseExpr(.compare) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_le, .left = left, .right = try p.parseExpr(.compare) }, left.loc);
                 },
                 .t_greater_than => {
                     if (level.gte(.compare)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_gt, .left = left, .right = p.parseExpr(.compare) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_gt, .left = left, .right = try p.parseExpr(.compare) }, left.loc);
                 },
                 .t_greater_than_equals => {
                     if (level.gte(.compare)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_ge, .left = left, .right = p.parseExpr(.compare) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_ge, .left = left, .right = try p.parseExpr(.compare) }, left.loc);
                 },
                 .t_less_than_less_than => {
                     if (level.gte(.shift)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_shl, .left = left, .right = p.parseExpr(.shift) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_shl, .left = left, .right = try p.parseExpr(.shift) }, left.loc);
                 },
                 .t_less_than_less_than_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_shl_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_shl_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_greater_than_greater_than => {
                     if (level.gte(.shift)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_shr, .left = left, .right = p.parseExpr(.shift) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_shr, .left = left, .right = try p.parseExpr(.shift) }, left.loc);
                 },
                 .t_greater_than_greater_than_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_shl_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_shl_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_greater_than_greater_than_greater_than => {
                     if (level.gte(.shift)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_u_shr, .left = left, .right = p.parseExpr(.shift) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_u_shr, .left = left, .right = try p.parseExpr(.shift) }, left.loc);
                 },
                 .t_greater_than_greater_than_greater_than_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_u_shr_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_u_shr_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_question_question => {
                     if (level.gte(.nullish_coalescing)) {
                         return left;
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_nullish_coalescing, .left = left, .right = p.parseExpr(.nullish_coalescing) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_nullish_coalescing, .left = left, .right = try p.parseExpr(.nullish_coalescing) }, left.loc);
                 },
                 .t_question_question_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_nullish_coalescing_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_nullish_coalescing_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_bar_bar => {
                     if (level.gte(.logical_or)) {
@@ -6455,18 +6498,18 @@ pub const P = struct {
 
                     // Prevent "||" inside "??" from the right
                     if (level.eql(.nullish_coalescing)) {
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                     }
 
-                    p.lexer.next();
-                    const right = p.parseExpr(.logical_or);
+                    try p.lexer.next();
+                    const right = try p.parseExpr(.logical_or);
                     left = p.e(E.Binary{ .op = Op.Code.bin_logical_or, .left = left, .right = right }, left.loc);
 
                     if (level.lt(.nullish_coalescing)) {
-                        left = p.parseSuffix(left, Level.nullish_coalescing.add(1), null, flags);
+                        left = try p.parseSuffix(left, Level.nullish_coalescing.add(1), null, flags);
 
                         if (p.lexer.token == .t_question_question) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                         }
                     }
                 },
@@ -6475,8 +6518,8 @@ pub const P = struct {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_logical_or_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_logical_or_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_ampersand_ampersand => {
                     if (level.gte(.logical_and)) {
@@ -6485,18 +6528,18 @@ pub const P = struct {
 
                     // Prevent "&&" inside "??" from the right
                     if (level.eql(.nullish_coalescing)) {
-                        p.lexer.unexpected();
+                        try p.lexer.unexpected();
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_logical_and, .left = left, .right = p.parseExpr(.logical_and) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_logical_and, .left = left, .right = try p.parseExpr(.logical_and) }, left.loc);
 
                     // Prevent "&&" inside "??" from the left
                     if (level.lt(.nullish_coalescing)) {
-                        left = p.parseSuffix(left, Level.nullish_coalescing.add(1), null, flags);
+                        left = try p.parseSuffix(left, Level.nullish_coalescing.add(1), null, flags);
 
                         if (p.lexer.token == .t_question_question) {
-                            p.lexer.unexpected();
+                            try p.lexer.unexpected();
                         }
                     }
                 },
@@ -6505,65 +6548,65 @@ pub const P = struct {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_logical_and_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_logical_and_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_bar => {
                     if (level.gte(.bitwise_or)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_bitwise_or, .left = left, .right = p.parseExpr(.bitwise_or) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_bitwise_or, .left = left, .right = try p.parseExpr(.bitwise_or) }, left.loc);
                 },
                 .t_bar_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_bitwise_or_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_bitwise_or_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_ampersand => {
                     if (level.gte(.bitwise_and)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_bitwise_and, .left = left, .right = p.parseExpr(.bitwise_and) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_bitwise_and, .left = left, .right = try p.parseExpr(.bitwise_and) }, left.loc);
                 },
                 .t_ampersand_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_shl_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_shl_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_caret => {
                     if (level.gte(.bitwise_xor)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_bitwise_xor, .left = left, .right = p.parseExpr(.bitwise_xor) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_bitwise_xor, .left = left, .right = try p.parseExpr(.bitwise_xor) }, left.loc);
                 },
                 .t_caret_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_bitwise_xor_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_bitwise_xor_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_equals => {
                     if (level.gte(.assign)) {
                         return left;
                     }
 
-                    p.lexer.next();
+                    try p.lexer.next();
 
-                    left = p.e(E.Binary{ .op = .bin_assign, .left = left, .right = p.parseExpr(Level.assign.sub(1)) }, left.loc);
+                    left = p.e(E.Binary{ .op = .bin_assign, .left = left, .right = try p.parseExpr(Level.assign.sub(1)) }, left.loc);
                 },
                 .t_in => {
                     if (level.gte(.compare) or !p.allow_in) {
@@ -6581,8 +6624,8 @@ pub const P = struct {
                         else => {},
                     }
 
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_in, .left = left, .right = p.parseExpr(.compare) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_in, .left = left, .right = try p.parseExpr(.compare) }, left.loc);
                 },
                 .t_instanceof => {
                     if (level.gte(.compare)) {
@@ -6602,13 +6645,13 @@ pub const P = struct {
                             else => {},
                         }
                     }
-                    p.lexer.next();
-                    left = p.e(E.Binary{ .op = .bin_instanceof, .left = left, .right = p.parseExpr(.compare) }, left.loc);
+                    try p.lexer.next();
+                    left = p.e(E.Binary{ .op = .bin_instanceof, .left = left, .right = try p.parseExpr(.compare) }, left.loc);
                 },
                 else => {
                     // Handle the TypeScript "as" operator
                     if (p.options.ts and level.lt(.compare) and !p.lexer.has_newline_before and p.lexer.isContextualKeyword("as")) {
-                        p.lexer.next();
+                        try p.lexer.next();
                         p.skipTypescriptType(.lowest);
 
                         // These tokens are not allowed to follow a cast expression. This isn't
@@ -6656,7 +6699,7 @@ pub const P = struct {
         Global.panic("{s}", .{fixedBuffer});
     }
 
-    pub fn _parsePrefix(p: *P, level: Level, errors: *DeferredErrors, flags: Expr.EFlags) Expr {
+    pub fn _parsePrefix(p: *P, level: Level, errors: *DeferredErrors, flags: Expr.EFlags) anyerror!Expr {
         const loc = p.lexer.loc();
         const l = @enumToInt(level);
         // Output.print("Parse Prefix {s}:{s} @{s} ", .{ p.lexer.token, p.lexer.raw(), @tagName(level) });
@@ -6664,7 +6707,7 @@ pub const P = struct {
         switch (p.lexer.token) {
             .t_super => {
                 const superRange = p.lexer.range();
-                p.lexer.next();
+                try p.lexer.next();
 
                 switch (p.lexer.token) {
                     .t_open_paren => {
@@ -6682,16 +6725,16 @@ pub const P = struct {
                 return p.e(E.Super{}, loc);
             },
             .t_open_paren => {
-                p.lexer.next();
+                try p.lexer.next();
 
                 // Arrow functions aren't allowed in the middle of expressions
                 if (level.gt(.assign)) {
                     const oldAllowIn = p.allow_in;
                     p.allow_in = true;
 
-                    var value = p.parseExpr(Level.lowest);
+                    var value = try p.parseExpr(Level.lowest);
                     p.markExprAsParenthesized(&value);
-                    p.lexer.expect(.t_close_paren);
+                    try p.lexer.expect(.t_close_paren);
                     p.allow_in = oldAllowIn;
                     return value;
                 }
@@ -6699,19 +6742,19 @@ pub const P = struct {
                 return p.parseParenExpr(loc, level, ParenExprOpts{}) catch unreachable;
             },
             .t_false => {
-                p.lexer.next();
+                try p.lexer.next();
                 return p.e(E.Boolean{ .value = false }, loc);
             },
             .t_true => {
-                p.lexer.next();
+                try p.lexer.next();
                 return p.e(E.Boolean{ .value = true }, loc);
             },
             .t_null => {
-                p.lexer.next();
+                try p.lexer.next();
                 return p.e(E.Null{}, loc);
             },
             .t_this => {
-                p.lexer.next();
+                try p.lexer.next();
                 return Expr{ .data = Prefill.Data.This, .loc = loc };
             },
             .t_identifier => {
@@ -6719,7 +6762,7 @@ pub const P = struct {
                 const name_range = p.lexer.range();
                 const raw = p.lexer.raw();
 
-                p.lexer.next();
+                try p.lexer.next();
 
                 // Handle async and await expressions
                 switch (AsyncPrefixExpression.find(name)) {
@@ -6746,9 +6789,9 @@ pub const P = struct {
                                         args.invalid_expr_await = name_range;
                                     }
 
-                                    const value = p.parseExpr(.prefix);
+                                    const value = try p.parseExpr(.prefix);
                                     if (p.lexer.token == T.t_asterisk_asterisk) {
-                                        p.lexer.unexpected();
+                                        try p.lexer.unexpected();
                                     }
 
                                     return p.e(E.Await{ .value = value }, loc);
@@ -6770,14 +6813,14 @@ pub const P = struct {
                                     if (level.gte(.assign)) {
                                         p.log.addRangeError(p.source, name_range, "Cannot use a \"yield\" here without parentheses") catch unreachable;
                                     }
-                                    const value = p.parseExpr(.prefix);
+                                    const value = try p.parseExpr(.prefix);
 
                                     if (p.fn_or_arrow_data_parse.arrow_arg_errors) |*args| {
                                         args.invalid_expr_yield = name_range;
                                     }
 
                                     if (p.lexer.token == T.t_asterisk_asterisk) {
-                                        p.lexer.unexpected();
+                                        try p.lexer.unexpected();
                                     }
 
                                     return p.e(E.Yield{ .value = value }, loc);
@@ -6823,7 +6866,7 @@ pub const P = struct {
                 }, loc);
             },
             .t_string_literal, .t_no_substitution_template_literal => {
-                return p.parseStringLiteral();
+                return try p.parseStringLiteral();
             },
             .t_template_head => {
                 var legacy_octal_loc = logger.Loc.Empty;
@@ -6833,7 +6876,7 @@ pub const P = struct {
                     legacy_octal_loc = p.lexer.legacy_octal_loc;
                 }
 
-                var resp = p.parseTemplateParts(false);
+                var resp = try p.parseTemplateParts(false);
                 const parts: []E.TemplatePart = resp.@"0";
                 const tail_legacy_octal_loc: logger.Loc = resp.@"1";
                 if (tail_legacy_octal_loc.start > 0) {
@@ -6847,26 +6890,26 @@ pub const P = struct {
             .t_numeric_literal => {
                 const value = p.e(E.Number{ .value = p.lexer.number }, loc);
                 // p.checkForLegacyOctalLiteral()
-                p.lexer.next();
+                try p.lexer.next();
                 return value;
             },
             .t_big_integer_literal => {
                 const value = p.lexer.identifier;
                 // markSyntaxFeature bigInt
-                p.lexer.next();
+                try p.lexer.next();
                 return p.e(E.BigInt{ .value = value }, loc);
             },
             .t_slash, .t_slash_equals => {
-                p.lexer.scanRegExp();
+                try p.lexer.scanRegExp();
                 const value = p.lexer.raw();
-                p.lexer.next();
+                try p.lexer.next();
                 return p.e(E.RegExp{ .value = value }, loc);
             },
             .t_void => {
-                p.lexer.next();
-                const value = p.parseExpr(.prefix);
+                try p.lexer.next();
+                const value = try p.parseExpr(.prefix);
                 if (p.lexer.token == .t_asterisk_asterisk) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
 
                 return p.e(E.Unary{
@@ -6875,19 +6918,19 @@ pub const P = struct {
                 }, loc);
             },
             .t_typeof => {
-                p.lexer.next();
-                const value = p.parseExpr(.prefix);
+                try p.lexer.next();
+                const value = try p.parseExpr(.prefix);
                 if (p.lexer.token == .t_asterisk_asterisk) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
 
                 return p.e(E.Unary{ .op = .un_typeof, .value = value }, loc);
             },
             .t_delete => {
-                p.lexer.next();
-                const value = p.parseExpr(.prefix);
+                try p.lexer.next();
+                const value = try p.parseExpr(.prefix);
                 if (p.lexer.token == .t_asterisk_asterisk) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
                 // TODO: add error deleting private identifier
                 // const private = value.data.e_private_identifier;
@@ -6899,56 +6942,56 @@ pub const P = struct {
                 return p.e(E.Unary{ .op = .un_delete, .value = value }, loc);
             },
             .t_plus => {
-                p.lexer.next();
-                const value = p.parseExpr(.prefix);
+                try p.lexer.next();
+                const value = try p.parseExpr(.prefix);
                 if (p.lexer.token == .t_asterisk_asterisk) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
 
                 return p.e(E.Unary{ .op = .un_pos, .value = value }, loc);
             },
             .t_minus => {
-                p.lexer.next();
-                const value = p.parseExpr(.prefix);
+                try p.lexer.next();
+                const value = try p.parseExpr(.prefix);
                 if (p.lexer.token == .t_asterisk_asterisk) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
 
                 return p.e(E.Unary{ .op = .un_neg, .value = value }, loc);
             },
             .t_tilde => {
-                p.lexer.next();
-                const value = p.parseExpr(.prefix);
+                try p.lexer.next();
+                const value = try p.parseExpr(.prefix);
                 if (p.lexer.token == .t_asterisk_asterisk) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
 
                 return p.e(E.Unary{ .op = .un_cpl, .value = value }, loc);
             },
             .t_exclamation => {
-                p.lexer.next();
-                const value = p.parseExpr(.prefix);
+                try p.lexer.next();
+                const value = try p.parseExpr(.prefix);
                 if (p.lexer.token == .t_asterisk_asterisk) {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                 }
 
                 return p.e(E.Unary{ .op = .un_not, .value = value }, loc);
             },
             .t_minus_minus => {
-                p.lexer.next();
-                return p.e(E.Unary{ .op = .un_pre_dec, .value = p.parseExpr(.prefix) }, loc);
+                try p.lexer.next();
+                return p.e(E.Unary{ .op = .un_pre_dec, .value = try p.parseExpr(.prefix) }, loc);
             },
             .t_plus_plus => {
-                p.lexer.next();
-                return p.e(E.Unary{ .op = .un_pre_inc, .value = p.parseExpr(.prefix) }, loc);
+                try p.lexer.next();
+                return p.e(E.Unary{ .op = .un_pre_inc, .value = try p.parseExpr(.prefix) }, loc);
             },
             .t_function => {
-                return p.parseFnExpr(loc, false, logger.Range.None) catch unreachable;
+                return try p.parseFnExpr(loc, false, logger.Range.None);
             },
             .t_class => {
                 const classKeyword = p.lexer.range();
                 // markSyntaxFEatuer class
-                p.lexer.next();
+                try p.lexer.next();
                 var name: ?js_ast.LocRef = null;
 
                 _ = p.pushScopeForParsePass(.class_name, loc) catch unreachable;
@@ -6956,7 +6999,7 @@ pub const P = struct {
                 // Parse an optional class name
                 if (p.lexer.token == .t_identifier and !js_lexer.StrictModeReservedWords.has(p.lexer.identifier)) {
                     name = js_ast.LocRef{ .loc = p.lexer.loc(), .ref = p.newSymbol(.other, p.lexer.identifier) catch unreachable };
-                    p.lexer.next();
+                    try p.lexer.next();
                 }
 
                 // Even anonymous classes can have TypeScript type parameters
@@ -6964,22 +7007,22 @@ pub const P = struct {
                     p.skipTypescriptTypeParameters();
                 }
 
-                const class = p.parseClass(classKeyword, name, ParseClassOptions{});
+                const class = try p.parseClass(classKeyword, name, ParseClassOptions{});
                 p.popScope();
                 return p.e(class, loc);
             },
             .t_new => {
-                p.lexer.next();
+                try p.lexer.next();
 
                 // Special-case the weird "new.target" expression here
 
-                const target = p.parseExprWithFlags(.member, flags);
+                const target = try p.parseExprWithFlags(.member, flags);
                 var args: []Expr = &([_]Expr{});
 
                 if (p.options.ts) {
                     // Skip over TypeScript non-null assertions
                     if (p.lexer.token == .t_exclamation and !p.lexer.has_newline_before) {
-                        p.lexer.next();
+                        try p.lexer.next();
                     }
 
                     // Skip over TypeScript type arguments here if there are any
@@ -6989,7 +7032,7 @@ pub const P = struct {
                 }
 
                 if (p.lexer.token == .t_open_paren) {
-                    args = p.parseCallArgs();
+                    args = try p.parseCallArgs();
                 }
 
                 return p.e(E.New{
@@ -6998,7 +7041,7 @@ pub const P = struct {
                 }, loc);
             },
             .t_open_bracket => {
-                p.lexer.next();
+                try p.lexer.next();
                 var is_single_line = !p.lexer.has_newline_before;
                 var items = List(Expr).init(p.allocator);
                 var self_errors = DeferredErrors{};
@@ -7018,14 +7061,14 @@ pub const P = struct {
                             errors.array_spread_feature = p.lexer.range();
 
                             const dots_loc = p.lexer.loc();
-                            p.lexer.next();
+                            try p.lexer.next();
                             items.append(
-                                p.parseExprOrBindings(.comma, &self_errors),
+                                try p.parseExprOrBindings(.comma, &self_errors),
                             ) catch unreachable;
                         },
                         else => {
                             items.append(
-                                p.parseExprOrBindings(.comma, &self_errors),
+                                try p.parseExprOrBindings(.comma, &self_errors),
                             ) catch unreachable;
                         },
                     }
@@ -7038,7 +7081,7 @@ pub const P = struct {
                         is_single_line = false;
                     }
 
-                    p.lexer.next();
+                    try p.lexer.next();
 
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
@@ -7049,7 +7092,7 @@ pub const P = struct {
                     is_single_line = false;
                 }
 
-                p.lexer.expect(.t_close_bracket);
+                try p.lexer.expect(.t_close_bracket);
                 p.allow_in = old_allow_in;
 
                 if (p.willNeedBindingPattern()) {} else if (errors.isEmpty()) {
@@ -7066,7 +7109,7 @@ pub const P = struct {
                 }, loc);
             },
             .t_open_brace => {
-                p.lexer.next();
+                try p.lexer.next();
                 var is_single_line = !p.lexer.has_newline_before;
                 var properties = List(G.Property).init(p.allocator);
                 var self_errors = DeferredErrors{};
@@ -7078,8 +7121,8 @@ pub const P = struct {
 
                 while (p.lexer.token != .t_close_brace) {
                     if (p.lexer.token == .t_dot_dot_dot) {
-                        p.lexer.next();
-                        properties.append(G.Property{ .kind = .spread, .value = p.parseExpr(.comma) }) catch unreachable;
+                        try p.lexer.next();
+                        properties.append(G.Property{ .kind = .spread, .value = try p.parseExpr(.comma) }) catch unreachable;
 
                         // Commas are not allowed here when destructuring
                         if (p.lexer.token == .t_comma) {
@@ -7088,7 +7131,7 @@ pub const P = struct {
                     } else {
                         // This property may turn out to be a type in TypeScript, which should be ignored
                         var propertyOpts = PropertyOpts{};
-                        if (p.parseProperty(.normal, &propertyOpts, &self_errors)) |prop| {
+                        if (try p.parseProperty(.normal, &propertyOpts, &self_errors)) |prop| {
                             properties.append(prop) catch unreachable;
                         }
                     }
@@ -7101,7 +7144,7 @@ pub const P = struct {
                         is_single_line = false;
                     }
 
-                    p.lexer.next();
+                    try p.lexer.next();
 
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
@@ -7112,7 +7155,7 @@ pub const P = struct {
                     is_single_line = false;
                 }
 
-                p.lexer.expect(.t_close_brace);
+                try p.lexer.expect(.t_close_brace);
                 p.allow_in = old_allow_in;
 
                 if (p.willNeedBindingPattern()) {} else if (errors.isEmpty()) {
@@ -7164,16 +7207,16 @@ pub const P = struct {
                 if (p.options.ts and p.options.jsx.parse) {
                     var oldLexer = p.lexer;
 
-                    p.lexer.next();
+                    try p.lexer.next();
                     // Look ahead to see if this should be an arrow function instead
                     var is_ts_arrow_fn = false;
 
                     if (p.lexer.token == .t_identifier) {
-                        p.lexer.next();
+                        try p.lexer.next();
                         if (p.lexer.token == .t_comma) {
                             is_ts_arrow_fn = true;
                         } else if (p.lexer.token == .t_extends) {
-                            p.lexer.next();
+                            try p.lexer.next();
                             is_ts_arrow_fn = p.lexer.token != .t_equals and p.lexer.token != .t_greater_than;
                         }
                     }
@@ -7183,21 +7226,21 @@ pub const P = struct {
 
                     if (is_ts_arrow_fn) {
                         p.skipTypescriptTypeParameters();
-                        p.lexer.expect(.t_open_paren);
+                        try p.lexer.expect(.t_open_paren);
                         return p.parseParenExpr(loc, level, ParenExprOpts{ .force_arrow_fn = true }) catch unreachable;
                     }
                 }
 
                 if (p.options.jsx.parse) {
                     // Use NextInsideJSXElement() instead of Next() so we parse "<<" as "<"
-                    p.lexer.nextInsideJSXElement() catch unreachable;
+                    try p.lexer.nextInsideJSXElement();
                     const element = p.parseJSXElement(loc) catch unreachable;
 
                     // The call to parseJSXElement() above doesn't consume the last
                     // TGreaterThan because the caller knows what Next() function to call.
                     // Use Next() instead of NextInsideJSXElement() here since the next
                     // token is an expression.
-                    p.lexer.next();
+                    try p.lexer.next();
                     return element;
                 }
 
@@ -7207,26 +7250,26 @@ pub const P = struct {
                     // "<T>(x)"
                     // "<T>(x) => {}"
                     if (p.trySkipTypeScriptTypeParametersThenOpenParenWithBacktracking()) {
-                        p.lexer.expect(.t_open_paren);
+                        try p.lexer.expect(.t_open_paren);
                         return p.parseParenExpr(loc, level, ParenExprOpts{}) catch unreachable;
                     }
 
                     // "<T>x"
-                    p.lexer.next();
+                    try p.lexer.next();
                     p.skipTypescriptType(.lowest);
-                    p.lexer.expectGreaterThan(false) catch unreachable;
+                    try p.lexer.expectGreaterThan(false);
                     return p.parsePrefix(level, errors, flags);
                 }
 
-                p.lexer.unexpected();
+                try p.lexer.unexpected();
                 return Expr{ .data = Prefill.Data.EMissing, .loc = logger.Loc.Empty };
             },
             .t_import => {
-                p.lexer.next();
+                try p.lexer.next();
                 return p.parseImportExpr(loc, level);
             },
             else => {
-                p.lexer.unexpected();
+                try p.lexer.unexpected();
                 return Expr{ .data = Prefill.Data.EMissing, .loc = logger.Loc.Empty };
             },
         }
@@ -7244,18 +7287,18 @@ pub const P = struct {
     }
 
     // Note: The caller has already parsed the "import" keyword
-    pub fn parseImportExpr(p: *P, loc: logger.Loc, level: Level) Expr {
+    pub fn parseImportExpr(p: *P, loc: logger.Loc, level: Level) anyerror!Expr {
         // Parse an "import.meta" expression
         if (p.lexer.token == .t_dot) {
             p.es6_import_keyword = js_lexer.rangeOfIdentifier(p.source, loc);
-            p.lexer.next();
+            try p.lexer.next();
             if (p.lexer.isContextualKeyword("meta")) {
                 const r = p.lexer.range();
-                p.lexer.next();
+                try p.lexer.next();
                 p.has_import_meta = true;
                 return p.e(E.ImportMeta{}, loc);
             } else {
-                p.lexer.expectedString("\"meta\"");
+                try p.lexer.expectedString("\"meta\"");
             }
         }
 
@@ -7268,12 +7311,12 @@ pub const P = struct {
         p.allow_in = true;
 
         p.lexer.preserve_all_comments_before = true;
-        p.lexer.expect(.t_open_paren);
+        try p.lexer.expect(.t_open_paren);
         const comments = p.lexer.comments_to_preserve_before.toOwnedSlice();
         p.lexer.preserve_all_comments_before = false;
 
-        const value = p.parseExpr(.comma);
-        p.lexer.expect(.t_close_paren);
+        const value = try p.parseExpr(.comma);
+        try p.lexer.expect(.t_close_paren);
 
         p.allow_in = old_allow_in;
         return p.e(E.Import{ .expr = value, .leading_interior_comments = comments, .import_record_index = 0 }, loc);
@@ -7377,8 +7420,8 @@ pub const P = struct {
             }
         } else {
             // Use Expect() not ExpectInsideJSXElement() so we can parse expression tokens
-            p.lexer.expect(.t_open_brace);
-            const value = p.parseExpr(.lowest);
+            try p.lexer.expect(.t_open_brace);
+            const value = try p.parseExpr(.lowest);
             try p.lexer.expectInsideJSXElement(.t_close_brace);
             return value;
         }
@@ -7450,11 +7493,11 @@ pub const P = struct {
                     .t_open_brace => {
                         defer i += 1;
                         // Use Next() not ExpectInsideJSXElement() so we can parse "..."
-                        p.lexer.next();
-                        p.lexer.expect(.t_dot_dot_dot);
+                        try p.lexer.next();
+                        try p.lexer.expect(.t_dot_dot_dot);
                         spread_prop_i = i;
                         spread_loc = p.lexer.loc();
-                        try props.append(G.Property{ .value = p.parseExpr(.comma), .kind = .spread });
+                        try props.append(G.Property{ .value = try p.parseExpr(.comma), .kind = .spread });
                         try p.lexer.nextInsideJSXElement();
                     },
                     else => {
@@ -7496,7 +7539,7 @@ pub const P = struct {
             // Use NextInsideJSXElement() not Next() so we can parse ">>" as ">"
             try p.lexer.nextInsideJSXElement();
             if (p.lexer.token != .t_greater_than) {
-                p.lexer.expected(.t_greater_than);
+                try p.lexer.expected(.t_greater_than);
             }
 
             return p.e(E.JSXElement{
@@ -7526,16 +7569,16 @@ pub const P = struct {
                 },
                 .t_open_brace => {
                     // Use Next() instead of NextJSXElementChild() here since the next token is an expression
-                    p.lexer.next();
+                    try p.lexer.next();
 
                     // The "..." here is ignored (it's used to signal an array type in TypeScript)
                     if (p.lexer.token == .t_dot_dot_dot and p.options.ts) {
-                        p.lexer.next();
+                        try p.lexer.next();
                     }
 
                     // The expression is optional, and may be absent
                     if (p.lexer.token != .t_close_brace) {
-                        try children.append(p.parseExpr(.lowest));
+                        try children.append(try p.parseExpr(.lowest));
                     }
 
                     // Use ExpectJSXElementChild() so we parse child strings
@@ -7569,7 +7612,7 @@ pub const P = struct {
                     }
 
                     if (p.lexer.token != .t_greater_than) {
-                        p.lexer.expected(.t_greater_than);
+                        try p.lexer.expected(.t_greater_than);
                     }
 
                     return p.e(E.JSXElement{
@@ -7581,7 +7624,7 @@ pub const P = struct {
                     }, loc);
                 },
                 else => {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                     p.panic("", .{});
                 },
             }
@@ -7612,8 +7655,8 @@ pub const P = struct {
         notimpl();
         // return false;
     }
-    pub fn parsePrefix(p: *P, level: Level, errors: ?*DeferredErrors, flags: Expr.EFlags) Expr {
-        return p._parsePrefix(level, errors orelse &DeferredErrors.None, flags);
+    pub fn parsePrefix(p: *P, level: Level, errors: ?*DeferredErrors, flags: Expr.EFlags) anyerror!Expr {
+        return try p._parsePrefix(level, errors orelse &DeferredErrors.None, flags);
     }
 
     pub fn appendPart(p: *P, parts: *List(js_ast.Part), stmts: []Stmt) !void {
@@ -10547,13 +10590,13 @@ pub const P = struct {
             if (is_spread) {
                 spread_range = p.lexer.range();
                 // p.markSyntaxFeature()
-                p.lexer.next();
+                try p.lexer.next();
             }
 
             // We don't know yet whether these are arguments or expressions, so parse
             p.latest_arrow_arg_loc = p.lexer.loc();
 
-            var item = p.parseExprOrBindings(.comma, &errors);
+            var item = try p.parseExprOrBindings(.comma, &errors);
 
             if (is_spread) {
                 item = p.e(E.Spread{ .value = item }, loc);
@@ -10562,14 +10605,14 @@ pub const P = struct {
             // Skip over types
             if (p.options.ts and p.lexer.token == .t_colon) {
                 type_colon_range = p.lexer.range();
-                p.lexer.next();
+                try p.lexer.next();
                 p.skipTypescriptType(.lowest);
             }
 
             // There may be a "=" after the type (but not after an "as" cast)
             if (p.options.ts and p.lexer.token == .t_equals and !p.forbid_suffix_after_as_loc.eql(p.lexer.loc())) {
-                p.lexer.next();
-                item = Expr.assign(item, p.parseExpr(.comma), p.allocator);
+                try p.lexer.next();
+                item = Expr.assign(item, try p.parseExpr(.comma), p.allocator);
             }
 
             items_list.append(item) catch unreachable;
@@ -10584,12 +10627,12 @@ pub const P = struct {
             }
 
             // Eat the comma token
-            p.lexer.next();
+            try p.lexer.next();
         }
         var items = items_list.toOwnedSlice();
 
         // The parenthetical construct must end with a close parenthesis
-        p.lexer.expect(.t_close_paren);
+        try p.lexer.expect(.t_close_paren);
 
         // Restore "in" operator status before we parse the arrow function body
         p.allow_in = oldAllowIn;
@@ -10601,7 +10644,7 @@ pub const P = struct {
         if (p.lexer.token == .t_equals_greater_than or opts.force_arrow_fn or (p.options.ts and p.lexer.token == .t_colon)) {
             // Arrow functions are not allowed inside certain expressions
             if (level.gt(.assign)) {
-                p.lexer.unexpected();
+                try p.lexer.unexpected();
             }
 
             var invalidLog = List(logger.Loc).init(p.allocator);
@@ -10690,7 +10733,7 @@ pub const P = struct {
         }
 
         // Indicate that we expected an arrow function
-        p.lexer.expected(.t_equals_greater_than);
+        try p.lexer.expected(.t_equals_greater_than);
         p.panic("", .{});
     }
 
diff --git a/src/json_parser.zig b/src/json_parser.zig
index 771207f0c..80c7511a7 100644
--- a/src/json_parser.zig
+++ b/src/json_parser.zig
@@ -72,46 +72,46 @@ fn JSONLikeParser(opts: js_lexer.JSONOptions) type {
                 return Expr.alloc(p.allocator, t, loc);
             }
         }
-        pub fn parseExpr(p: *Parser) Expr {
+        pub fn parseExpr(p: *Parser) anyerror!Expr {
             const loc = p.lexer.loc();
 
             switch (p.lexer.token) {
                 .t_false => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     return p.e(E.Boolean{
                         .value = false,
                     }, loc);
                 },
                 .t_true => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     return p.e(E.Boolean{
                         .value = true,
                     }, loc);
                 },
                 .t_null => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     return p.e(E.Null{}, loc);
                 },
                 .t_string_literal => {
                     const value = p.lexer.string_literal;
-                    p.lexer.next();
+                    try p.lexer.next();
                     return p.e(E.String{
                         .value = value,
                     }, loc);
                 },
                 .t_numeric_literal => {
                     const value = p.lexer.number;
-                    p.lexer.next();
+                    try p.lexer.next();
                     return p.e(E.Number{ .value = value }, loc);
                 },
                 .t_minus => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     const value = p.lexer.number;
-                    p.lexer.expect(.t_numeric_literal);
+                    try p.lexer.expect(.t_numeric_literal);
                     return p.e(E.Number{ .value = -value }, loc);
                 },
                 .t_open_bracket => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     var is_single_line = !p.lexer.has_newline_before;
                     var exprs = std.ArrayList(Expr).init(p.allocator);
 
@@ -121,7 +121,7 @@ fn JSONLikeParser(opts: js_lexer.JSONOptions) type {
                                 is_single_line = false;
                             }
 
-                            if (!p.parseMaybeTrailingComma(.t_close_bracket)) {
+                            if (!try p.parseMaybeTrailingComma(.t_close_bracket)) {
                                 break;
                             }
 
@@ -130,17 +130,17 @@ fn JSONLikeParser(opts: js_lexer.JSONOptions) type {
                             }
                         }
 
-                        exprs.append(p.parseExpr()) catch unreachable;
+                        exprs.append(try p.parseExpr()) catch unreachable;
                     }
 
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
                     }
-                    p.lexer.expect(.t_close_bracket);
+                    try p.lexer.expect(.t_close_bracket);
                     return p.e(E.Array{ .items = exprs.toOwnedSlice() }, loc);
                 },
                 .t_open_brace => {
-                    p.lexer.next();
+                    try p.lexer.next();
                     var is_single_line = !p.lexer.has_newline_before;
                     var properties = std.ArrayList(G.Property).init(p.allocator);
                     var duplicates = std.StringHashMap(u1).init(p.allocator);
@@ -150,7 +150,7 @@ fn JSONLikeParser(opts: js_lexer.JSONOptions) type {
                             if (p.lexer.has_newline_before) {
                                 is_single_line = false;
                             }
-                            if (!p.parseMaybeTrailingComma(.t_close_brace)) {
+                            if (!try p.parseMaybeTrailingComma(.t_close_brace)) {
                                 break;
                             }
                             if (p.lexer.has_newline_before) {
@@ -161,7 +161,7 @@ fn JSONLikeParser(opts: js_lexer.JSONOptions) type {
                         var key_string = p.lexer.string_literal;
                         var key_range = p.lexer.range();
                         var key = p.e(E.String{ .value = key_string }, key_range.loc);
-                        p.lexer.expect(.t_string_literal);
+                        try p.lexer.expect(.t_string_literal);
                         var key_text = p.lexer.utf16ToString(key_string);
                         // Warn about duplicate keys
 
@@ -170,30 +170,30 @@ fn JSONLikeParser(opts: js_lexer.JSONOptions) type {
                             p.log.addRangeWarningFmt(p.source, key_range, p.allocator, "Duplicate key \"{s}\" in object literal", .{key_text}) catch unreachable;
                         }
 
-                        p.lexer.expect(.t_colon);
-                        var value = p.parseExpr();
+                        try p.lexer.expect(.t_colon);
+                        var value = try p.parseExpr();
                         properties.append(G.Property{ .key = key, .value = value }) catch unreachable;
                     }
 
                     if (p.lexer.has_newline_before) {
                         is_single_line = false;
                     }
-                    p.lexer.expect(.t_close_brace);
+                    try p.lexer.expect(.t_close_brace);
                     return p.e(E.Object{
                         .properties = properties.toOwnedSlice(),
                         .is_single_line = is_single_line,
                     }, loc);
                 },
                 else => {
-                    p.lexer.unexpected();
+                    try p.lexer.unexpected();
                     return p.e(E.Missing{}, loc);
                 },
             }
         }
 
-        pub fn parseMaybeTrailingComma(p: *Parser, closer: T) bool {
+        pub fn parseMaybeTrailingComma(p: *Parser, closer: T) !bool {
             const comma_range = p.lexer.range();
-            p.lexer.expect(.t_comma);
+            try p.lexer.expect(.t_comma);
 
             if (p.lexer.token == closer) {
                 if (!opts.allow_trailing_commas) {
-- 
cgit v1.2.3