Rollup merge of #103067 - Nilstrieb:tidy-likes-the-alphabet, r=jackh726

More alphabetical sorting

Sort and enforce a few more things. The biggest change here is sorting all target features.

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -13,17 +13,25 @@ pub const RUSTC_SPECIFIC_FEATURES: &[&str] = &["crt-static"];
 // if it doesn't, to_llvm_feature in llvm_util in rustc_codegen_llvm needs to be adapted
 
 const ARM_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
+    // tidy-alphabetical-start
     ("aclass", Some(sym::arm_target_feature)),
-    ("mclass", Some(sym::arm_target_feature)),
+    ("aes", Some(sym::arm_target_feature)),
-    ("rclass", Some(sym::arm_target_feature)),
-    ("dsp", Some(sym::arm_target_feature)),
-    ("neon", Some(sym::arm_target_feature)),
     ("crc", Some(sym::arm_target_feature)),
     ("crypto", Some(sym::arm_target_feature)),
-    ("aes", Some(sym::arm_target_feature)),
+    ("d32", Some(sym::arm_target_feature)),
-    ("sha2", Some(sym::arm_target_feature)),
-    ("i8mm", Some(sym::arm_target_feature)),
     ("dotprod", Some(sym::arm_target_feature)),
+    ("dsp", Some(sym::arm_target_feature)),
+    ("fp-armv8", Some(sym::arm_target_feature)),
+    ("i8mm", Some(sym::arm_target_feature)),
+    ("mclass", Some(sym::arm_target_feature)),
+    ("neon", Some(sym::arm_target_feature)),
+    ("rclass", Some(sym::arm_target_feature)),
+    ("sha2", Some(sym::arm_target_feature)),
+    // This is needed for inline assembly, but shouldn't be stabilized as-is
+    // since it should be enabled per-function using #[instruction_set], not
+    // #[target_feature].
+    ("thumb-mode", Some(sym::arm_target_feature)),
+    ("thumb2", Some(sym::arm_target_feature)),
     ("v5te", Some(sym::arm_target_feature)),
     ("v6", Some(sym::arm_target_feature)),
     ("v6k", Some(sym::arm_target_feature)),
@@ -33,104 +41,97 @@ const ARM_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
     ("vfp2", Some(sym::arm_target_feature)),
     ("vfp3", Some(sym::arm_target_feature)),
     ("vfp4", Some(sym::arm_target_feature)),
-    ("fp-armv8", Some(sym::arm_target_feature)),
+    // tidy-alphabetical-end
-    // This is needed for inline assembly, but shouldn't be stabilized as-is
-    // since it should be enabled per-function using #[instruction_set], not
-    // #[target_feature].
-    ("thumb-mode", Some(sym::arm_target_feature)),
-    ("thumb2", Some(sym::arm_target_feature)),
-    ("d32", Some(sym::arm_target_feature)),
 ];
 
 const AARCH64_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
-    // FEAT_AdvSimd & FEAT_FP
+    // tidy-alphabetical-start
-    ("neon", None),
+    // FEAT_AES
-    // FEAT_FP16
+    ("aes", None),
-    ("fp16", None),
+    // FEAT_BF16
-    // FEAT_SVE
+    ("bf16", None),
-    ("sve", None),
+    // FEAT_BTI
+    ("bti", None),
     // FEAT_CRC
     ("crc", None),
-    // FEAT_RAS
-    ("ras", None),
-    // FEAT_LSE
-    ("lse", None),
-    // FEAT_RDM
-    ("rdm", None),
-    // FEAT_RCPC
-    ("rcpc", None),
-    // FEAT_RCPC2
-    ("rcpc2", None),
-    // FEAT_DotProd
-    ("dotprod", None),
-    // FEAT_TME
-    ("tme", None),
-    // FEAT_FHM
-    ("fhm", None),
     // FEAT_DIT
     ("dit", None),
