Avoid needless allocations when generating __all__

`dunder_all_stubs` now sizes the name vector upfront and returns before
allocating it at all when the module has no member, as suggested in review.

`natural_cmp` used to copy every run of digits it compared into a `String`,
twice per comparison inside a sort comparator. It walks subslices instead now,
so ordering `__all__` does not allocate.

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

Author: jonasdedden

pyo3-introspection/src/stubs.rs

@@ -6,9 +6,9 @@ use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fmt::Write;
-use std::iter::{once, Peekable};
+use std::iter::once;
 use std::path::PathBuf;
-use std::str::{Chars, FromStr};
+use std::str::FromStr;
 
 /// Generates the [type stubs](https://typing.readthedocs.io/en/latest/source/stubs.html) of a given module.
 /// It returns a map between the file name and the file content.
@@ -140,18 +140,25 @@ fn dunder_all_stubs(module: &Module, imports: &Imports) -> Option<String> {
     if module.incomplete {
         return None;
     }
-    let mut names = module
-        .modules
-        .iter()
-        .map(|m| &m.name)
-        .chain(module.classes.iter().map(|c| &c.name))
-        .chain(module.functions.iter().map(|f| &f.name))
-        .chain(module.attributes.iter().map(|a| &a.name))
-        .collect::<Vec<_>>();
-    if names.is_empty() {
+    let member_count = module.modules.len()
+        + module.classes.len()
+        + module.functions.len()
+        + module.attributes.len();
+    if member_count == 0 {
         // Nothing was ever added to the module, so it has no `__all__` at runtime either
         return None;
     }
+
+    let mut names = Vec::with_capacity(member_count);
+    names.extend(
+        module
+            .modules
+            .iter()
+            .map(|m| &m.name)
+            .chain(module.classes.iter().map(|c| &c.name))
+            .chain(module.functions.iter().map(|f| &f.name))
+            .chain(module.attributes.iter().map(|a| &a.name)),
+    );
     names.sort_unstable_by(|a, b| isort_style_cmp(a, b));
 
     let mut buffer = "__all__ = ".to_string();
@@ -214,40 +221,37 @@ fn isort_style_cmp(a: &str, b: &str) -> Ordering {
 /// (so `arg2` comes before `arg10`), everything else by code point.
 ///
 /// [natural order]: https://en.wikipedia.org/wiki/Natural_sort_order
-fn natural_cmp(a: &str, b: &str) -> Ordering {
-    fn take_digits(chars: &mut Peekable<Chars<'_>>) -> String {
-        let mut digits = String::new();
-        while let Some(c) = chars.next_if(char::is_ascii_digit) {
-            digits.push(c);
-        }
-        digits
+fn natural_cmp(mut a: &str, mut b: &str) -> Ordering {
+    /// Splits the leading run of digits from the rest
+    fn split_digits(s: &str) -> (&str, &str) {
+        s.split_at(s.find(|c: char| !c.is_ascii_digit()).unwrap_or(s.len()))
     }
 
-    let mut a = a.chars().peekable();
-    let mut b = b.chars().peekable();
     loop {
         // The one that is exhausted first comes first
-        let (next_a, next_b) = match (a.peek().copied(), b.peek().copied()) {
+        let (next_a, next_b) = match (a.chars().next(), b.chars().next()) {
             (None, None) => return Ordering::Equal,
             (None, Some(_)) => return Ordering::Less,
             (Some(_), None) => return Ordering::Greater,
             (Some(next_a), Some(next_b)) => (next_a, next_b),
         };
         let ordering = if next_a.is_ascii_digit() && next_b.is_ascii_digit() {
-            let (digits_a, digits_b) = (take_digits(&mut a), take_digits(&mut b));
+            let (digits_a, digits_b);
+            (digits_a, a) = split_digits(a);
+            (digits_b, b) = split_digits(b);
             if next_a == '0' || next_b == '0' {
                 // A leading zero makes the run a fraction, compared digit by digit
-                digits_a.cmp(&digits_b)
+                digits_a.cmp(digits_b)
             } else {
                 // The longest run spells the biggest number, ties go to the first differing digit
                 digits_a
                     .len()
                     .cmp(&digits_b.len())
-                    .then_with(|| digits_a.cmp(&digits_b))
+                    .then_with(|| digits_a.cmp(digits_b))
             }
         } else {
-            a.next();
-            b.next();
+            a = &a[next_a.len_utf8()..];
+            b = &b[next_b.len_utf8()..];
             next_a.cmp(&next_b)
         };
         if ordering != Ordering::Equal {