Start using pattern types in libcore

Author: oli-obk

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2204,19 +2204,23 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                             )
                         }
                     }
-                    // For types with no regions we can just check that the
-                    // both operands have the same type.
-                    ty::Int(_) | ty::Uint(_) | ty::Bool | ty::Char | ty::Float(_)
-                        if ty_left == right.ty(body, tcx) => {}
-                    // Other types are compared by trait methods, not by
-                    // `Rvalue::BinaryOp`.
-                    _ => span_mirbug!(
-                        self,
-                        rvalue,
-                        "unexpected comparison types {:?} and {:?}",
-                        ty_left,
-                        right.ty(body, tcx)
-                    ),
+                    _ => {
+                        if ty_left.is_scalar() && ty_left == right.ty(body, tcx) {
+
+                            // For types with no regions we can just check that the
+                            // both operands have the same type.
+                        } else {
+                            // Other types are compared by trait methods, not by
+                            // `Rvalue::BinaryOp`.
+                            span_mirbug!(
+                                self,
+                                rvalue,
+                                "unexpected comparison types {:?} and {:?}",
+                                ty_left,
+                                right.ty(body, tcx)
+                            )
+                        }
+                    }
                 }
             }
 

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -456,7 +456,18 @@ pub(crate) fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) ->
             AdtKind::Enum => enums::build_enum_type_di_node(cx, unique_type_id),
         },
         ty::Tuple(_) => build_tuple_type_di_node(cx, unique_type_id),
-        _ => bug!("debuginfo: unexpected type in type_di_node(): {:?}", t),
+        ty::Pat(base, _) => return type_di_node(cx, base),
+        // FIXME(unsafe_binders): impl debug info
+        ty::UnsafeBinder(_) => unimplemented!(),
+        ty::Alias(..)
+        | ty::Param(_)
+        | ty::Bound(..)
+        | ty::Infer(_)
+        | ty::Placeholder(_)
+        | ty::CoroutineWitness(..)
+        | ty::Error(_) => {
+            bug!("debuginfo: unexpected type in type_di_node(): {:?}", t)
+        }
     };
 
     {

compiler/rustc_lint/src/types.rs

@@ -891,15 +891,15 @@ fn get_nullable_type<'tcx>(
             };
             return get_nullable_type(tcx, typing_env, inner_field_ty);
         }
-        ty::Int(ty) => Ty::new_int(tcx, ty),
-        ty::Uint(ty) => Ty::new_uint(tcx, ty),
+        ty::Int(_) => ty,
+        ty::Uint(_) => ty,
         ty::RawPtr(ty, mutbl) => Ty::new_ptr(tcx, ty, mutbl),
         // As these types are always non-null, the nullable equivalent of
         // `Option<T>` of these types are their raw pointer counterparts.
         ty::Ref(_region, ty, mutbl) => Ty::new_ptr(tcx, ty, mutbl),
-        // There is no nullable equivalent for Rust's function pointers,
+        // There is no nullable equivalent for Rust's function pointers or pattern types,
         // you must use an `Option<fn(..) -> _>` to represent it.