-    // FEAT_FLAGM
+    // FEAT_DotProd
-    ("flagm", None),
+    ("dotprod", None),
-    // FEAT_SSBS
-    ("ssbs", None),
-    // FEAT_SB
-    ("sb", None),
-    // FEAT_PAUTH (address authentication)
-    ("paca", None),
-    // FEAT_PAUTH (generic authentication)
-    ("pacg", None),
     // FEAT_DPB
     ("dpb", None),
     // FEAT_DPB2
     ("dpb2", None),
-    // FEAT_SVE2
-    ("sve2", None),
-    // FEAT_SVE2_AES
-    ("sve2-aes", None),
-    // FEAT_SVE2_SM4
-    ("sve2-sm4", None),
-    // FEAT_SVE2_SHA3
-    ("sve2-sha3", None),
-    // FEAT_SVE2_BitPerm
-    ("sve2-bitperm", None),
-    // FEAT_FRINTTS
-    ("frintts", None),
-    // FEAT_I8MM
-    ("i8mm", None),
     // FEAT_F32MM
     ("f32mm", None),
     // FEAT_F64MM
     ("f64mm", None),
-    // FEAT_BF16
-    ("bf16", None),
-    // FEAT_RAND
-    ("rand", None),
-    // FEAT_BTI
-    ("bti", None),
-    // FEAT_MTE
-    ("mte", None),
-    // FEAT_JSCVT
-    ("jsconv", None),
     // FEAT_FCMA
     ("fcma", None),
-    // FEAT_AES
+    // FEAT_FHM
-    ("aes", None),
+    ("fhm", None),
+    // FEAT_FLAGM
+    ("flagm", None),
+    // FEAT_FP16
+    ("fp16", None),
+    // FEAT_FRINTTS
+    ("frintts", None),
+    // FEAT_I8MM
+    ("i8mm", None),
+    // FEAT_JSCVT
+    ("jsconv", None),
+    // FEAT_LOR
+    ("lor", None),
+    // FEAT_LSE
+    ("lse", None),
+    // FEAT_MTE
+    ("mte", None),
+    // FEAT_AdvSimd & FEAT_FP
+    ("neon", None),
+    // FEAT_PAUTH (address authentication)
+    ("paca", None),
+    // FEAT_PAUTH (generic authentication)
+    ("pacg", None),
+    // FEAT_PAN
+    ("pan", None),
+    // FEAT_PMUv3
+    ("pmuv3", None),
+    // FEAT_RAND
+    ("rand", None),
+    // FEAT_RAS
+    ("ras", None),
+    // FEAT_RCPC
+    ("rcpc", None),
+    // FEAT_RCPC2
+    ("rcpc2", None),
+    // FEAT_RDM
+    ("rdm", None),
+    // FEAT_SB
+    ("sb", None),
     // FEAT_SHA1 & FEAT_SHA256
     ("sha2", None),
     // FEAT_SHA512 & FEAT_SHA3
     ("sha3", None),
     // FEAT_SM3 & FEAT_SM4
     ("sm4", None),
-    // FEAT_PAN
-    ("pan", None),
-    // FEAT_LOR
-    ("lor", None),
-    // FEAT_VHE
-    ("vh", None),
-    // FEAT_PMUv3
-    ("pmuv3", None),
     // FEAT_SPE
     ("spe", None),
+    // FEAT_SSBS
+    ("ssbs", None),
+    // FEAT_SVE
+    ("sve", None),
+    // FEAT_SVE2
+    ("sve2", None),
+    // FEAT_SVE2_AES
+    ("sve2-aes", None),
+    // FEAT_SVE2_BitPerm
+    ("sve2-bitperm", None),
+    // FEAT_SVE2_SHA3
+    ("sve2-sha3", None),
+    // FEAT_SVE2_SM4
+    ("sve2-sm4", None),
+    // FEAT_TME
+    ("tme", None),
     ("v8.1a", Some(sym::aarch64_ver_target_feature)),
     ("v8.2a", Some(sym::aarch64_ver_target_feature)),
     ("v8.3a", Some(sym::aarch64_ver_target_feature)),
@@ -138,6 +139,9 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
     ("v8.5a", Some(sym::aarch64_ver_target_feature)),
     ("v8.6a", Some(sym::aarch64_ver_target_feature)),
     ("v8.7a", Some(sym::aarch64_ver_target_feature)),
