perf: Replace hot regex with parser (#11341)

Author: quininer

Cargo.lock

@@ -112,6 +112,8 @@ urlencoding         = { version = "2.1.3", default-features = false }
 ustr                = { package = "ustr-fxhash", version = "1.0.1", default-features = false }
 wasmparser          = { version = "0.222.0", default-features = false }
 xxhash-rust         = { version = "0.8.14", default-features = false }
+winnow              = { version = "0.7.12", default-features = false, features = ["std", "simd"] }
+memchr              = { version = "2.7.5", default-features = false }
 
 # Pinned
 napi        = { version = "3.1.6", default-features = false }

Cargo.toml

@@ -79,6 +79,7 @@ swc_node_comments = { workspace = true }
 tokio = { workspace = true, features = ["rt", "macros"] }
 tracing = { workspace = true }
 ustr = { workspace = true }
+winnow = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = { workspace = true }

crates/rspack_core/Cargo.toml

@@ -2753,7 +2753,7 @@ pub fn split_readable_identifier(extra_info: &str) -> Vec<String> {
   let extra_info = REGEX.replace_all(extra_info, "");
   let mut splitted_info: Vec<String> = extra_info
     .split('/')
-    .map(|s| escape_identifier(s).to_string())
+    .map(|s| escape_identifier(s).into_owned())
     .collect();
   splitted_info.reverse();
   splitted_info
@@ -2767,5 +2767,5 @@ pub fn escape_name(name: &str) -> String {
     return "namespaceObject".to_string();
   }
 
-  escape_identifier(name).to_string()
+  escape_identifier(name).into_owned()
 }

crates/rspack_core/src/concatenated_module.rs

@@ -1,9 +1,5 @@
-use std::{
-  borrow::Cow,
-  sync::{Arc, LazyLock},
-};
+use std::{borrow::Cow, sync::Arc};
 
-use regex::Regex;
 use rspack_cacheable::cacheable;
 use rspack_error::{Result, error};
 use rspack_hook::define_hook;
@@ -12,6 +8,7 @@ use rspack_paths::Utf8PathBuf;
 use rspack_util::MergeFrom;
 use sugar_path::SugarPath;
 use swc_core::common::Span;
+use winnow::prelude::*;
 
 use crate::{
   AssetInlineGeneratorOptions, AssetResourceGeneratorOptions, BoxLoader, BoxModule,
@@ -79,16 +76,6 @@ impl ModuleFactory for NormalModuleFactory {
   }
 }
 
-static MATCH_RESOURCE_REGEX: LazyLock<Regex> =
-  LazyLock::new(|| Regex::new("^([^!]+)!=!").expect("Failed to initialize `MATCH_RESOURCE_REGEX`"));
-
-static MATCH_WEBPACK_EXT_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-  Regex::new(r#"\.webpack\[([^\]]+)\]$"#).expect("Failed to initialize `MATCH_WEBPACK_EXT_REGEX`")
-});
-
-static ELEMENT_SPLIT_REGEX: LazyLock<Regex> =
-  LazyLock::new(|| Regex::new(r"!+").expect("Failed to initialize `ELEMENT_SPLIT_REGEX`"));
-
 const HYPHEN: char = '-';
 const EXCLAMATION: char = '!';
 const DOT: char = '.';
