perf(formatter): optimize JSDoc formatting hot paths

- Skip process_import_tags when no @import tags present
- Use streaming byte comparison (compare_multiline_jsdoc) to avoid
  allocating a temp String for unchanged-comment detection
- Replace str_width() with len() for ASCII-only tag lines and separators
- Track has_import_tags during tag collection to avoid unnecessary work

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Dunqing

crates/oxc_formatter/src/formatter/jsdoc/serialize.rs

@@ -128,9 +128,11 @@ impl<'a, 'o> JsdocFormatter<'a, 'o> {
         if !desc_trimmed.is_empty() {
             merged_desc.push_str(desc_trimmed);
         }
-        // Collect effective tags, absorbing @description tag content
+        // Collect effective tags, absorbing @description tag content.
+        // Track whether @import tags exist to skip import processing (common case).
         let mut effective_tags: Vec<(&oxc_jsdoc::parser::JSDocTag<'_>, &str)> =
             Vec::with_capacity(sorted_tags.len());
+        let mut has_import_tags = false;
         for (tag, normalized_kind) in &sorted_tags {
             if should_remove_empty_tag(normalized_kind) && !tag_has_content(tag) {
                 continue;
@@ -146,6 +148,9 @@ impl<'a, 'o> JsdocFormatter<'a, 'o> {
                 }
                 continue;
             }
+            if *normalized_kind == "import" {
+                has_import_tags = true;
+            }
             effective_tags.push((tag, normalized_kind));
         }
 
@@ -172,9 +177,15 @@ impl<'a, 'o> JsdocFormatter<'a, 'o> {
         // Reorder @param tags to match the function signature order
         reorder_param_tags(&mut effective_tags, comment, source_text);
 
-        // Pre-process @import tags: merge by module, sort, format
-        let (mut import_lines, parsed_import_indices) = process_import_tags(&effective_tags);
-        let has_imports = !import_lines.is_empty();
+        // Pre-process @import tags: merge by module, sort, format.
+        // Skip entirely when no @import tags exist (common case) to avoid allocation.
+        let (mut import_lines, parsed_import_indices) = if has_import_tags {
+            let (lines, indices) = process_import_tags(&effective_tags);
+            (Some(lines), indices)
+        } else {
+            (None, smallvec::SmallVec::new())
+        };
+        let has_imports = import_lines.as_ref().is_some_and(|l| !l.is_empty());
         let mut imports_emitted = false;
 
         // Format tags
@@ -189,8 +200,7 @@ impl<'a, 'o> JsdocFormatter<'a, 'o> {
                     if !self.content_lines.is_empty() && !self.content_lines.last_is_empty() {
                         self.content_lines.push_empty();
                     }
-                    let import_str =
-                        std::mem::replace(&mut import_lines, LineBuffer::new()).into_string();
+                    let import_str = import_lines.take().unwrap().into_string();
                     self.content_lines.push(import_str);
                     imports_emitted = true;
                     prev_normalized_kind = Some("import");
@@ -322,26 +332,9 @@ impl<'a, 'o> JsdocFormatter<'a, 'o> {
             return Some(FormattedJsdoc::SingleLine(alloc_first));
         }
 
-        // Build temp string with `/** ... */` wrapper for comparison against original
-        let capacity =
-            content_str.len() + content_str.bytes().filter(|&b| b == b'\n').count() * 4 + 10;
-        let mut tmp = String::with_capacity(capacity);
-        tmp.push_str("/**");
-
-        for line in std::iter::once(first).chain(second).chain(iter) {
-            tmp.push('\n');
-            if line.is_empty() {
-                tmp.push_str(" *");
-            } else {
-                tmp.push_str(" * ");
-                tmp.push_str(line);
-            }
-        }
-        tmp.push('\n');
-        tmp.push_str(" */");
-
-        // Compare with original — if unchanged, return None
-        if tmp == content {
+        // Compare with original without allocating a temp string.
+        // Stream-compare the formatted output against `content` byte-by-byte.
+        if compare_multiline_jsdoc(content, first, second, iter) {
             return None;
         }
 
@@ -450,6 +443,57 @@ impl<'a, 'o> JsdocFormatter<'a, 'o> {
     }
 }
 
+/// Compare a multi-line JSDoc comment's formatted content against the original source
+/// without allocating a temp string. Returns `true` if the formatted output would be
+/// identical to `original`.
+fn compare_multiline_jsdoc<'a>(
+    original: &str,
+    first_line: &'a str,
+    second_line: Option<&'a str>,
+    rest: impl Iterator<Item = &'a str>,
+) -> bool {
+    let original = original.as_bytes();
+    let mut pos = 0;
+
+    // Match "/**"
+    if original.get(pos..pos + 3).is_none_or(|s| s != b"/**") {
+        return false;
+    }
+    pos += 3;
+
+    // Match each content line: "\n * {line}" or "\n *" for empty lines
+    for line in std::iter::once(first_line).chain(second_line).chain(rest) {
+        if pos >= original.len() || original[pos] != b'\n' {
+            return false;
+        }
+        pos += 1;
+        if line.is_empty() {
+            if original.get(pos..pos + 2).is_none_or(|s| s != b" *") {
+                return false;
+            }
+            pos += 2;
+        } else {
+            if original.get(pos..pos + 3).is_none_or(|s| s != b" * ") {
+                return false;
+            }
+            pos += 3;
+            let line_bytes = line.as_bytes();
+            if original.get(pos..pos + line_bytes.len()).is_none_or(|s| s != line_bytes) {
+                return false;
+            }
+            pos += line_bytes.len();
+        }
+    }
+
+    // Match "\n */"
+    if original.get(pos..pos + 4).is_none_or(|s| s != b"\n */") {
+        return false;
+    }
+    pos += 4;
+
+    pos == original.len()
+}
+
 /// Trim trailing whitespace from an owned `String` in place, avoiding a reallocation.
 pub(super) fn truncate_trim_end(s: &mut String) {
     let trimmed_len = s.trim_end().len();

crates/oxc_formatter/src/formatter/jsdoc/tag_formatters.rs

@@ -327,8 +327,8 @@ impl JsdocFormatter<'_, '_> {
         let desc_raw = desc_raw.trim();
 
         if desc_raw.is_empty() && default_value.is_none() {
-            // Try type wrapping if line is too long
-            if str_width(&tag_line) > self.wrap_width
+            // Try type wrapping if line is too long (tag_line is ASCII)
+            if tag_line.len() > self.wrap_width
                 && !normalized_type_str.is_empty()
                 && self.wrap_type_expression(
                     &tag_line[..tag_prefix_len],
@@ -413,8 +413,9 @@ impl JsdocFormatter<'_, '_> {
         };
         let has_remaining = !remaining_desc.trim().is_empty();
 
-        // Compute one-liner length without allocating
-        let prefix_len = str_width(&tag_line) + str_width(separator);
+        // Compute one-liner length without allocating.
+        // tag_line is always ASCII (@kind + {type} + name), use len() directly.
+        let prefix_len = tag_line.len() + separator.len();
         let one_liner_len = if has_remaining {
             prefix_len + str_width(&first_text)
         } else if let Some(ds_len) = default_suffix_len {
@@ -605,8 +606,8 @@ impl JsdocFormatter<'_, '_> {
         let desc_text = desc_text.trim();
 
         if desc_text.is_empty() {
-            // Try type wrapping if line is too long
-            if str_width(&tag_line) > self.wrap_width
+            // Try type wrapping if line is too long (tag_line is ASCII)
+            if tag_line.len() > self.wrap_width
                 && !normalized_type_str.is_empty()
                 && self.wrap_type_expression(&tag_line[..tag_prefix_len], &normalized_type_str, "")
             {
@@ -619,15 +620,15 @@ impl JsdocFormatter<'_, '_> {
         let desc_text: Cow<'_, str> =
             if should_capitalize { capitalize_first(desc_text) } else { Cow::Borrowed(desc_text) };
 
-        let prefix_len = str_width(&tag_line) + 1; // tag_line + " "
+        let prefix_len = tag_line.len() + 1; // tag_line is ASCII, + " "
         let one_liner_len = prefix_len + str_width(&desc_text);
         if one_liner_len <= self.wrap_width {
             let s = self.content_lines.begin_line();
             s.push_str(&tag_line);
             s.push(' ');
             s.push_str(&desc_text);
         } else if !normalized_type_str.is_empty()
-            && str_width(&tag_line) > self.wrap_width
+            && tag_line.len() > self.wrap_width
             && self.wrap_type_expression(&tag_line[..tag_prefix_len], &normalized_type_str, "")
         {
             // Type was wrapped. Add description as continuation.