+    // FEAT_VHE
+    ("vh", None),
+    // tidy-alphabetical-end
 ];
 
 const AARCH64_TIED_FEATURES: &[&[&str]] = &[
@@ -145,6 +149,7 @@ const AARCH64_TIED_FEATURES: &[&[&str]] = &[
 ];
 
 const X86_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
+    // tidy-alphabetical-start
     ("adx", None),
     ("aes", None),
     ("avx", None),
@@ -194,69 +199,80 @@ const X86_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
     ("xsavec", None),
     ("xsaveopt", None),
     ("xsaves", None),
+    // tidy-alphabetical-end
 ];
 
 const HEXAGON_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
+    // tidy-alphabetical-start
     ("hvx", Some(sym::hexagon_target_feature)),
     ("hvx-length128b", Some(sym::hexagon_target_feature)),
+    // tidy-alphabetical-end
 ];
 
 const POWERPC_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
+    // tidy-alphabetical-start
     ("altivec", Some(sym::powerpc_target_feature)),
     ("power8-altivec", Some(sym::powerpc_target_feature)),
-    ("power9-altivec", Some(sym::powerpc_target_feature)),
     ("power8-vector", Some(sym::powerpc_target_feature)),
+    ("power9-altivec", Some(sym::powerpc_target_feature)),
     ("power9-vector", Some(sym::powerpc_target_feature)),
     ("vsx", Some(sym::powerpc_target_feature)),
+    // tidy-alphabetical-end
 ];
 
 const MIPS_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
+    // tidy-alphabetical-start
     ("fp64", Some(sym::mips_target_feature)),
     ("msa", Some(sym::mips_target_feature)),
     ("virt", Some(sym::mips_target_feature)),
+    // tidy-alphabetical-end
 ];
 
 const RISCV_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
-    ("m", Some(sym::riscv_target_feature)),
+    // tidy-alphabetical-start
     ("a", Some(sym::riscv_target_feature)),
     ("c", Some(sym::riscv_target_feature)),
-    ("f", Some(sym::riscv_target_feature)),
     ("d", Some(sym::riscv_target_feature)),
     ("e", Some(sym::riscv_target_feature)),
+    ("f", Some(sym::riscv_target_feature)),
+    ("m", Some(sym::riscv_target_feature)),
     ("v", Some(sym::riscv_target_feature)),
-    ("zfinx", Some(sym::riscv_target_feature)),
-    ("zdinx", Some(sym::riscv_target_feature)),
-    ("zhinx", Some(sym::riscv_target_feature)),
-    ("zhinxmin", Some(sym::riscv_target_feature)),
-    ("zfh", Some(sym::riscv_target_feature)),
-    ("zfhmin", Some(sym::riscv_target_feature)),
     ("zba", Some(sym::riscv_target_feature)),
     ("zbb", Some(sym::riscv_target_feature)),
     ("zbc", Some(sym::riscv_target_feature)),
-    ("zbs", Some(sym::riscv_target_feature)),
     ("zbkb", Some(sym::riscv_target_feature)),
     ("zbkc", Some(sym::riscv_target_feature)),
     ("zbkx", Some(sym::riscv_target_feature)),
+    ("zbs", Some(sym::riscv_target_feature)),
+    ("zdinx", Some(sym::riscv_target_feature)),
+    ("zfh", Some(sym::riscv_target_feature)),
+    ("zfhmin", Some(sym::riscv_target_feature)),
+    ("zfinx", Some(sym::riscv_target_feature)),
+    ("zhinx", Some(sym::riscv_target_feature)),
+    ("zhinxmin", Some(sym::riscv_target_feature)),
+    ("zk", Some(sym::riscv_target_feature)),
+    ("zkn", Some(sym::riscv_target_feature)),
     ("zknd", Some(sym::riscv_target_feature)),
     ("zkne", Some(sym::riscv_target_feature)),
     ("zknh", Some(sym::riscv_target_feature)),