@@ -171,9 +158,8 @@ impl NormalModuleFactory {
     if scheme.is_none() {
       let mut request_without_match_resource = data.request.as_str();
       request_without_match_resource = {
-        if let Some(m) = MATCH_RESOURCE_REGEX.captures(request_without_match_resource) {
+        if let Ok((resource, full_matched)) = match_resource(request_without_match_resource) {
           let match_resource = {
-            let resource = m.get(1).expect("Should have match resource").as_str();
             let mut chars = resource.chars();
             let first_char = chars.next();
             let second_char = chars.next();
@@ -209,10 +195,7 @@ impl NormalModuleFactory {
           );
 
           // e.g. ./index.js!=!
-          let whole_matched = m
-            .get(0)
-            .expect("should guaranteed to return a non-None value.")
-            .as_str();
+          let whole_matched = full_matched;
 
           match request_without_match_resource
             .char_indices()
@@ -259,7 +242,7 @@ impl NormalModuleFactory {
             Some((pos, _)) => &request_without_match_resource[pos..],
             None => request_without_match_resource,
           };
-          ELEMENT_SPLIT_REGEX.split(s).collect::<Vec<_>>()
+          split_element(s)
         };
 
         unresolved_resource = raw_elements
@@ -371,15 +354,10 @@ impl NormalModuleFactory {
     };
 
     let resolved_module_rules = if let Some(match_resource_data) = &mut match_resource_data
-      && let Some(captures) = MATCH_WEBPACK_EXT_REGEX.captures(&match_resource_data.resource)
-      && let Some(module_type) = captures.get(1)
+      && let Ok((module, module_type)) = match_webpack_ext(&match_resource_data.resource)
     {
-      match_module_type = Some(module_type.as_str().into());
-      match_resource_data.resource = match_resource_data
-        .resource
-        .strip_suffix(&format!(".webpack[{}]", module_type.as_str()))
-        .expect("should success")
-        .to_owned();
+      match_module_type = Some(module_type.into());
+      match_resource_data.resource = module.into();
 
       vec![]
     } else {
@@ -943,12 +921,58 @@ pub struct NormalModuleCreateData {
   pub context: Option<String>,
 }
 
+fn split_element(mut input: &str) -> Vec<&str> {
+  use winnow::{
+    combinator::separated,
+    error::ContextError,
+    token::{take_till, take_while},
+  };
+
+  separated::<_, _, _, _, ContextError, _, _>(.., take_till(.., '!'), take_while(1.., '!'))
+    .parse_next(&mut input)
+    .expect("split should never fail")
+}
+
+fn match_resource(mut input: &str) -> winnow::ModalResult<(&str, &str)> {
+  use winnow::{combinator::terminated, token::take_until};
+
+  let backup = input;
+
+  let res = terminated(take_until(1.., '!'), "!=!").parse_next(&mut input)?;
+  let whole_matched = &backup[..backup.len() - input.len()];
+  Ok((res, whole_matched))
+}
+
+fn match_webpack_ext(mut input: &str) -> winnow::ModalResult<(&str, &str)> {
+  use winnow::{
+    combinator::{delimited, eof, preceded, terminated},
+    token::take_until,
+  };
+
+  let parser = (
+    take_until(0.., ".webpack"),
+    preceded(".webpack", delimited('[', take_until(1.., ']'), ']')),
+  );
+
+  terminated(parser, eof).parse_next(&mut input)
+}
+
 #[test]
-fn match_webpack_ext() {
-  assert!(MATCH_WEBPACK_EXT_REGEX.is_match("foo.webpack[type/javascript]"));
-  let cap = MATCH_WEBPACK_EXT_REGEX
-    .captures("foo.webpack[type/javascript]")
-    .unwrap();
+fn test_split_element() {
+  assert_eq!(split_element("a!a"), vec!["a", "a"]);
+  assert_eq!(split_element("a!!a"), vec!["a", "a"]);
+  assert_eq!(split_element("!!a!!a!!"), vec!["", "a", "a", ""]);
+}
+
+#[test]
+fn test_match_webpack_ext() {
+  assert!(match_webpack_ext("foo.webpack[type/javascript]").is_ok());
+  let cap = match_webpack_ext("foo.webpack[type/javascript]").unwrap();
+
+  assert_eq!(cap, ("foo", "type/javascript"));
 
-  assert_eq!(cap.get(1).unwrap().as_str(), "type/javascript");
+  assert_eq!(
+    match_webpack_ext("foo.css.webpack[javascript/auto]"),
+    Ok(("foo.css", "javascript/auto"))
+  );
 }

crates/rspack_core/src/normal_module_factory.rs

@@ -4,10 +4,9 @@ use std::{
   hash::{Hash, Hasher},
   ops::Deref,
   ptr,
-  sync::{Arc, LazyLock},
+  sync::Arc,
 };
 
-use regex::Regex;
 use rspack_cacheable::{
   cacheable,
   with::{AsPreset, Unsupported},
@@ -33,9 +32,6 @@ pub static FULL_HASH_PLACEHOLDER: &str = "[fullhash]";
 pub static CHUNK_HASH_PLACEHOLDER: &str = "[chunkhash]";
 pub static CONTENT_HASH_PLACEHOLDER: &str = "[contenthash]";
 
-static DATA_URI_REGEX: LazyLock<Regex> =
-  LazyLock::new(|| Regex::new(r"^data:([^;,]+)").expect("Invalid regex"));
-
 #[cacheable]
 #[derive(PartialEq, Debug, Hash, Eq, Clone, PartialOrd, Ord)]
 enum FilenameKind {
@@ -200,14 +196,8 @@ fn render_template(
   let mut t = template;
   // file-level
   if let Some(filename) = options.filename {
-    if let Some(caps) = DATA_URI_REGEX.captures(filename) {
-      let ext = mime_guess::get_mime_extensions_str(
-        caps
-          .get(1)
-          .expect("should match mime for data uri")
-          .as_str(),
-      )
-      .map(|exts| exts[0]);
+    if let Ok(caps) = data_uri(filename) {
+      let ext = mime_guess::get_mime_extensions_str(caps).map(|exts| exts[0]);
 
       let replacer = options
         .content_hash
@@ -347,3 +337,16 @@ fn render_template(
   }
   t.into_owned()
 }
+
+fn data_uri(mut input: &str) -> winnow::ModalResult<&str> {
+  use winnow::{combinator::preceded, prelude::*, token::take_till};
+
+  preceded("data:", take_till(1.., (';', ','))).parse_next(&mut input)
+}
+
+#[test]
+fn test_data_uri() {
+  assert_eq!(data_uri("data:good").ok(), Some("good"));
+  assert_eq!(data_uri("data:g;ood").ok(), Some("g"));
+  assert_eq!(data_uri("data:;ood").ok(), None);
+}

crates/rspack_core/src/options/filename.rs

@@ -1,18 +1,12 @@
-use std::sync::LazyLock;
-
-use regex::Regex;
-
-static COMMENT_END_REGEX: LazyLock<Regex> =
-  LazyLock::new(|| Regex::new(r"\*\/").expect("should init regex"));
+use cow_utils::CowUtils;
 
 #[inline]
 pub fn to_comment(str: &str) -> String {
   if str.is_empty() {
     return String::new();
   }
 
-  let result = COMMENT_END_REGEX.replace_all(str, "* /");
-
+  let result = str.cow_replace("*/", "* /");
   format!("/*! {result} */")
 }
 
@@ -22,7 +16,6 @@ pub fn to_comment_with_nl(str: &str) -> String {
     return String::new();
   }
 
-  let result = COMMENT_END_REGEX.replace_all(str, "* /");
-
+  let result = str.cow_replace("*/", "* /");
   format!("/*! {result} */\n")
 }