[autofix.ci] apply automated fixes

autofix-ci[bot] · IWANABETHATGUY · commit b458aa2eac10 · 2026-03-22T23:00:07.000+08:00
diff --git a/crates/rolldown_binding/src/types/binding_magic_string.rs b/crates/rolldown_binding/src/types/binding_magic_string.rs
@@ -163,6 +163,20 @@ impl Utf16ToByteMapper {
     count
   }
 
+  /// Converts a UTF-8 byte offset to a UTF-16 code unit offset.
+  /// Returns `None` if the byte offset is past the end of the mapping.
+  #[expect(clippy::cast_possible_truncation)]
+  fn byte_to_utf16(&self, byte_offset: u32) -> Option<u32> {
+    let mut idx = self.entries.partition_point(|e| e.byte_offset < byte_offset);
+    // If we landed on a low surrogate, the byte offset is "after" the
+    // supplementary character. The correct UTF-16 position is the next
+    // index (which shares the same byte_offset).
+    if idx < self.entries.len() && self.entries[idx].is_low_surrogate() {
+      idx += 1;
+    }
+    (idx < self.entries.len()).then_some(idx as u32)
+  }
+
   /// Returns the total UTF-8 byte length of the original string.
   /// This is the correct sentinel for out-of-bounds index clamping in `slice`.
   fn total_len(&self) -> u32 {
@@ -427,12 +441,8 @@ impl BindingMagicString<'_> {
   /// not supported by the `regex` crate (e.g. backreferences, lookaround).
   /// Sticky (`y`) flag always uses the `regress` path since `regex` doesn't support it,
   /// and `lastIndex` is respected via `find_from`.
-  fn regex_replace(
-    &mut self,
-    js_regex: &JsRegExp,
-    replacement: &str,
-    global: bool,
-  ) -> napi::Result<Option<u32>> {
+  fn regex_replace(&mut self, js_regex: &JsRegExp, replacement: &str) -> napi::Result<Option<u32>> {
+    let global = js_regex.flags.contains('g');
     let flags_without_g: String = js_regex.flags.chars().filter(|&c| c != 'g').collect();
     let reg = HybridRegex::with_flags(&js_regex.source, &flags_without_g)
       .map_err(|e| napi::Error::from_reason(format!("Invalid regex: {e}")))?;
@@ -470,8 +480,16 @@ impl BindingMagicString<'_> {
       HybridRegex::Ecma(r) => {
         let is_sticky = js_regex.flags.contains('y');
         // For global regexes, JS resets lastIndex to 0 before matching.
-        // For non-global sticky, use the caller's lastIndex.
-        let start = if global || !is_sticky { 0 } else { js_regex.last_index };
+        // For non-global sticky, use the caller's lastIndex (converted from UTF-16 to byte offset).
+        // If lastIndex is out of bounds, sticky must immediately fail (no match).
+        let start = if global || !is_sticky {
+          0
+        } else {
+          match self.utf16_to_byte_mapper.utf16_to_byte(js_regex.last_index as u32) {
+            Some(byte_offset) => byte_offset as usize,
+            None => return Ok(None),
+          }
+        };
 
         if is_sticky {
           // Sticky: only accept contiguous matches starting at `start`.
@@ -507,20 +525,24 @@ impl BindingMagicString<'_> {
               last_match_end = Some(m.range.end as u32);
               let matched = &source[m.range.clone()];
               let rep = apply_replacement_regress(replacement, matched, &m, source);
-              (rep != matched).then(|| (m.range.start as u32, m.range.end as u32, rep))
+              (rep != matched).then_some((m.range.start as u32, m.range.end as u32, rep))
             })
             .collect()
         }
       }
     };
 
-    for (start, end, rep) in &overwrites {
+    // Convert byte offset back to UTF-16 code units for JS lastIndex writeback.
+    let last_match_end_utf16 =
+      last_match_end.and_then(|b| self.utf16_to_byte_mapper.byte_to_utf16(b));
+
+    for (start, end, rep) in overwrites {
       self
         .inner
-        .update_with(*start, *end, rep.clone(), UpdateOptions { overwrite: true, keep_original: false })
+        .update_with(start, end, rep, UpdateOptions { overwrite: true, keep_original: false })
         .map_err(napi::Error::from_reason)?;
     }
-    Ok(last_match_end)
+    Ok(last_match_end_utf16)
   }
 
   /// Applies `self.offset` to a u32 character index.
@@ -567,22 +589,16 @@ impl BindingMagicString<'_> {
     Ok(this)
   }
 
-  /// Returns the byte offset past the last match, or -1 if no match was found.
+  /// Returns the UTF-16 offset past the last match, or -1 if no match was found.
   /// The JS wrapper uses this to update `lastIndex` on the caller's RegExp.
+  /// Global/sticky behavior is derived from the regex's own flags.
   #[napi(js_name = "replaceRegex")]