+    ("zkr", Some(sym::riscv_target_feature)),
+    ("zks", Some(sym::riscv_target_feature)),
     ("zksed", Some(sym::riscv_target_feature)),
     ("zksh", Some(sym::riscv_target_feature)),
-    ("zkr", Some(sym::riscv_target_feature)),
-    ("zkn", Some(sym::riscv_target_feature)),
-    ("zks", Some(sym::riscv_target_feature)),
-    ("zk", Some(sym::riscv_target_feature)),
     ("zkt", Some(sym::riscv_target_feature)),
+    // tidy-alphabetical-end
 ];
 
 const WASM_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
-    ("simd128", None),
+    // tidy-alphabetical-start
     ("atomics", Some(sym::wasm_target_feature)),
-    ("nontrapping-fptoint", Some(sym::wasm_target_feature)),
     ("bulk-memory", Some(sym::wasm_target_feature)),
     ("mutable-globals", Some(sym::wasm_target_feature)),
+    ("nontrapping-fptoint", Some(sym::wasm_target_feature)),
     ("reference-types", Some(sym::wasm_target_feature)),
     ("sign-ext", Some(sym::wasm_target_feature)),
+    ("simd128", None),
+    // tidy-alphabetical-end
 ];
 
 const BPF_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[("alu32", Some(sym::bpf_target_feature))];

library/std/src/io/error.rs

