Prefer -1 for None

Currently we pick "weird" numbers like `1114112` for `None::<char>`.  While that's not *wrong*, it's kinda *unnatural* -- a human wouldn't make that choice.

This PR instead picks `-1` for thinge like `None::<char>` -- like clang's `WEOF` -- and `None::<bool>` and such.

Any enums with more than one niched value (so not `Result` nor `Option`) remain as they were before.

Author: scottmcm

compiler/rustc_abi/src/lib.rs

@@ -2051,8 +2051,7 @@ impl Niche {
         assert!(size.bits() <= 128);
         let max_value = size.unsigned_int_max();
 
-        let niche = v.end.wrapping_add(1)..v.start;
-        let available = niche.end.wrapping_sub(niche.start) & max_value;
+        let available = v.start.wrapping_sub(v.end).wrapping_sub(1) & max_value;
         if count > available {
             return None;
         }
@@ -2080,7 +2079,15 @@ impl Niche {
             Some((start, Scalar::Initialized { value, valid_range: v.with_end(end) }))
         };
         let distance_end_zero = max_value - v.end;
-        if v.start > v.end {
+        if count == 1 {
+            // We only need one, so just pick the one closest to zero.
+            // Not only does that obviously use zero if it's possible, but it also
+            // simplifies testing things like `Option<char>`, since looking for `-1`
+            // is easier than looking for `1114112` (and matches clang's `WEOF`).
+            let next_up = size.sign_extend(v.end.wrapping_add(1)).unsigned_abs();
+            let next_down = size.sign_extend(v.start.wrapping_sub(1)).unsigned_abs();
+            if next_down <= next_up { move_start(v) } else { move_end(v) }
+        } else if v.start > v.end {
             // zero is unavailable because wrapping occurs
             move_end(v)
         } else if v.start <= distance_end_zero {

tests/codegen-llvm/enum/enum-aggregate.rs

@@ -2,6 +2,7 @@
 //@ only-64bit
 
 #![crate_type = "lib"]
+#![feature(pattern_types, pattern_type_macro)]
 
 use std::cmp::Ordering;
 use std::num::NonZero;
@@ -20,7 +21,7 @@ fn make_some_bool(x: bool) -> Option<bool> {
 fn make_none_bool() -> Option<bool> {
     // CHECK-LABEL: i8 @make_none_bool()
     // CHECK-NEXT: start:
-    // CHECK-NEXT: ret i8 2
+    // CHECK-NEXT: ret i8 -1
     None
 }
 
@@ -123,3 +124,14 @@ fn make_fully_uninhabited_result(v: u32, n: Never) -> Result<(u32, Never), (Neve
 }
 
 enum Never {}
+
+#[repr(transparent)]
+struct NewtypeIndex(std::pat::pattern_type!(u32 is 0..=0xFFFFFF00));
+
+#[no_mangle]
+pub fn make_none_newtype_index() -> Option<NewtypeIndex> {
+    // CHECK-LABEL: @make_none_newtype_index
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret i32 -1
+    None
+}

tests/codegen-llvm/enum/enum-discriminant-eq.rs

@@ -25,8 +25,8 @@ pub enum Giant {
 #[unsafe(no_mangle)]
 pub fn opt_bool_eq_discr(a: Option<bool>, b: Option<bool>) -> bool {
     // CHECK-LABEL: @opt_bool_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
-    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, -1
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, -1
     // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
     // CHECK: ret i1 %[[R]]
 
@@ -36,8 +36,8 @@ pub fn opt_bool_eq_discr(a: Option<bool>, b: Option<bool>) -> bool {
 #[unsafe(no_mangle)]
 pub fn opt_ord_eq_discr(a: Option<Ordering>, b: Option<Ordering>) -> bool {
     // CHECK-LABEL: @opt_ord_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
-    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, -2
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, -2
     // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
     // CHECK: ret i1 %[[R]]
 
@@ -58,8 +58,8 @@ pub fn opt_nz32_eq_discr(a: Option<NonZero<u32>>, b: Option<NonZero<u32>>) -> bo
 #[unsafe(no_mangle)]
 pub fn opt_ac_eq_discr(a: Option<AC>, b: Option<AC>) -> bool {
     // CHECK-LABEL: @opt_ac_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i8 %a, -128
-    // CHECK: %[[B:.+]] = icmp eq i8 %b, -128
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, -1
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, -1
     // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
     // CHECK: ret i1 %[[R]]
 

tests/codegen-llvm/enum/enum-match.rs

@@ -17,7 +17,7 @@ pub enum Enum0 {
 
 // CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match0(i8{{.+}}%0)
 // CHECK-NEXT: start:
-// CHECK-NEXT: %[[IS_B:.+]] = icmp eq i8 %0, 2
+// CHECK-NEXT: %[[IS_B:.+]] = icmp eq i8 %0, -1
 // CHECK-NEXT: %[[TRUNC:.+]] = and i8 %0, 1
 // CHECK-NEXT: %[[R:.+]] = select i1 %[[IS_B]], i8 13, i8 %[[TRUNC]]
 // CHECK-NEXT: ret i8 %[[R]]

tests/codegen-llvm/enum/enum-two-variants-match.rs

@@ -60,7 +60,7 @@ pub fn result_match(x: Result<u64, i64>) -> u16 {
 #[no_mangle]
 pub fn option_bool_match(x: Option<bool>) -> char {
     // CHECK: %[[RAW:.+]] = load i8, ptr %x
-    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], 2
+    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], -1
     // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
     // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
     // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]
@@ -81,7 +81,7 @@ use std::cmp::Ordering::{self, *};
 #[no_mangle]
 pub fn option_ordering_match(x: Option<Ordering>) -> char {
     // CHECK: %[[RAW:.+]] = load i8, ptr %x
-    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], 2
+    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], -2
     // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
     // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
     // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]

tests/codegen-llvm/function-arguments.rs

@@ -297,7 +297,7 @@ pub fn return_slice(x: &[u16]) -> &[u16] {
     x
 }
 
-// CHECK: { i16, i16 } @enum_id_1(i16 noundef{{( range\(i16 0, 3\))?}} %x.0, i16 %x.1)
+// CHECK: { i16, i16 } @enum_id_1(i16 noundef{{( range\(i16 -1, 2\))?}} %x.0, i16 %x.1)
 #[no_mangle]
 pub fn enum_id_1(x: Option<Result<u16, u16>>) -> Option<Result<u16, u16>> {
     x

tests/codegen-llvm/intrinsics/cold_path2.rs

@@ -26,7 +26,7 @@ pub fn test(x: Option<bool>) {
     }
 
     // CHECK-LABEL: void @test(i8{{.+}}%x)
-    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %x, 2
+    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %x, -1
     // CHECK: br i1 %[[IS_NONE]], label %bb2, label %bb1, !prof ![[NUM:[0-9]+]]
     // CHECK: bb1:
     // CHECK: path_a

tests/codegen-llvm/range-attribute.rs

@@ -23,7 +23,7 @@ pub fn nonzero_int(x: NonZero<u128>) -> NonZero<u128> {
     x
 }
 
-// CHECK: noundef range(i8 0, 3) i8 @optional_bool(i8{{.*}} range(i8 0, 3) %x)
+// CHECK: noundef range(i8 -1, 2) i8 @optional_bool(i8{{.*}} range(i8 -1, 2) %x)
 #[no_mangle]
 pub fn optional_bool(x: Option<bool>) -> Option<bool> {
     x

tests/ui/layout/zero-sized-array-enum-niche.stderr

@@ -370,7 +370,7 @@ error: layout_of(Result<[u32; 0], Packed<U16IsZero>>) = Layout {
                        I16,
                        false,
                    ),
-                   valid_range: 0..=1,
+                   valid_range: (..=0) | (65535..),
                },
            ),
            uninhabited: false,
@@ -380,12 +380,12 @@ error: layout_of(Result<[u32; 0], Packed<U16IsZero>>) = Layout {
                        I16,
                        false,
                    ),
-                   valid_range: 0..=1,
+                   valid_range: (..=0) | (65535..),
                },
                tag_encoding: Niche {
                    untagged_variant: 1,
                    niche_variants: 0..=0,
-                   niche_start: 1,
+                   niche_start: 65535,
                },
                tag_field: 0,
                variants: [

tests/ui/transmutability/enums/niche_optimization.rs

@@ -54,7 +54,7 @@ fn bool() {
     assert::is_transmutable::<bool, OptionLike>();
     assert::is_transmutable::<V0, OptionLike>();
     assert::is_transmutable::<V1, OptionLike>();
-    assert::is_transmutable::<V2, OptionLike>();
+    assert::is_transmutable::<V255, OptionLike>();
 }
 
 fn one_niche() {