Revert "decode regex if needed (oven-sh#5167)"

This reverts commit 32664df.

Author: Jarred-Sumner

src/js_ast.zig

@@ -2538,10 +2538,7 @@ pub const E = struct {
     };
 
     pub const RegExp = struct {
-        data: union(enum) {
-            raw: string,
-            decoded: bun.BabyList(u16),
-        },
+        value: string,
 
         // This exists for JavaScript bindings
         // The RegExp constructor expects flags as a second argument.
@@ -2551,7 +2548,7 @@ pub const E = struct {
         //      ^
         flags_offset: ?u16 = null,
 
-        pub var empty = RegExp{ .data = .{ .raw = "" } };
+        pub var empty = RegExp{ .value = "" };
 
         pub fn pattern(this: RegExp) string {
 

src/js_lexer.zig

@@ -295,7 +295,7 @@ fn NewLexer_(
             this.comments_to_preserve_before.clearAndFree();
         }
 
-        pub fn decodeEscapeSequences(lexer: *LexerType, start: usize, text: string, comptime BufType: type, buf_: *BufType) !void {
+        fn decodeEscapeSequences(lexer: *LexerType, start: usize, text: string, comptime BufType: type, buf_: *BufType) !void {
             var buf = buf_.*;
             defer buf_.* = buf;
             if (comptime is_json) lexer.is_ascii_only = false;
@@ -2075,11 +2075,9 @@ fn NewLexer_(
             if (comptime is_json) unreachable;
         }
 
-        // returns true of the regex contents need to be decoded
-        pub fn scanRegExp(lexer: *LexerType) !bool {
+        pub fn scanRegExp(lexer: *LexerType) !void {
             lexer.assertNotJSON();
             lexer.regex_flags_start = null;
-            var decode = lexer.code_point >= 0x80;
             while (true) {
                 switch (lexer.code_point) {
                     '/' => {
@@ -2123,48 +2121,20 @@ fn NewLexer_(
                                 },
                             }
                         }
-
-                        return decode;
+                        return;
                     },
                     '[' => {
                         lexer.step();
-                        if (lexer.code_point >= 0x80) decode = true;
                         while (lexer.code_point != ']') {
-                            try lexer.scanRegExpValidateAndStep(&decode);
+                            try lexer.scanRegExpValidateAndStep();
                         }
                         lexer.step();
-                        if (lexer.code_point >= 0x80) decode = true;
                     },
                     else => {
-                        try lexer.scanRegExpValidateAndStep(&decode);
+                        try lexer.scanRegExpValidateAndStep();
                     },
                 }
             }
-
-            return decode;
-        }
-
-        fn scanRegExpValidateAndStep(lexer: *LexerType, decode: *bool) !void {
-            lexer.assertNotJSON();
-
-            if (lexer.code_point == '\\') {
-                lexer.step();
-                if (lexer.code_point >= 0x80) decode.* = true;
-            }
-
-            switch (lexer.code_point) {
-                '\r', '\n', 0x2028, 0x2029 => {
-                    // Newlines aren't allowed in regular expressions
-                    try lexer.syntaxError();
-                },
-                -1 => { // EOF
-                    try lexer.syntaxError();
-                },
-                else => {
-                    lexer.step();
-                    if (lexer.code_point >= 0x80) decode.* = true;
-                },
-            }
         }
 
         // TODO: use wtf-8 encoding.
@@ -2622,6 +2592,27 @@ fn NewLexer_(
             try lexer.nextInsideJSXElement();
         }
 
+        fn scanRegExpValidateAndStep(lexer: *LexerType) !void {
+            lexer.assertNotJSON();
+
+            if (lexer.code_point == '\\') {
+                lexer.step();
+            }
+
+            switch (lexer.code_point) {
+                '\r', '\n', 0x2028, 0x2029 => {
+                    // Newlines aren't allowed in regular expressions
+                    try lexer.syntaxError();
+                },
+                -1 => { // EOF
+                    try lexer.syntaxError();
+                },
+                else => {
+                    lexer.step();
+                },
+            }
+        }
+
         pub fn rescanCloseBraceAsTemplateToken(lexer: *LexerType) !void {
             lexer.assertNotJSON();
 

src/js_parser.zig

@@ -13095,39 +13095,13 @@ fn NewParser_(
                     return p.newExpr(E.BigInt{ .value = value }, loc);
                 },
                 .t_slash, .t_slash_equals => {
-                    const needs_decode = try p.lexer.scanRegExp();
+                    try p.lexer.scanRegExp();
                     // always set regex_flags_start to null to make sure we don't accidentally use the wrong value later
                     defer p.lexer.regex_flags_start = null;
-
-                    const raw = p.lexer.raw();
-
-                    if (!needs_decode) {
-                        try p.lexer.next();
-                        return p.newExpr(
-                            E.RegExp{
-                                .data = .{
-                                    .raw = raw,
-                                },
-                                .flags_offset = p.lexer.regex_flags_start,
-                            },
-                            loc,
-                        );
-                    }
-
-                    var buf = std.ArrayList(u16).initCapacity(p.allocator, raw.len) catch unreachable;
-                    try p.lexer.decodeEscapeSequences(p.lexer.start, raw, @TypeOf(buf), &buf);
-
+                    const value = p.lexer.raw();
                     try p.lexer.next();
 
-                    return p.newExpr(
-                        E.RegExp{
-                            .data = .{
-                                .decoded = bun.BabyList(u16).init(buf.items),
-                            },
-                            .flags_offset = p.lexer.regex_flags_start,
-                        },
-                        loc,
-                    );
+                    return p.newExpr(E.RegExp{ .value = value, .flags_offset = p.lexer.regex_flags_start }, loc);
                 },
                 .t_void => {
                     try p.lexer.next();