Rollup merge of rust-lang#141311 - folkertdev:tidy-natural-sort, r=jieyouxu

make `tidy-alphabetical` use a natural sort

The idea here is that these lines should be correctly sorted, even though a naive string comparison would say they are not:

```
foo2
foo10
```

This is the ["natural sort order"](https://en.wikipedia.org/wiki/Natural_sort_order).

There is more discussion in [#t-compiler/help > tidy natural sort](https://rust-lang.zulipchat.com/#narrow/channel/182449-t-compiler.2Fhelp/topic/tidy.20natural.20sort/with/519111079)

Unfortunately, no standard sorting tools are smart enough to to this automatically (casting some doubt on whether we should make this change). Here are some sort outputs:

```
> cat foo.txt | sort
foo
foo1
foo10
foo2
mp
mp1e2
np",
np1e2",
> cat foo.txt | sort -n
foo
foo1
foo10
foo2
mp
mp1e2
np",
np1e2",
> cat foo.txt | sort -V
foo
foo1
foo2
foo10
mp
mp1e2
np1e2",
np",
```

Disappointingly, "numeric" sort does not actually have the behavior we want. It only sorts by numeric value if the line starts with a number. The "version" sort looks promising, but does something very unintuitive if you look at the final 4 values. None of the other options seem to have the desired behavior in all cases:

```
  -b, --ignore-leading-blanks  ignore leading blanks
  -d, --dictionary-order      consider only blanks and alphanumeric characters
  -f, --ignore-case           fold lower case to upper case characters
  -g, --general-numeric-sort  compare according to general numerical value
  -i, --ignore-nonprinting    consider only printable characters
  -M, --month-sort            compare (unknown) < 'JAN' < ... < 'DEC'
  -h, --human-numeric-sort    compare human readable numbers (e.g., 2K 1G)
  -n, --numeric-sort          compare according to string numerical value
  -R, --random-sort           shuffle, but group identical keys.  See shuf(1)
      --random-source=FILE    get random bytes from FILE
  -r, --reverse               reverse the result of comparisons
      --sort=WORD             sort according to WORD:
                                general-numeric -g, human-numeric -h, month -M,
                                numeric -n, random -R, version -V
  -V, --version-sort          natural sort of (version) numbers within text
```

r? ```@Noratrieb``` (it sounded like you know this code?)

Author: matthiaskrgr

core/src/lib.rs

@@ -150,8 +150,8 @@
 #![feature(doc_cfg_hide)]
 #![feature(doc_notable_trait)]
 #![feature(extern_types)]
-#![feature(f128)]
 #![feature(f16)]
+#![feature(f128)]
 #![feature(freeze_impls)]
 #![feature(fundamental)]
 #![feature(if_let_guard)]

coretests/tests/lib.rs

@@ -34,8 +34,8 @@
 #![feature(exact_size_is_empty)]
 #![feature(extend_one)]
 #![feature(extern_types)]
-#![feature(f128)]
 #![feature(f16)]
+#![feature(f128)]
 #![feature(float_algebraic)]
 #![feature(float_gamma)]
 #![feature(float_minimum_maximum)]

std/src/io/error.rs

@@ -462,8 +462,8 @@ impl ErrorKind {
             Deadlock => "deadlock",
             DirectoryNotEmpty => "directory not empty",
             ExecutableFileBusy => "executable file busy",
-            FilesystemLoop => "filesystem loop or indirection limit (e.g. symlink loop)",
             FileTooLarge => "file too large",
+            FilesystemLoop => "filesystem loop or indirection limit (e.g. symlink loop)",
             HostUnreachable => "host unreachable",
             InProgress => "in progress",
             Interrupted => "operation interrupted",

std/src/lib.rs

@@ -290,8 +290,8 @@
 #![feature(doc_notable_trait)]
 #![feature(dropck_eyepatch)]
 #![feature(extended_varargs_abi_support)]
-#![feature(f128)]
 #![feature(f16)]
+#![feature(f128)]
 #![feature(ffi_const)]
 #![feature(formatting_options)]
 #![feature(if_let_guard)]

std/src/sys/pal/windows/api.rs

@@ -271,20 +271,20 @@ impl WinError {
     // tidy-alphabetical-start
     pub const ACCESS_DENIED: Self = Self::new(c::ERROR_ACCESS_DENIED);
     pub const ALREADY_EXISTS: Self = Self::new(c::ERROR_ALREADY_EXISTS);
-    pub const BAD_NET_NAME: Self = Self::new(c::ERROR_BAD_NET_NAME);
     pub const BAD_NETPATH: Self = Self::new(c::ERROR_BAD_NETPATH);
+    pub const BAD_NET_NAME: Self = Self::new(c::ERROR_BAD_NET_NAME);
     pub const CANT_ACCESS_FILE: Self = Self::new(c::ERROR_CANT_ACCESS_FILE);
     pub const DELETE_PENDING: Self = Self::new(c::ERROR_DELETE_PENDING);
-    pub const DIR_NOT_EMPTY: Self = Self::new(c::ERROR_DIR_NOT_EMPTY);
     pub const DIRECTORY: Self = Self::new(c::ERROR_DIRECTORY);
+    pub const DIR_NOT_EMPTY: Self = Self::new(c::ERROR_DIR_NOT_EMPTY);
     pub const FILE_NOT_FOUND: Self = Self::new(c::ERROR_FILE_NOT_FOUND);
     pub const INSUFFICIENT_BUFFER: Self = Self::new(c::ERROR_INSUFFICIENT_BUFFER);
     pub const INVALID_FUNCTION: Self = Self::new(c::ERROR_INVALID_FUNCTION);
     pub const INVALID_HANDLE: Self = Self::new(c::ERROR_INVALID_HANDLE);
     pub const INVALID_PARAMETER: Self = Self::new(c::ERROR_INVALID_PARAMETER);
-    pub const NO_MORE_FILES: Self = Self::new(c::ERROR_NO_MORE_FILES);
     pub const NOT_FOUND: Self = Self::new(c::ERROR_NOT_FOUND);
     pub const NOT_SUPPORTED: Self = Self::new(c::ERROR_NOT_SUPPORTED);
+    pub const NO_MORE_FILES: Self = Self::new(c::ERROR_NO_MORE_FILES);
     pub const OPERATION_ABORTED: Self = Self::new(c::ERROR_OPERATION_ABORTED);
     pub const PATH_NOT_FOUND: Self = Self::new(c::ERROR_PATH_NOT_FOUND);
     pub const SHARING_VIOLATION: Self = Self::new(c::ERROR_SHARING_VIOLATION);

std/tests/run-time-detect.rs

@@ -57,18 +57,18 @@ fn aarch64_linux() {
     println!("fhm: {}", is_aarch64_feature_detected!("fhm"));
     println!("flagm2: {}", is_aarch64_feature_detected!("flagm2"));
     println!("flagm: {}", is_aarch64_feature_detected!("flagm"));
-    println!("fp16: {}", is_aarch64_feature_detected!("fp16"));
     println!("fp8: {}", is_aarch64_feature_detected!("fp8"));
     println!("fp8dot2: {}", is_aarch64_feature_detected!("fp8dot2"));
     println!("fp8dot4: {}", is_aarch64_feature_detected!("fp8dot4"));
     println!("fp8fma: {}", is_aarch64_feature_detected!("fp8fma"));
+    println!("fp16: {}", is_aarch64_feature_detected!("fp16"));
     println!("fpmr: {}", is_aarch64_feature_detected!("fpmr"));
     println!("frintts: {}", is_aarch64_feature_detected!("frintts"));
     println!("hbc: {}", is_aarch64_feature_detected!("hbc"));
     println!("i8mm: {}", is_aarch64_feature_detected!("i8mm"));
     println!("jsconv: {}", is_aarch64_feature_detected!("jsconv"));
-    println!("lse128: {}", is_aarch64_feature_detected!("lse128"));
     println!("lse2: {}", is_aarch64_feature_detected!("lse2"));
+    println!("lse128: {}", is_aarch64_feature_detected!("lse128"));
     println!("lse: {}", is_aarch64_feature_detected!("lse"));
     println!("lut: {}", is_aarch64_feature_detected!("lut"));
     println!("mops: {}", is_aarch64_feature_detected!("mops"));
@@ -87,10 +87,10 @@ fn aarch64_linux() {
     println!("sha3: {}", is_aarch64_feature_detected!("sha3"));
     println!("sm4: {}", is_aarch64_feature_detected!("sm4"));
     println!("sme-b16b16: {}", is_aarch64_feature_detected!("sme-b16b16"));
-    println!("sme-f16f16: {}", is_aarch64_feature_detected!("sme-f16f16"));
-    println!("sme-f64f64: {}", is_aarch64_feature_detected!("sme-f64f64"));
     println!("sme-f8f16: {}", is_aarch64_feature_detected!("sme-f8f16"));
     println!("sme-f8f32: {}", is_aarch64_feature_detected!("sme-f8f32"));
+    println!("sme-f16f16: {}", is_aarch64_feature_detected!("sme-f16f16"));
+    println!("sme-f64f64: {}", is_aarch64_feature_detected!("sme-f64f64"));
     println!("sme-fa64: {}", is_aarch64_feature_detected!("sme-fa64"));
     println!("sme-i16i64: {}", is_aarch64_feature_detected!("sme-i16i64"));
     println!("sme-lutv2: {}", is_aarch64_feature_detected!("sme-lutv2"));