-        ty::FnPtr(..) => ty,
+        ty::Pat(..) | ty::FnPtr(..) => ty,
         // We should only ever reach this case if `ty_is_known_nonnull` is
         // extended to other types.
         ref unhandled => {

compiler/rustc_middle/src/ty/sty.rs

@@ -1257,17 +1257,19 @@ impl<'tcx> Ty<'tcx> {
     /// contents are abstract to rustc.)
     #[inline]
     pub fn is_scalar(self) -> bool {
-        matches!(
-            self.kind(),
-            Bool | Char
-                | Int(_)
-                | Float(_)
-                | Uint(_)
-                | FnDef(..)
-                | FnPtr(..)
-                | RawPtr(_, _)
-                | Infer(IntVar(_) | FloatVar(_))
-        )
+        match self.kind() {
+            Bool
+            | Char
+            | Int(_)
+            | Float(_)
+            | Uint(_)
+            | FnDef(..)
+            | FnPtr(..)
+            | RawPtr(_, _)
+            | Infer(IntVar(_) | FloatVar(_)) => true,
+            Pat(base, _) => base.is_scalar(),
+            _ => false,
+        }
     }
 
     /// Returns `true` if this type is a floating point type.

compiler/rustc_mir_transform/src/validate.rs

@@ -1062,17 +1062,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     }
                     Eq | Lt | Le | Ne | Ge | Gt => {
                         for x in [a, b] {
-                            check_kinds!(
-                                x,
-                                "Cannot {op:?} compare type {:?}",
-                                ty::Bool
-                                    | ty::Char
-                                    | ty::Int(..)
-                                    | ty::Uint(..)
-                                    | ty::Float(..)
-                                    | ty::RawPtr(..)
-                                    | ty::FnPtr(..)
-                            )
+                            if !x.is_scalar() {
+                                self.fail(location, format!("Cannot {op:?} compare type {x:?}"))
+                            }
                         }
                     }
                     Cmp => {

library/core/src/lib.rs

@@ -181,6 +181,8 @@
 #![feature(no_core)]
 #![feature(no_sanitize)]
 #![feature(optimize_attribute)]
+#![feature(pattern_type_macro)]
+#![feature(pattern_types)]
 #![feature(prelude_import)]
 #![feature(repr_simd)]
 #![feature(rustc_allow_const_fn_unstable)]

library/core/src/num/niche_types.rs

@@ -8,19 +8,28 @@ use crate::cmp::Ordering;
 use crate::fmt;
 use crate::hash::{Hash, Hasher};
 use crate::marker::StructuralPartialEq;
+#[cfg(not(bootstrap))]
+use crate::pattern_type;
 
 macro_rules! define_valid_range_type {
     ($(
         $(#[$m:meta])*
         $vis:vis struct $name:ident($int:ident as $uint:ident in $low:literal..=$high:literal);
     )+) => {$(
-        #[derive(Clone, Copy, Eq)]
+        #[derive(Clone, Copy)]
         #[repr(transparent)]
-        #[rustc_layout_scalar_valid_range_start($low)]
-        #[rustc_layout_scalar_valid_range_end($high)]
+        #[cfg_attr(bootstrap, rustc_layout_scalar_valid_range_start($low))]
+        #[cfg_attr(bootstrap, rustc_layout_scalar_valid_range_end($high))]
         $(#[$m])*
+        #[cfg(bootstrap)]
         $vis struct $name($int);
 
+        #[derive(Clone, Copy)]
+        #[repr(transparent)]
+        $(#[$m])*
+        #[cfg(not(bootstrap))]
+        $vis struct $name(pattern_type!($int is $low..=$high));
+
         const _: () = {
             // With the `valid_range` attributes, it's always specified as unsigned
             assert!(<$uint>::MIN == 0);
@@ -41,7 +50,7 @@ macro_rules! define_valid_range_type {
             #[inline]
             pub const unsafe fn new_unchecked(val: $int) -> Self {
                 // SAFETY: Caller promised that `val` is non-zero.
-                unsafe { $name(val) }
+                unsafe { $name(crate::mem::transmute(val)) }
             }
 
             #[inline]
@@ -57,6 +66,8 @@ macro_rules! define_valid_range_type {
         // by <https://github.com/rust-lang/compiler-team/issues/807>.
         impl StructuralPartialEq for $name {}
 
+        impl Eq for $name {}
+
         impl PartialEq for $name {
             #[inline]
             fn eq(&self, other: &Self) -> bool {

tests/ui/consts/const-eval/raw-bytes.64bit.stderr

@@ -68,7 +68,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/raw-bytes.rs:59:1
    |
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0: encountered 0, but expected something greater or equal to 1
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 1, align: 1) {
@@ -79,7 +79,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/raw-bytes.rs:61:1
    |
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0: encountered 0, but expected something greater or equal to 1
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: 8, align: 8) {

tests/ui/consts/const-eval/ub-nonnull.stderr

@@ -19,7 +19,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/ub-nonnull.rs:24:1
    |
 LL | const NULL_U8: NonZero<u8> = unsafe { mem::transmute(0u8) };
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0: encountered 0, but expected something greater or equal to 1
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -30,7 +30,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/ub-nonnull.rs:26:1
    |
 LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0: encountered 0, but expected something greater or equal to 1
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0.0: encountered 0, but expected something greater or equal to 1
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {

tests/ui/lint/clashing-extern-fn.stderr

@@ -1,3 +1,94 @@
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:320:36
+   |
+LL |             fn non_zero_usize() -> core::num::NonZero<usize>;
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+   = note: `#[warn(improper_ctypes)]` on by default
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:341:24
+   |
+LL |             fn f1() -> std::num::NonZero<usize>;
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:350:24
+   |
+LL |             fn f1() -> X;
+   |                        ^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:356:24
+   |
+LL |             fn f2() -> std::num::NonZero<usize>;
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:369:24
+   |
+LL |             fn f2() -> X;
+   |                        ^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:394:24
+   |
+LL |             fn f4() -> E;
+   |                        ^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:400:24
+   |
+LL |             fn f4() -> std::num::NonZero<usize>;
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:420:43
+   |
+LL |             fn option_non_zero_usize() -> Option<core::num::NonZero<usize>>;
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(isize) is 1..=-1`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:421:43
+   |
+LL |             fn option_non_zero_isize() -> Option<core::num::NonZero<isize>>;
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
+warning: `extern` block uses type `(usize) is 1..=usize::MAX`, which is not FFI-safe
+  --> $DIR/clashing-extern-fn.rs:481:46
+   |
+LL |             fn hidden_niche_transparent() -> Option<Transparent>;
+   |                                              ^^^^^^^^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider using the base type instead
+   = note: pattern types have no C equivalent
+
 warning: `extern` block uses type `Option<TransparentNoNiche>`, which is not FFI-safe
   --> $DIR/clashing-extern-fn.rs:483:55
    |
@@ -6,7 +97,6 @@ LL |             fn hidden_niche_transparent_no_niche() -> Option<TransparentNoN
    |
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
-   = note: `#[warn(improper_ctypes)]` on by default
 
 warning: `extern` block uses type `Option<UnsafeCell<NonZero<usize>>>`, which is not FFI-safe
   --> $DIR/clashing-extern-fn.rs:487:46
@@ -210,6 +300,30 @@ LL |             fn non_null_ptr() -> *const usize;
    = note: expected `unsafe extern "C" fn() -> NonNull<usize>`
               found `unsafe extern "C" fn() -> *const usize`
 
+warning: `option_non_zero_usize` redeclared with a different signature
+  --> $DIR/clashing-extern-fn.rs:420:13
+   |
+LL |             fn option_non_zero_usize() -> usize;
+   |             ------------------------------------ `option_non_zero_usize` previously declared here
+...
+LL |             fn option_non_zero_usize() -> Option<core::num::NonZero<usize>>;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |
+   = note: expected `unsafe extern "C" fn() -> usize`
+              found `unsafe extern "C" fn() -> Option<NonZero<usize>>`
+
+warning: `option_non_zero_isize` redeclared with a different signature
+  --> $DIR/clashing-extern-fn.rs:421:13
+   |
+LL |             fn option_non_zero_isize() -> isize;
+   |             ------------------------------------ `option_non_zero_isize` previously declared here
+...
+LL |             fn option_non_zero_isize() -> Option<core::num::NonZero<isize>>;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |
+   = note: expected `unsafe extern "C" fn() -> isize`
+              found `unsafe extern "C" fn() -> Option<NonZero<isize>>`
+
 warning: `option_non_zero_usize_incorrect` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:425:13
    |
@@ -234,6 +348,18 @@ LL |             fn option_non_null_ptr_incorrect() -> *const isize;
    = note: expected `unsafe extern "C" fn() -> *const usize`
               found `unsafe extern "C" fn() -> *const isize`
 
+warning: `hidden_niche_transparent` redeclared with a different signature
+  --> $DIR/clashing-extern-fn.rs:481:13
+   |
+LL |             fn hidden_niche_transparent() -> usize;
+   |             --------------------------------------- `hidden_niche_transparent` previously declared here
+...
+LL |             fn hidden_niche_transparent() -> Option<Transparent>;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |
+   = note: expected `unsafe extern "C" fn() -> usize`
+              found `unsafe extern "C" fn() -> Option<Transparent>`
+
 warning: `hidden_niche_transparent_no_niche` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:483:13
    |
@@ -258,5 +384,5 @@ LL |             fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZero<usiz
    = note: expected `unsafe extern "C" fn() -> usize`
               found `unsafe extern "C" fn() -> Option<UnsafeCell<NonZero<usize>>>`
 
-warning: 22 warnings emitted
+warning: 35 warnings emitted
 

tests/ui/lint/invalid_value.stderr

@@ -333,7 +333,6 @@ LL |         let _val: (NonZero<u32>, i32) = mem::uninitialized();
    |
    = note: `std::num::NonZero<u32>` must be non-null
    = note: because `core::num::niche_types::NonZeroU32Inner` must be non-null
-   = note: integers must be initialized
 
 error: the type `*const dyn Send` does not permit zero-initialization
   --> $DIR/invalid_value.rs:97:37
@@ -430,7 +429,6 @@ note: because `std::num::NonZero<u32>` must be non-null (in this field of the on
 LL |     Banana(NonZero<u32>),
    |            ^^^^^^^^^^^^
    = note: because `core::num::niche_types::NonZeroU32Inner` must be non-null
-   = note: integers must be initialized
 
 error: the type `bool` does not permit being left uninitialized
   --> $DIR/invalid_value.rs:111:26

tests/ui/lint/lint-ctypes-enum.stderr

@@ -0,0 +1,19 @@
+use std::pat::pattern_type;
+
+struct Thing(pattern_type!(u32 is 1..));
+
+impl Eq for Thing {}
+impl PartialEq for Thing {
+    fn eq(&self, other: &Thing) -> bool {
+        todo!()
+    }
+}
+
+const TWO: Thing = Thing(unsafe { std::mem::transmute(2_u32) });
+
+const _: () = match TWO {
+    TWO => {}
+    _ => unreachable!(),
+};
+
+fn main() {}

tests/ui/type/pattern_types/matching.rs

@@ -0,0 +1,51 @@
+error[E0658]: use of unstable library feature `pattern_type_macro`
+  --> $DIR/matching.rs:3:14
+   |
+LL | struct Thing(pattern_type!(u32 is 1..));
+   |              ^^^^^^^^^^^^
+   |
+   = note: see issue #123646 <https://github.com/rust-lang/rust/issues/123646> for more information
+   = help: add `#![feature(pattern_type_macro)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: pattern types are unstable
+  --> $DIR/matching.rs:3:14
+   |
+LL | struct Thing(pattern_type!(u32 is 1..));
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #123646 <https://github.com/rust-lang/rust/issues/123646> for more information
+   = help: add `#![feature(pattern_types)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: use of unstable library feature `pattern_type_macro`
+  --> $DIR/matching.rs:1:5
+   |
+LL | use std::pat::pattern_type;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #123646 <https://github.com/rust-lang/rust/issues/123646> for more information
+   = help: add `#![feature(pattern_type_macro)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: constant of non-structural type `Thing` in a pattern
+  --> $DIR/matching.rs:15:5
+   |
+LL | struct Thing(pattern_type!(u32 is 1..));
+   | ------------ `Thing` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+...
+LL | const TWO: Thing = Thing(unsafe { std::mem::transmute(2_u32) });
+   | ---------------- constant defined here
+...
+LL |     TWO => {}
+   |     ^^^ constant of non-structural type
+   |
+note: the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+  --> $DIR/matching.rs:6:1
+   |
+LL | impl PartialEq for Thing {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0658`.