fix(regex-parser): parse simple TemplateLiterals

Sysix · Sysix · commit c94aa23dbb82 · 2025-08-29T17:38:47.000+02:00
diff --git a/crates/oxc_linter/src/rules/eslint/no_control_regex.rs b/crates/oxc_linter/src/rules/eslint/no_control_regex.rs
@@ -317,7 +317,9 @@ mod tests {
                 r"/\u{1F}/",
                 r"/\u{1F}/g",
                 r"new RegExp('\\u{20}', 'u')",
+                r"new RegExp('\\u{20}', `u`)",
                 r"new RegExp('\\u{1F}')",
+                r"new RegExp(`\\u{1F}`)",
                 r"new RegExp('\\u{1F}', 'g')",
                 r"new RegExp('\\u{1F}', flags)", // unknown flags, we assume no 'u'
                 // https://github.com/oxc-project/oxc/issues/6136
@@ -347,6 +349,8 @@ mod tests {
                 r"/\u{1F}/u",
                 r"/\u{1F}/ugi",
                 r"new RegExp('\\u{1F}', 'u')",
+                r"new RegExp(`\\u{1F}`, 'u')",
+                r"new RegExp('\\u{1F}', `u`)",
                 r"new RegExp('\\u{1F}', 'ugi')",
                 // https://github.com/oxc-project/oxc/issues/6136
                 r"/\u{0a}/u",
diff --git a/crates/oxc_linter/src/rules/eslint/no_useless_backreference.rs b/crates/oxc_linter/src/rules/eslint/no_useless_backreference.rs
@@ -365,6 +365,7 @@ fn test() {
         r"new RegExp(`${prefix}\\1(a)`)",
         r"let RegExp; new RegExp('\\1(a)');",
         r"function foo() { var RegExp; RegExp('\\1(a)', 'u'); }",
+        r"function foo() { var RegExp; RegExp('\\1(a)', `u`); }",
         r"function foo(RegExp) { new RegExp('\\1(a)'); }",
         r"if (foo) { const RegExp = bar; RegExp('\\1(a)'); }",
         // we don't support globals off yet
diff --git a/crates/oxc_linter/src/snapshots/eslint_no_control_regex.snap b/crates/oxc_linter/src/snapshots/eslint_no_control_regex.snap
diff --git a/crates/oxc_linter/src/utils/regex.rs b/crates/oxc_linter/src/utils/regex.rs
@@ -9,6 +9,69 @@ use oxc_span::Span;
 
 use crate::{AstNode, context::LintContext};
 
+fn run_on_arguments<'a, M>(
+    arg1: Option<&'a Argument>,
+    arg2: Option<&'a Argument>,
+    ctx: &'a LintContext<'_>,
+    cb: M,
+) where
+    M: FnOnce(&Pattern<'_>, Span),
+{
+    // note: improvements required for strings used via identifier references
+    // Missing or non-string arguments will be runtime errors, but are not covered by this rule.
+    match (arg1, arg2) {
+        (Some(Argument::StringLiteral(pattern)), Some(Argument::StringLiteral(flags))) => {
+            let allocator = Allocator::default();
+            if let Some(pat) = parse_regex(&allocator, pattern.span, Some(flags.span), ctx) {
+                cb(&pat, pattern.span);
+            }
+        }
+        (Some(Argument::StringLiteral(pattern)), Some(Argument::TemplateLiteral(flags))) => {
+            if !flags.is_no_substitution_template() {
+                return;
+            }
+            let allocator = Allocator::default();
+            if let Some(pat) = parse_regex(&allocator, pattern.span, Some(flags.span), ctx) {
+                cb(&pat, pattern.span);
+            }
+        }
+        (Some(Argument::StringLiteral(pattern)), _) => {
+            let allocator = Allocator::default();
+            if let Some(pat) = parse_regex(&allocator, pattern.span, None, ctx) {
+                cb(&pat, pattern.span);
+            }
+        }
+        (Some(Argument::TemplateLiteral(pattern)), Some(Argument::TemplateLiteral(flags))) => {
+            if !pattern.is_no_substitution_template() || !flags.is_no_substitution_template() {
+                return;
+            }
+            let allocator = Allocator::default();
+            if let Some(pat) = parse_regex(&allocator, pattern.span, Some(flags.span), ctx) {
+                cb(&pat, pattern.span);
+            }
+        }
+        (Some(Argument::TemplateLiteral(pattern)), Some(Argument::StringLiteral(flags))) => {
+            if !pattern.is_no_substitution_template() {
+                return;
+            }
+            let allocator = Allocator::default();
+            if let Some(pat) = parse_regex(&allocator, pattern.span, Some(flags.span), ctx) {
+                cb(&pat, pattern.span);
+            }
+        }
+        (Some(Argument::TemplateLiteral(pattern)), _) => {
+            if !pattern.is_no_substitution_template() {
+                return;
+            }
+            let allocator = Allocator::default();
+            if let Some(pat) = parse_regex(&allocator, pattern.span, None, ctx) {
+                cb(&pat, pattern.span);
+            }
+        }
+        _ => {}
+    }
+}
+
 pub fn run_on_regex_node<'a, 'b, M>(node: &'a AstNode<'b>, ctx: &'a LintContext<'b>, cb: M)
 where
     M: FnOnce(&Pattern<'_>, Span),
@@ -20,46 +83,12 @@ where
             }
         }
         AstKind::NewExpression(expr) if is_regexp_callee(&expr.callee, ctx) => {
-            // note: improvements required for strings used via identifier references
-            // Missing or non-string arguments will be runtime errors, but are not covered by this rule.
-            match (&expr.arguments.first(), &expr.arguments.get(1)) {
-                (Some(Argument::StringLiteral(pattern)), Some(Argument::StringLiteral(flags))) => {
-                    let allocator = Allocator::default();
-                    if let Some(pat) = parse_regex(&allocator, pattern.span, Some(flags.span), ctx)
-                    {
-                        cb(&pat, pattern.span);
-                    }
-                }
-                (Some(Argument::StringLiteral(pattern)), _) => {
-                    let allocator = Allocator::default();
-                    if let Some(pat) = parse_regex(&allocator, pattern.span, None, ctx) {
-                        cb(&pat, pattern.span);
-                    }
-                }
-                _ => {}
-            }
+            run_on_arguments(expr.arguments.first(), expr.arguments.get(1), ctx, cb);
         }
 
         // RegExp()
         AstKind::CallExpression(expr) if is_regexp_callee(&expr.callee, ctx) => {
-            // note: improvements required for strings used via identifier references
-            // Missing or non-string arguments will be runtime errors, but are not covered by this rule.
-            match (&expr.arguments.first(), &expr.arguments.get(1)) {
-                (Some(Argument::StringLiteral(pattern)), Some(Argument::StringLiteral(flags))) => {
-                    let allocator = Allocator::default();
-                    if let Some(pat) = parse_regex(&allocator, pattern.span, Some(flags.span), ctx)
-                    {
-                        cb(&pat, pattern.span);
-                    }
-                }
-                (Some(Argument::StringLiteral(pattern)), _) => {
-                    let allocator = Allocator::default();
-                    if let Some(pat) = parse_regex(&allocator, pattern.span, None, ctx) {
-                        cb(&pat, pattern.span);
-                    }
-                }
-                _ => {}
-            }
+            run_on_arguments(expr.arguments.first(), expr.arguments.get(1), ctx, cb);
         }
         _ => {}
     }
diff --git a/crates/oxc_regular_expression/src/parser/parser_impl.rs b/crates/oxc_regular_expression/src/parser/parser_impl.rs
@@ -93,7 +93,7 @@ impl<'a> ConstructorParser<'a> {
             (false, false)
         };
 
-        let pattern_text = if matches!(self.pattern_text, r#""""# | "''") {
+        let pattern_text = if matches!(self.pattern_text, r#""""# | "''" | "``") {
             r#""(?:)""#
         } else {
             self.pattern_text
diff --git a/crates/oxc_regular_expression/src/parser/reader/ast.rs b/crates/oxc_regular_expression/src/parser/reader/ast.rs
@@ -0,0 +1,10 @@
+use oxc_span::Span;
+
+/// Represents UTF-16 code unit(u16 as u32) or Unicode code point(char as u32).
+/// `Span` width may be more than 1, since there will be escape sequences.
+#[derive(Debug, Clone, Copy)]
+pub struct CodePoint {
+    pub span: Span,
+    // NOTE: If we need codegen, more information should be added.
+    pub value: u32,
+}
diff --git a/crates/oxc_regular_expression/src/parser/reader/characters.rs b/crates/oxc_regular_expression/src/parser/reader/characters.rs
diff --git a/crates/oxc_regular_expression/src/parser/reader/mod.rs b/crates/oxc_regular_expression/src/parser/reader/mod.rs
@@ -1,6 +1,12 @@
+mod ast;
+mod characters;
+mod options;
 mod reader_impl;
 mod string_literal_parser;
+mod template_literal_parser;
 
+pub use ast::*;
+pub use options::Options;
 pub use reader_impl::Reader;
 
 #[cfg(test)]
diff --git a/crates/oxc_regular_expression/src/parser/reader/options.rs b/crates/oxc_regular_expression/src/parser/reader/options.rs
diff --git a/crates/oxc_regular_expression/src/parser/reader/reader_impl.rs b/crates/oxc_regular_expression/src/parser/reader/reader_impl.rs
@@ -1,14 +1,19 @@
 use oxc_diagnostics::Result;
 use oxc_span::Atom;
 
-use crate::parser::reader::string_literal_parser::{
-    Options as StringLiteralParserOptions, Parser as StringLiteralParser, ast as StringLiteralAst,
-    parse_regexp_literal,
+use crate::parser::reader::{
+    Options,
+    ast::CodePoint,
+    string_literal_parser::{
+        Parser as StringLiteralParser, ast as StringLiteralAst, parse_regexp_literal,
+    },
+    template_literal_parser::{Parser as TemplateLiteralParser, ast as TemplateLiteralAst},
 };
 
+#[derive(Debug)]
 pub struct Reader<'a> {
     source_text: &'a str,
-    units: Vec<StringLiteralAst::CodePoint>,
+    units: Vec<CodePoint>,
     index: usize,
     offset: u32,
 }
@@ -17,24 +22,37 @@ impl<'a> Reader<'a> {
     pub fn initialize(
         source_text: &'a str,
         unicode_mode: bool,
-        parse_string_literal: bool,
+        parse_string_or_template_literal: bool,
     ) -> Result<Self> {
         // NOTE: This must be `0`.
         // Since `source_text` here may be a slice of the original source text,
         // using `Span` for `span.source_text(source_text)` will be out of range in some cases.
         let span_offset = 0;
 
-        let units = if parse_string_literal {
-            let StringLiteralAst::StringLiteral { body, .. } = StringLiteralParser::new(
-                source_text,
-                StringLiteralParserOptions {
-                    strict_mode: false,
-                    span_offset,
-                    combine_surrogate_pair: unicode_mode,
-                },
-            )
-            .parse()?;
-            body
+        let units = if parse_string_or_template_literal {
+            if source_text.chars().next().is_some_and(|c| c == '`') {
+                let TemplateLiteralAst::TemplateLiteral { body, .. } = TemplateLiteralParser::new(
+                    source_text,
+                    Options {
+                        strict_mode: false,
+                        span_offset,
+                        combine_surrogate_pair: unicode_mode,
+                    },
+                )
+                .parse()?;
+                body
+            } else {
+                let StringLiteralAst::StringLiteral { body, .. } = StringLiteralParser::new(
+                    source_text,
+                    Options {
+                        strict_mode: false,
+                        span_offset,
+                        combine_surrogate_pair: unicode_mode,
+                    },
+                )
+                .parse()?;
+                body
+            }
         } else {
             parse_regexp_literal(source_text, span_offset, unicode_mode)
         };
@@ -45,7 +63,7 @@ impl<'a> Reader<'a> {
             index: 0,
             // If `parse_string_literal` is `true`, the first character is the opening quote.
             // We need to +1 to skip it.
-            offset: u32::from(parse_string_literal),
+            offset: u32::from(parse_string_or_template_literal),
         })
     }
 
diff --git a/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/ast.rs b/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/ast.rs
@@ -1,5 +1,7 @@
 use oxc_span::Span;
 
+use crate::parser::reader::ast::CodePoint;
+
 #[derive(Debug)]
 pub struct StringLiteral {
     #[allow(unused, clippy::allow_attributes)]
@@ -14,12 +16,3 @@ pub enum StringLiteralKind {
     Double,
     Single,
 }
-
-/// Represents UTF-16 code unit(u16 as u32) or Unicode code point(char as u32).
-/// `Span` width may be more than 1, since there will be escape sequences.
-#[derive(Debug, Clone, Copy)]
-pub struct CodePoint {
-    pub span: Span,
-    // NOTE: If we need codegen, more information should be added.
-    pub value: u32,
-}
diff --git a/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/mod.rs b/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/mod.rs
@@ -1,15 +1,14 @@
 pub mod ast;
-mod characters;
 mod diagnostics;
-mod options;
 mod parser_impl;
 
-pub use options::Options;
 pub use parser_impl::{Parser, parse_regexp_literal};
 
 #[cfg(test)]
 mod test {
-    use super::{Options, Parser, ast, parse_regexp_literal};
+    use crate::parser::reader::Options;
+
+    use super::{Parser, ast, parse_regexp_literal};
 
     #[test]
     fn should_pass() {
diff --git a/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/parser_impl.rs b/crates/oxc_regular_expression/src/parser/reader/string_literal_parser/parser_impl.rs
@@ -1,13 +1,12 @@
 use oxc_diagnostics::Result;
 use oxc_span::Span;
 
-use crate::parser::reader::string_literal_parser::{
-    ast,
+use crate::parser::reader::{
+    CodePoint, Options,
     characters::{
         CR, LF, LS, PS, is_line_terminator, is_non_escape_character, is_single_escape_character,
     },
-    diagnostics,
-    options::Options,
+    string_literal_parser::{ast, diagnostics},
 };
 
 // Internal representation of escape sequence resolved unit in a string literal.
@@ -19,7 +18,7 @@ pub fn parse_regexp_literal(
     source_text: &str,
     span_offset: u32,
     combine_surrogate_pair: bool,
-) -> Vec<ast::CodePoint> {
+) -> Vec<CodePoint> {
     let mut body = vec![];
 
     let mut offset = 0;
@@ -50,7 +49,7 @@ pub struct Parser {
 impl Parser {
     // This is public because it is used in `parse_regexp_literal()`.
     pub fn handle_code_point(
-        body: &mut Vec<ast::CodePoint>,
+        body: &mut Vec<CodePoint>,
         (offsets, cp): OffsetsAndCp,
         span_offset: u32,
         combine_surrogate_pair: bool,
@@ -59,13 +58,13 @@ impl Parser {
 
         if combine_surrogate_pair || (0..=0xffff).contains(&cp) {
             // If the code point is in the BMP or if forced, just push it
-            body.push(ast::CodePoint { span, value: cp });
+            body.push(CodePoint { span, value: cp });
         } else {
             // Otherwise, split the code point into a surrogate pair, sharing the same span
             let (lead, trail) =
                 (0xd800 + ((cp - 0x10000) >> 10), 0xdc00 + ((cp - 0x10000) & 0x3ff));
-            body.push(ast::CodePoint { span, value: lead });
-            body.push(ast::CodePoint { span, value: trail });
+            body.push(CodePoint { span, value: lead });
+            body.push(CodePoint { span, value: trail });
         }
     }
 
@@ -114,10 +113,7 @@ impl Parser {
     // SingleStringCharacters ::
     //   SingleStringCharacter SingleStringCharacters[opt]
     // ```
-    fn parse_string_characters(
-        &mut self,
-        single_or_double_quote: char,
-    ) -> Result<Vec<ast::CodePoint>> {
+    fn parse_string_characters(&mut self, single_or_double_quote: char) -> Result<Vec<CodePoint>> {
         let mut body = vec![];
         while let Some(code_point) = self.parse_string_character(single_or_double_quote)? {
             Parser::handle_code_point(
diff --git a/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/README.md b/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/README.md
@@ -0,0 +1,5 @@
+# template_literal_parser
+
+Implements ECMAScript® 2025 Language Specification
+
+- https://tc39.es/ecma262/2025/multipage/ecmascript-language-lexical-grammar.html#sec-template-literal-lexical-components
diff --git a/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/ast.rs b/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/ast.rs
@@ -0,0 +1,10 @@
+use oxc_span::Span;
+
+use crate::parser::reader::CodePoint;
+
+#[derive(Debug)]
+pub struct TemplateLiteral {
+    #[allow(unused, clippy::allow_attributes)]
+    pub span: Span,
+    pub body: Vec<CodePoint>,
+}
diff --git a/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/diagnostics.rs b/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/diagnostics.rs
diff --git a/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/mod.rs b/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/mod.rs
diff --git a/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/parser_impl.rs b/crates/oxc_regular_expression/src/parser/reader/template_literal_parser/parser_impl.rs
