8000 Rollup merge of #65355 - Centril:almost-is-never-enough, r=oli-obk · Centril/rust@0828d53 · GitHub
[go: up one dir, main page]
Skip to content

Commit 0828d53

Browse files
CentrilCentril
authored
Rollup merge of rust-lang#65355 - Centril:almost-is-never-enough, r=oli-obk
Stabilize `!` in Rust 1.41.0 This PR stabilizes the `never_type` (written `!`). The type represents computations that we know diverge in the type system and therefore has no values / inhabitants / elements / members. The current nightly version is 1.40.0 which will become stable on 2019-12-19. Tracking issue: rust-lang#35121. Closes rust-lang#57012. Closes rust-lang#58184. Original stabilization report: rust-lang#57012 (comment) Additional notes: - In rust-lang#62661 we reserved `impl<T> From<!> for T` so this concern should be resolved. - The type inference fallback change is moved to `#![feature(never_type_fallback)]` (rust-lang#65992). - You can find all of the tests referencing `never_type` in this PR which also reorganizes these tests whereas they were more scattered before. r? @nikomatsakis
2 parents f1b882b + 238d03b commit 0828d53

File tree

120 files changed

+205
-415
lines changed
  • ui

    • Some content is hidden

    Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

    120 files changed

    +205
    -415
    lines changed

    ‎src/libcore/clone.rs

    Lines changed: 1 addition & 1 deletion
    Original file line numberDiff line numberDiff line change
    @@ -185,7 +185,7 @@ mod impls {
    185185
    bool char
    186186
    }
    187187

    188-
    #[unstable(feature = "never_type", issue = "35121")]
    188+
    #[stable(feature = "never_type", since = "1.41.0")]
    189189
    impl Clone for ! {
    190190
    #[inline]
    191191
    fn clone(&self) -> Self {

    ‎src/libcore/cmp.rs

    Lines changed: 4 additions & 4 deletions
    Original file line numberDiff line numberDiff line change
    @@ -1128,24 +1128,24 @@ mod impls {
    11281128

    11291129
    ord_impl! { char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
    11301130

    1131-
    #[unstable(feature = "never_type", issue = "35121")]
    1131+
    #[stable(feature = "never_type", since = "1.41.0")]
    11321132
    impl PartialEq for ! {
    11331133
    fn eq(&self, _: &!) -> bool {
    11341134
    *self
    11351135
    }
    11361136
    }
    11371137

    1138-
    #[unstable(feature = "never_type", issue = "35121")]
    1138+
    #[stable(feature = "never_type", since = "1.41.0")]
    11391139
    impl Eq for ! {}
    11401140

    1141-
    #[unstable(feature = "never_type", issue = "35121")]
    1141+
    #[stable(feature = "never_type", since = "1.41.0")]
    11421142
    impl PartialOrd for ! {
    11431143
    fn partial_cmp(&self, _: &!) -> Option<Ordering> {
    11441144
    *self
    11451145
    }
    11461146
    }
    11471147

    1148-
    #[unstable(feature = "never_type", issue = "35121")]
    1148+
    #[stable(feature = "never_type", since = "1.41.0")]
    11491149
    impl Ord for ! {
    11501150
    fn cmp(&self, _: &!) -> Ordering {
    11511151
    *self

    ‎src/libcore/convert.rs

    Lines changed: 7 additions & 88 deletions
    Original file line numberDiff line numberDiff line change
    @@ -40,8 +40,6 @@
    4040
    4141
    #![stable(feature = "rust1", since = "1.0.0")]
    4242

    43-
    use crate::fmt;
    44-
    4543
    /// The identity function.
    4644
    ///
    4745
    /// Two things are important to note about this function:
    @@ -426,9 +424,7 @@ pub trait TryInto<T>: Sized {
    426424
    /// - `TryFrom<T> for U` implies [`TryInto`]`<U> for T`
    427425
    /// - [`try_from`] is reflexive, which means that `TryFrom<T> for T`
    428426
    /// is implemented and cannot fail -- the associated `Error` type for
    429-
    /// calling `T::try_from()` on a value of type `T` is [`Infallible`].
    430-
    /// When the [`!`] type is stabilized [`Infallible`] and [`!`] will be
    431-
    /// equivalent.
    427+
    /// calling `T::try_from()` on a value of type `T` is [`!`].
    432428
    ///
    433429
    /// `TryFrom<T>` can be implemented as follows:
    434430
    ///
    @@ -477,7 +473,6 @@ pub trait TryInto<T>: Sized {
    477473
    /// [`TryInto`]: trait.TryInto.html
    478474
    /// [`i32::MAX`]: ../../std/i32/constant.MAX.html
    479475
    /// [`!`]: ../../std/primitive.never.html
    480-
    /// [`Infallible`]: enum.Infallible.html
    481476
    #[stable(feature = "try_from", since = "1.34.0")]
    482477
    pub trait TryFrom<T>: Sized {
    483478
    /// The type returned in the event of a conversion error.
    @@ -615,9 +610,9 @@ impl AsRef<str> for str {
    615610
    // THE NO-ERROR ERROR TYPE
    616611
    ////////////////////////////////////////////////////////////////////////////////
    617612

    618-
    /// The error type for errors that can never happen.
    613+
    /// A type alias for [the `!` “never” type][never].
    619614
    ///
    620-
    /// Since this enum has no variant, a value of this type can never actually exist.
    615+
    /// `Infallible` represents types of errors that can never happen since `!` has no valid values.
    621616
    /// This can be useful for generic APIs that use [`Result`] and parameterize the error type,
    622617
    /// to indicate that the result is always [`Ok`].
    623618
    ///
    @@ -634,91 +629,15 @@ impl AsRef<str> for str {
    634629
    /// }
    635630
    /// ```
    636631
    ///
    637-
    /// # Future compatibility
    638-
    ///
    639-
    /// This enum has the same role as [the `!` “never” type][never],
    640-
    /// which is unstable in this version of Rust.
    641-
    /// When `!` is stabilized, we plan to make `Infallible` a type alias to it:
    642-
    ///
    643-
    /// ```ignore (illustrates future std change)
    644-
    /// pub type Infallible = !;
    645-
    /// ```
    646-
    ///
    647-
    /// … and eventually deprecate `Infallible`.
    648-
    ///
    649-
    ///
    650-
    /// However there is one case where `!` syntax can be used
    651-
    /// before `!` is stabilized as a full-fleged type: in the position of a function’s return type.
    652-
    /// Specifically, it is possible implementations for two different function pointer types:
    653-
    ///
    654-
    /// ```
    655-
    /// trait MyTrait {}
    656-
    /// impl MyTrait for fn() -> ! {}
    657-
    /// impl MyTrait for fn() -> std::convert::Infallible {}
    658-
    /// ```
    632+
    /// # Eventual deprecation
    659633
    ///
    660-
    /// With `Infallible` being an enum, this code is valid.
    661-
    /// However when `Infallible` becomes an alias for the never type,
    662-
    /// the two `impl`s will start to overlap
    663-
    /// and therefore will be disallowed by the language’s trait coherence rules.
    634+
    /// Previously, `Infallible` was defined as `enum Infallible {}`.
    635+
    /// Now that it is merely a type alias to `!`, we will eventually deprecate `Infallible`.
    664636
    ///
    665637
    /// [`Ok`]: ../result/enum.Result.html#variant.Ok
    666638
    /// [`Result`]: ../result/enum.Result.html
    667639
    /// [`TryFrom`]: trait.TryFrom.html
    668640
    /// [`Into`]: trait.Into.html
    669641
    /// [never]: ../../std/primitive.never.html
    670642
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    671-
    #[derive(Copy)]
    672-
    pub enum Infallible {}
    673-
    674-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    675-
    impl Clone for Infallible {
    676-
    fn clone(&self) -> Infallible {
    677-
    match *self {}
    678-
    }
    679-
    }
    680-
    681-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    682-
    impl fmt::Debug for Infallible {
    683-
    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
    684-
    match *self {}
    685-
    }
    686-
    }
    687-
    688-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    689-
    impl fmt::Display for Infallible {
    690-
    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
    691-
    match *self {}
    692-
    }
    693-
    }
    694-
    695-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    696-
    impl PartialEq for Infallible {
    697-
    fn eq(&self, _: &Infallible) -> bool {
    698-
    match *self {}
    699-
    }
    700-
    }
    701-
    702-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    703-
    impl Eq for Infallible {}
    704-
    705-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    706-
    impl PartialOrd for Infallible {
    707-
    fn partial_cmp(&self, _other: &Self) -> Option<crate::cmp::Ordering> {
    708-
    match *self {}
    709-
    }
    710-
    }
    711-
    712-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    713-
    impl Ord for Infallible {
    714-
    fn cmp(&self, _other: &Self) -> crate::cmp::Ordering {
    715-
    match *self {}
    716-
    }
    717-
    }
    718-
    719-
    #[stable(feature = "convert_infallible", since = "1.34.0")]
    720-
    impl From<!> for Infallible {
    721-
    fn from(x: !) -> Self {
    722-
    x
    723-
    }
    724-
    }
    643+
    pub type Infallible = !;

    ‎src/libcore/fmt/mod.rs

    Lines changed: 2 additions & 2 deletions
    Original file line numberDiff line numberDiff line change
    @@ -1935,14 +1935,14 @@ macro_rules! fmt_refs {
    19351935

    19361936
    fmt_refs! { Debug, Display, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp }
    19371937

    1938-
    #[unstable(feature = "never_type", issue = "35121")]
    1938+
    #[stable(feature = "never_type", since = "1.41.0")]
    19391939
    impl Debug for ! {
    19401940
    fn fmt(&self, _: &mut Formatter<'_>) -> Result {
    19411941
    *self
    19421942
    }
    19431943
    }
    19441944

    1945-
    #[unstable(feature = "never_type", issue = "35121")]
    1945+
    #[stable(feature = "never_type", since = "1.41.0")]
    19461946
    impl Display for ! {
    19471947
    fn fmt(&self, _: &mut Formatter<'_>) -> Result {
    19481948
    *self

    ‎src/libcore/lib.rs

    Lines changed: 1 addition & 1 deletion
    Original file line numberDiff line numberDiff line change
    @@ -85,7 +85,7 @@
    8585
    #![feature(iter_once_with)]
    8686
    #![feature(lang_items)]
    8787
    #![feature(link_llvm_intrinsics)]
    88-
    #![feature(never_type)]
    88+
    #![cfg_attr(bootstrap, feature(never_type))]
    8989
    #![feature(nll)]
    9090
    #![feature(exhaustive_patterns)]
    9191
    #![feature(no_core)]

    ‎src/libcore/marker.rs

    Lines changed: 1 addition & 1 deletion
    Original file line numberDiff line numberDiff line change
    @@ -774,7 +774,7 @@ mod copy_impls {
    774774
    bool char
    775775
    }
    776776

    777-
    #[unstable(feature = "never_type", issue = "35121")]
    777+
    #[stable(feature = "never_type", since = "1.41.0")]
    778778
    impl Copy for ! {}
    779779

    780780
    #[stable(feature = "rust1", since = "1.0.0")]

    ‎src/libcore/num/mod.rs

    Lines changed: 1 addition & 11 deletions
    Original file line numberDiff line numberDiff line change
    @@ -4,7 +4,7 @@
    44
    55
    #![stable(feature = "rust1", since = "1.0.0")]
    66

    7-
    use crate::convert::{TryFrom, Infallible};
    7+
    use crate::convert::TryFrom;
    88
    use crate::fmt;
    99
    use crate::intrinsics;
    1010
    use crate::mem;
    @@ -4722,18 +4722,8 @@ impl fmt::Display for TryFromIntError {
    47224722
    }
    47234723

    47244724
    #[stable(feature = "try_from", since = "1.34.0")]
    4725-
    impl From<Infallible> for TryFromIntError {
    4726-
    fn from(x: Infallible) -> TryFromIntError {
    4727-
    match x {}
    4728-
    }
    4729-
    }
    4730-
    4731-
    #[unstable(feature = "never_type", issue = "35121")]
    47324725
    impl From<!> for TryFromIntError {
    47334726
    fn from(never: !) -> TryFromIntError {
    4734-
    // Match rather than coerce to make sure that code like
    4735-
    // `From<Infallible> for TryFromIntError` above will keep working
    4736-
    // when `Infallible` becomes an alias to `!`.
    47374727
    match never {}
    47384728
    }
    47394729
    }

    ‎src/librustc/lib.rs

    Lines changed: 1 addition & 1 deletion
    Original file line numberDiff line numberDiff line change
    @@ -36,7 +36,7 @@
    3636
    #![feature(core_intrinsics)]
    3737
    #![feature(drain_filter)]
    3838
    #![cfg_attr(windows, feature(libc))]
    39-
    #![feature(never_type)]
    39+
    #![cfg_attr(bootstrap, feature(never_type))]
    4040
    #![feature(exhaustive_patterns)]
    4141
    #![feature(overlapping_marker_traits)]
    4242
    #![feature(extern_types)]

    ‎src/librustc/ty/context.rs

    Lines changed: 2 additions & 2 deletions
    Original file line numberDiff line numberDiff line change
    @@ -2440,10 +2440,10 @@ impl<'tcx> TyCtxt<'tcx> {
    24402440

    24412441
    #[inline]
    24422442
    pub fn mk_diverging_default(self) -> Ty<'tcx> {
    2443-
    if self.features().never_type {
    2443+
    if self.features().never_type_fallback {
    24442444
    self.types.never
    24452445
    } else {
    2446-
    self.intern_tup(&[])
    2446+
    self.types.unit
    24472447
    }
    24482448
    }
    24492449

    ‎src/librustc_codegen_utils/lib.rs

    Lines changed: 1 addition & 1 deletion
    Original file line numberDiff line numberDiff line change
    @@ -8,7 +8,7 @@
    88
    #![feature(box_patterns)]
    99
    #![feature(box_syntax)]
    1010
    #![feature(core_intrinsics)]
    11-
    #![feature(never_type)]
    11+
    #![cfg_attr(bootstrap, feature(never_type))]
    1212
    #![feature(nll)]
    1313
    #![feature(in_band_lifetimes)]
    1414

    0 commit comments

    Comments
     (0)
    0