-  pub fn replace_regex(&mut self, from: JsRegExp, to: String) -> napi::Result<i32> {
-    let is_global = from.flags.contains('g');
-    let last_end = self.regex_replace(&from, &to, is_global)?;
-    #[expect(clippy::cast_possible_wrap)]
-    Ok(last_end.map_or(-1, |v| v as i32))
-  }
-
-  /// Note: non-global RegExp check is handled in the JS wrapper (`binding-magic-string.ts`)
-  /// which throws a proper `TypeError`. If called directly without the wrapper,
-  /// a non-global regex will simply be treated as global (safe fallback).
-  #[napi(js_name = "replaceAllRegex")]
-  pub fn replace_all_regex(&mut self, from: JsRegExp, to: String) -> napi::Result<i32> {
-    let last_end = self.regex_replace(&from, &to, true)?;
+  pub fn replace_regex(
+    &mut self,
+    #[napi(ts_arg_type = "RegExp")] from: JsRegExp,
+    to: String,
+  ) -> napi::Result<i32> {
+    let last_end = self.regex_replace(&from, &to)?;
     #[expect(clippy::cast_possible_wrap)]
     Ok(last_end.map_or(-1, |v| v as i32))
   }
@@ -1143,6 +1159,10 @@ fn apply_replacement<'a>(
   group_count: usize,
   get_group: impl Fn(usize) -> Option<&'a str>,
 ) -> String {
+  // Fast path: no substitution tokens — return replacement as-is.
+  if !replacement.contains('$') {
+    return replacement.to_owned();
+  }
   let mut result = String::with_capacity(replacement.len());
   let bytes = replacement.as_bytes();
   let len = bytes.len();
diff --git a/packages/rolldown/src/binding-magic-string.ts b/packages/rolldown/src/binding-magic-string.ts
@@ -13,8 +13,8 @@ Object.defineProperty(NativeBindingMagicString.prototype, 'isRolldownMagicString
 
 // Override replace/replaceAll to support RegExp patterns.
 // String patterns delegate to the native Rust implementation.
-// RegExp patterns delegate to native replaceRegex/replaceAllRegex which use
-// the regress crate for ECMAScript-compatible regex matching with capture groups.
+// RegExp patterns delegate to native replaceRegex which uses the regress crate
+// for ECMAScript-compatible regex matching with capture groups.
 // eslint-disable-next-line @typescript-eslint/unbound-method -- intentionally saving refs before overriding
 const nativeReplace = NativeBindingMagicString.prototype.replace;
 // eslint-disable-next-line @typescript-eslint/unbound-method
@@ -31,7 +31,7 @@ NativeBindingMagicString.prototype.replace = function (
   if (searchValue.global) {
     searchValue.lastIndex = 0;
   }
-  // replaceRegex returns the byte offset past the last match, or -1 if no match.
+  // replaceRegex returns the UTF-16 offset past the last match, or -1 if no match.
   const lastMatchEnd: number = (this as any).replaceRegex(searchValue, replacement);
   // Update lastIndex to match JS semantics:
   // - Global: reset to 0 (exec loop exhaustion)
@@ -58,7 +58,7 @@ NativeBindingMagicString.prototype.replaceAll = function (
     );
   }
   searchValue.lastIndex = 0;
-  (this as any).replaceAllRegex(searchValue, replacement);
+  (this as any).replaceRegex(searchValue, replacement);
   searchValue.lastIndex = 0;
   return this;
 };
diff --git a/packages/rolldown/src/binding.d.cts b/packages/rolldown/src/binding.d.cts
@@ -1490,16 +1490,11 @@ export declare class BindingMagicString {
   replace(from: string, to: string): this
   replaceAll(from: string, to: string): this
   /**
-   * Returns the byte offset past the last match, or -1 if no match was found.
+   * Returns the UTF-16 offset past the last match, or -1 if no match was found.
    * The JS wrapper uses this to update `lastIndex` on the caller's RegExp.
+   * Global/sticky behavior is derived from the regex's own flags.
    */
-  replaceRegex(from: JsRegExp, to: string): number
-  /**
-   * Note: non-global RegExp check is handled in the JS wrapper (`binding-magic-string.ts`)
-   * which throws a proper `TypeError`. If called directly without the wrapper,
-   * a non-global regex will simply be treated as global (safe fallback).
-   */
-  replaceAllRegex(from: JsRegExp, to: string): number
+  replaceRegex(from: RegExp, to: string): number
   prepend(content: string): this
   append(content: string): this
   prependLeft(index: number, content: string): this
diff --git a/packages/rolldown/tests/magic-string/rolldown-magic-string.test.ts b/packages/rolldown/tests/magic-string/rolldown-magic-string.test.ts
@@ -220,4 +220,20 @@ describe('regex replace', () => {
     assert.strictEqual(s.toString(), '\u{1F937}x');
     assert.strictEqual(regex.lastIndex, 3);
   });
+
+  it('returns correct lastIndex when match ends at a supplementary character boundary', () => {
+    // Matching the emoji itself — the match end byte offset lands on the
+    // low surrogate entry in the mapper, which must be skipped to produce
+    // the correct UTF-16 lastIndex.
+    const s = new MagicString('A\u{1F937}B');
+    const regex = /./uy;
+
+    // Start at the emoji (UTF-16 index 1).
+    regex.lastIndex = 1;
+    s.replace(regex, 'X');
+
+    assert.strictEqual(s.toString(), 'AXB');
+    // The emoji occupies UTF-16 indices 1-2, so lastIndex should be 3.
+    assert.strictEqual(regex.lastIndex, 3);
+  });
 });