@@ -387,7 +387,7 @@ pub enum ErrorKind {
 impl ErrorKind {
     pub(crate) fn as_str(&self) -> &'static str {
         use ErrorKind::*;
-        // Strictly alphabetical, please.  (Sadly rustfmt cannot do this yet.)
+        // tidy-alphabetical-start
         match *self {
             AddrInUse => "address in use",
             AddrNotAvailable => "address not available",
@@ -431,6 +431,7 @@ impl ErrorKind {
             WouldBlock => "operation would block",
             WriteZero => "write zero",
         }
+        // tidy-alphabetical-end
     }
 }
 

library/std/tests/run-time-detect.rs

@@ -14,77 +14,85 @@
 #[cfg(all(target_arch = "arm", any(target_os = "linux", target_os = "android")))]
 fn arm_linux() {
     use std::arch::is_arm_feature_detected;
+    // tidy-alphabetical-start
+    println!("aes: {}", is_arm_feature_detected!("aes"));
+    println!("crc: {}", is_arm_feature_detected!("crc"));
+    println!("crypto: {}", is_arm_feature_detected!("crypto"));
     println!("neon: {}", is_arm_feature_detected!("neon"));
     println!("pmull: {}", is_arm_feature_detected!("pmull"));
-    println!("crypto: {}", is_arm_feature_detected!("crypto"));
-    println!("crc: {}", is_arm_feature_detected!("crc"));
-    println!("aes: {}", is_arm_feature_detected!("aes"));
     println!("sha2: {}", is_arm_feature_detected!("sha2"));
+    // tidy-alphabetical-end
 }
 
 #[test]
 #[cfg(all(target_arch = "aarch64", any(target_os = "linux", target_os = "android")))]
 fn aarch64_linux() {
     use std::arch::is_aarch64_feature_detected;
-    println!("neon: {}", is_aarch64_feature_detected!("neon"));
+    // tidy-alphabetical-start
+    println!("aes: {}", is_aarch64_feature_detected!("aes"));
     println!("asimd: {}", is_aarch64_feature_detected!("asimd"));
-    println!("pmull: {}", is_aarch64_feature_detected!("pmull"));
+    println!("bf16: {}", is_aarch64_feature_detected!("bf16"));
-    println!("fp16: {}", is_aarch64_feature_detected!("fp16"));
+    println!("bti: {}", is_aarch64_feature_detected!("bti"));
-    println!("sve: {}", is_aarch64_feature_detected!("sve"));
     println!("crc: {}", is_aarch64_feature_detected!("crc"));
-    println!("lse: {}", is_aarch64_feature_detected!("lse"));
-    println!("lse2: {}", is_aarch64_feature_detected!("lse2"));
-    println!("rdm: {}", is_aarch64_feature_detected!("rdm"));
-    println!("rcpc: {}", is_aarch64_feature_detected!("rcpc"));
-    println!("rcpc2: {}", is_aarch64_feature_detected!("rcpc2"));
-    println!("dotprod: {}", is_aarch64_feature_detected!("dotprod"));
-    println!("tme: {}", is_aarch64_feature_detected!("tme"));
-    println!("fhm: {}", is_aarch64_feature_detected!("fhm"));
     println!("dit: {}", is_aarch64_feature_detected!("dit"));
-    println!("flagm: {}", is_aarch64_feature_detected!("flagm"));
+    println!("dotprod: {}", is_aarch64_feature_detected!("dotprod"));
-    println!("ssbs: {}", is_aarch64_feature_detected!("ssbs"));
-    println!("sb: {}", is_aarch64_feature_detected!("sb"));
-    println!("paca: {}", is_aarch64_feature_detected!("paca"));
-    println!("pacg: {}", is_aarch64_feature_detected!("pacg"));
-    println!("dpb: {}", is_aarch64_feature_detected!("dpb"));
     println!("dpb2: {}", is_aarch64_feature_detected!("dpb2"));
-    println!("sve2: {}", is_aarch64_feature_detected!("sve2"));
+    println!("dpb: {}", is_aarch64_feature_detected!("dpb"));
-    println!("sve2-aes: {}", is_aarch64_feature_detected!("sve2-aes"));
-    println!("sve2-sm4: {}", is_aarch64_feature_detected!("sve2-sm4"));
-    println!("sve2-sha3: {}", is_aarch64_feature_detected!("sve2-sha3"));
-    println!("sve2-bitperm: {}", is_aarch64_feature_detected!("sve2-bitperm"));
-    println!("frintts: {}", is_aarch64_feature_detected!("frintts"));
-    println!("i8mm: {}", is_aarch64_feature_detected!("i8mm"));
     println!("f32mm: {}", is_aarch64_feature_detected!("f32mm"));
     println!("f64mm: {}", is_aarch64_feature_detected!("f64mm"));
-    println!("bf16: {}", is_aarch64_feature_detected!("bf16"));
-    println!("rand: {}", is_aarch64_feature_detected!("rand"));
-    println!("bti: {}", is_aarch64_feature_detected!("bti"));
-    println!("mte: {}", is_aarch64_feature_detected!("mte"));
-    println!("jsconv: {}", is_aarch64_feature_detected!("jsconv"));
     println!("fcma: {}", is_aarch64_feature_detected!("fcma"));
-    println!("aes: {}", is_aarch64_feature_detected!("aes"));
+    println!("fhm: {}", is_aarch64_feature_detected!("fhm"));
+    println!("flagm: {}", is_aarch64_feature_detected!("flagm"));
+    println!("fp16: {}", is_aarch64_feature_detected!("fp16"));
+    println!("frintts: {}", is_aarch64_feature_detected!("frintts"));
+    println!("i8mm: {}", is_aarch64_feature_detected!("i8mm"));
+    println!("jsconv: {}", is_aarch64_feature_detected!("jsconv"));
+    println!("lse2: {}", is_aarch64_feature_detected!("lse2"));
+    println!("lse: {}", is_aarch64_feature_detected!("lse"));
+    println!("mte: {}", is_aarch64_feature_detected!("mte"));
+    println!("neon: {}", is_aarch64_feature_detected!("neon"));
+    println!("paca: {}", is_aarch64_feature_detected!("paca"));
+    println!("pacg: {}", is_aarch64_feature_detected!("pacg"));
+    println!("pmull: {}", is_aarch64_feature_detected!("pmull"));
+    println!("rand: {}", is_aarch64_feature_detected!("rand"));
+    println!("rcpc2: {}", is_aarch64_feature_detected!("rcpc2"));
+    println!("rcpc: {}", is_aarch64_feature_detected!("rcpc"));
+    println!("rdm: {}", is_aarch64_feature_detected!("rdm"));
+    println!("sb: {}", is_aarch64_feature_detected!("sb"));
     println!("sha2: {}", is_aarch64_feature_detected!("sha2"));
     println!("sha3: {}", is_aarch64_feature_detected!("sha3"));
     println!("sm4: {}", is_aarch64_feature_detected!("sm4"));
+    println!("ssbs: {}", is_aarch64_feature_detected!("ssbs"));
+    println!("sve2-aes: {}", is_aarch64_feature_detected!("sve2-aes"));
+    println!("sve2-bitperm: {}", is_aarch64_feature_detected!("sve2-bitperm"));
+    println!("sve2-sha3: {}", is_aarch64_feature_detected!("sve2-sha3"));
+    println!("sve2-sm4: {}", is_aarch64_feature_detected!("sve2-sm4"));
+    println!("sve2: {}", is_aarch64_feature_detected!("sve2"));
+    println!("sve: {}", is_aarch64_feature_detected!("sve"));
+    println!("tme: {}", is_aarch64_feature_detected!("tme"));
+    // tidy-alphabetical-end
 }
 
 #[test]
 #[cfg(all(target_arch = "powerpc", target_os = "linux"))]
 fn powerpc_linux() {
     use std::arch::is_powerpc_feature_detected;
+    // tidy-alphabetical-start
     println!("altivec: {}", is_powerpc_feature_detected!("altivec"));
-    println!("vsx: {}", is_powerpc_feature_detected!("vsx"));
     println!("power8: {}", is_powerpc_feature_detected!("power8"));
+    println!("vsx: {}", is_powerpc_feature_detected!("vsx"));
+    // tidy-alphabetical-end
 }
 
 #[test]
 #[cfg(all(target_arch = "powerpc64", target_os = "linux"))]
 fn powerpc64_linux() {
     use std::arch::is_powerpc64_feature_detected;
+    // tidy-alphabetical-start
     println!("altivec: {}", is_powerpc64_feature_detected!("altivec"));
-    println!("vsx: {}", is_powerpc64_feature_detected!("vsx"));
     println!("power8: {}", is_powerpc64_feature_detected!("power8"));
+    println!("vsx: {}", is_powerpc64_feature_detected!("vsx"));
+    // tidy-alphabetical-end
 }
 
 #[test]
@@ -102,9 +110,9 @@ fn x86_all() {
     // the below is in alphabetical order and matches
     // the order of X86_ALLOWED_FEATURES in rustc_codegen_ssa's target_features.rs
 
+    // tidy-alphabetical-start
     println!("adx: {:?}", is_x86_feature_detected!("adx"));
     println!("aes: {:?}", is_x86_feature_detected!("aes"));
-    println!("avx: {:?}", is_x86_feature_detected!("avx"));
     println!("avx2: {:?}", is_x86_feature_detected!("avx2"));
     println!("avx512bf16: {:?}", is_x86_feature_detected!("avx512bf16"));
     println!("avx512bitalg: {:?}", is_x86_feature_detected!("avx512bitalg"));
@@ -117,13 +125,14 @@ fn x86_all() {
     println!("avx512ifma: {:?}", is_x86_feature_detected!("avx512ifma"));
     println!("avx512pf: {:?}", is_x86_feature_detected!("avx512pf"));
     println!("avx512vaes: {:?}", is_x86_feature_detected!("avx512vaes"));
-    println!("avx512vbmi: {:?}", is_x86_feature_detected!("avx512vbmi"));
     println!("avx512vbmi2: {:?}", is_x86_feature_detected!("avx512vbmi2"));
+    println!("avx512vbmi: {:?}", is_x86_feature_detected!("avx512vbmi"));
     println!("avx512vl: {:?}", is_x86_feature_detected!("avx512vl"));
     println!("avx512vnni: {:?}", is_x86_feature_detected!("avx512vnni"));
     println!("avx512vp2intersect: {:?}", is_x86_feature_detected!("avx512vp2intersect"));
     println!("avx512vpclmulqdq: {:?}", is_x86_feature_detected!("avx512vpclmulqdq"));
     println!("avx512vpopcntdq: {:?}", is_x86_feature_detected!("avx512vpopcntdq"));
+    println!("avx: {:?}", is_x86_feature_detected!("avx"));
     println!("bmi1: {:?}", is_x86_feature_detected!("bmi1"));
     println!("bmi2: {:?}", is_x86_feature_detected!("bmi2"));
     println!("cmpxchg16b: {:?}", is_x86_feature_detected!("cmpxchg16b"));
@@ -138,16 +147,17 @@ fn x86_all() {
     println!("rdseed: {:?}", is_x86_feature_detected!("rdseed"));
     println!("rtm: {:?}", is_x86_feature_detected!("rtm"));
     println!("sha: {:?}", is_x86_feature_detected!("sha"));
-    println!("sse: {:?}", is_x86_feature_detected!("sse"));
     println!("sse2: {:?}", is_x86_feature_detected!("sse2"));
     println!("sse3: {:?}", is_x86_feature_detected!("sse3"));
     println!("sse4.1: {:?}", is_x86_feature_detected!("sse4.1"));
     println!("sse4.2: {:?}", is_x86_feature_detected!("sse4.2"));
     println!("sse4a: {:?}", is_x86_feature_detected!("sse4a"));
+    println!("sse: {:?}", is_x86_feature_detected!("sse"));
     println!("ssse3: {:?}", is_x86_feature_detected!("ssse3"));
     println!("tbm: {:?}", is_x86_feature_detected!("tbm"));
     println!("xsave: {:?}", is_x86_feature_detected!("xsave"));
     println!("xsavec: {:?}", is_x86_feature_detected!("xsavec"));
     println!("xsaveopt: {:?}", is_x86_feature_detected!("xsaveopt"));
     println!("xsaves: {:?}", is_x86_feature_detected!("xsaves"));
+    // tidy-alphabetical-end
 }

src/librustdoc/clean/types.rs

@@ -2540,7 +2540,7 @@ impl SubstParam {
 mod size_asserts {
     use super::*;
     use rustc_data_structures::static_assert_size;
-    // These are in alphabetical order, which is easy to maintain.
+    // tidy-alphabetical-start
     static_assert_size!(Crate, 72); // frequently moved by-value
     static_assert_size!(DocFragment, 32);
     static_assert_size!(GenericArg, 48);
@@ -2550,4 +2550,5 @@ mod size_asserts {
     static_assert_size!(ItemKind, 88);
     static_assert_size!(PathSegment, 40);
     static_assert_size!(Type, 48);
+    // tidy-alphabetical-end
 }

src/tools/tidy/src/alphabetical.rs

@@ -29,7 +29,8 @@ fn is_close_bracket(c: char) -> bool {
     matches!(c, ')' | ']' | '}')
 }
 
-const START_COMMENT: &str = "// tidy-alphabetical-start";
+// Don't let tidy check this here :D
+const START_COMMENT: &str = concat!("// tidy-alphabetical", "-start");
 const END_COMMENT: &str = "// tidy-alphabetical-end";
 
 fn check_section<'a>(
@@ -47,7 +48,7 @@ fn check_section<'a>(
         if line.contains(START_COMMENT) {
             tidy_error!(
                 bad,
-                "{file}:{} found `// tidy-alphabetical-start` expecting `// tidy-alphabetical-end`",
+                "{file}:{} found `{START_COMMENT}` expecting `{END_COMMENT}`",
                 line_idx
             )
         }
@@ -102,10 +103,7 @@ pub fn check(path: &Path, bad: &mut bool) {
             if line.contains(START_COMMENT) {
                 check_section(file, &mut lines, bad);
                 if lines.peek().is_none() {
-                    tidy_error!(
+                    tidy_error!(bad, "{file}: reached end of file expecting `{END_COMMENT}`")
-                        bad,
-                        "{file}: reached end of file expecting `// tidy-alphabetical-end`"
-                    )
                 }
             }
         }

src/tools/tidy/src/main.rs

@@ -90,7 +90,9 @@ fn main() {
         check!(edition, &compiler_path);
         check!(edition, &library_path);
 
+        check!(alphabetical, &src_path);
         check!(alphabetical, &compiler_path);
+        check!(alphabetical, &library_path);
 
         let collected = {
             while handles.len() >= concurrency.get() {