Fix use <2024 identifier sorting transitivity

The sorting tries to create a lowercase>Capital>SCREAMING relation, but
does this in a way that causes non-transitive behavior for identifiers
starting with `_`. These identifiers are neither Capital nor SCREAMING
so they are always compared via lexicographic ASCII matching.

This causes a problem, because `A < _ < a` lexicographically in ASCII.
But `A > a` with our special case rules!

When doing these manual comparisons, hitting these issues is very easy.
To fix this, we can simply create a sorting key that mirrors our desired
order and sort that normally. This way, it's guaranteed to have all the
necessary properties.

By *always* sorting uppercase identifiers first, we ensure that `A > _`.

Author: Noratrieb

src/imports.rs

@@ -945,20 +945,16 @@ impl Ord for UseSegment {
                 let ident_ord = if self.style_edition >= StyleEdition::Edition2024 {
                     version_sort(ia, ib)
                 } else {
-                    // snake_case < CamelCase < UPPER_SNAKE_CASE
-                    if ia.starts_with(char::is_uppercase) && !ib.starts_with(char::is_uppercase) {
-                        return Ordering::Greater;
+                    fn sorting_key(ident: &str) -> (bool, bool, &str) {
+                        // snake_case < CamelCase < UPPER_SNAKE_CASE
+                        (
+                            is_upper_snake_case(ident),
+                            ident.starts_with(char::is_uppercase),
+                            ident,
+                        )
                     }
-                    if !ia.starts_with(char::is_uppercase) && ib.starts_with(char::is_uppercase) {
-                        return Ordering::Less;
-                    }
-                    if is_upper_snake_case(ia) && !is_upper_snake_case(ib) {
-                        return Ordering::Greater;
-                    }
-                    if !is_upper_snake_case(ia) && is_upper_snake_case(ib) {
-                        return Ordering::Less;
-                    }
-                    ia.cmp(ib)
+
+                    sorting_key(ia).cmp(&sorting_key(ib))
                 };
 
                 if ident_ord != Ordering::Equal {
@@ -977,16 +973,7 @@ impl Ord for UseSegment {
                     (None, None) => Ordering::Equal,
                 }
             }
-            (List(ref a), List(ref b)) => {
-                for (a, b) in a.iter().zip(b.iter()) {
-                    let ord = a.cmp(b);
-                    if ord != Ordering::Equal {
-                        return ord;
-                    }
-                }
-
-                a.len().cmp(&b.len())
-            }
+            (List(ref a), List(ref b)) => a.iter().cmp(b.iter()),
             (Slf(_), _) => Ordering::Less,
             (_, Slf(_)) => Ordering::Greater,
             (Super(_), _) => Ordering::Less,
@@ -1518,6 +1505,10 @@ mod test {
         assert!(parse_use_tree("a").normalize() < parse_use_tree("{a, b}").normalize());
         assert!(parse_use_tree("*").normalize() < parse_use_tree("{a, b}").normalize());
 
+        assert!(parse_use_tree("A").normalize() > parse_use_tree("a").normalize());
+        assert!(parse_use_tree("A").normalize() > parse_use_tree("_b").normalize());
+        assert!(parse_use_tree("a").normalize() > parse_use_tree("_b").normalize());
+
         assert!(
             parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, dddddddd}").normalize()
                 < parse_use_tree("aaaaaaaaaaaaaaa::{bb, cc, ddddddddd}").normalize()

tests/source/use-identifier-order-mixed-edition.rs

@@ -0,0 +1,13 @@
+// rustfmt-edition: 2024
+// rustfmt-style_edition: 2021
+// rustfmt-reorder_imports: true
+
+use a::{
+    Big, small, t_i_n_y, HUGE, SCREAMING_LOUDLY, or_quietly, OrInTheMiddle
+};
+
+use a::{
+    _bind_this_one_has_underscore, A1, A2, A3, A4, A5, A6, A7, A9, UnescapeOptions, bind_11,
+    bind_12, build_13, check_14, check_15, coerce_16, construct_17, construct_18, create_19, df_20,
+    expand_21,
+};

tests/source/use-identifier-order.rs

@@ -0,0 +1,13 @@
+// rustfmt-edition: 2021
+// rustfmt-style_edition: 2021
+// rustfmt-reorder_imports: true
+
+use a::{
+    Big, small, t_i_n_y, HUGE, SCREAMING_LOUDLY, or_quietly, OrInTheMiddle
+};
+
+use a::{
+    _bind_this_one_has_underscore, A1, A2, A3, A4, A5, A6, A7, A9, UnescapeOptions, bind_11,
+    bind_12, build_13, check_14, check_15, coerce_16, construct_17, construct_18, create_19, df_20,
+    expand_21,
+};

tests/target/use-identifier-order-mixed-edition.rs

@@ -0,0 +1,11 @@
+// rustfmt-edition: 2024
+// rustfmt-style_edition: 2021
+// rustfmt-reorder_imports: true
+
+use a::{or_quietly, small, t_i_n_y, Big, OrInTheMiddle, HUGE, SCREAMING_LOUDLY};
+
+use a::{
+    _bind_this_one_has_underscore, bind_11, bind_12, build_13, check_14, check_15, coerce_16,
+    construct_17, construct_18, create_19, df_20, expand_21, UnescapeOptions, A1, A2, A3, A4, A5,
+    A6, A7, A9,
+};

tests/target/use-identifier-order.rs

@@ -0,0 +1,11 @@
+// rustfmt-edition: 2021
+// rustfmt-style_edition: 2021
+// rustfmt-reorder_imports: true
+
+use a::{or_quietly, small, t_i_n_y, Big, OrInTheMiddle, HUGE, SCREAMING_LOUDLY};
+
+use a::{
+    _bind_this_one_has_underscore, bind_11, bind_12, build_13, check_14, check_15, coerce_16,
+    construct_17, construct_18, create_19, df_20, expand_21, UnescapeOptions, A1, A2, A3, A4, A5,
+    A6, A7, A9,
+};