[for crater run] make core::convert::Infallible be !

Author: arielb1

src/libcore/convert.rs

@@ -40,8 +40,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::fmt;
-
 /// An identity function.
 ///
 /// Two things are important to note about this function:
@@ -426,9 +424,7 @@ pub trait TryInto<T>: Sized {
 /// - `TryFrom<T> for U` implies [`TryInto`]`<U> for T`
 /// - [`try_from`] is reflexive, which means that `TryFrom<T> for T`
 /// is implemented and cannot fail -- the associated `Error` type for
-/// calling `T::try_from()` on a value of type `T` is [`Infallible`].
-/// When the [`!`] type is stabilized [`Infallible`] and [`!`] will be
-/// equivalent.
+/// calling `T::try_from()` on a value of type `T` is [`!`].
 ///
 /// `TryFrom<T>` can be implemented as follows:
 ///
@@ -477,7 +473,6 @@ pub trait TryInto<T>: Sized {
 /// [`TryInto`]: trait.TryInto.html
 /// [`i32::MAX`]: ../../std/i32/constant.MAX.html
 /// [`!`]: ../../std/primitive.never.html
-/// [`Infallible`]: enum.Infallible.html
 #[stable(feature = "try_from", since = "1.34.0")]
 pub trait TryFrom<T>: Sized {
     /// The type returned in the event of a conversion error.
@@ -610,110 +605,6 @@ impl AsRef<str> for str {
 // THE NO-ERROR ERROR TYPE
 ////////////////////////////////////////////////////////////////////////////////
 
-/// The error type for errors that can never happen.
-///
-/// Since this enum has no variant, a value of this type can never actually exist.
-/// This can be useful for generic APIs that use [`Result`] and parameterize the error type,
-/// to indicate that the result is always [`Ok`].
-///
-/// For example, the [`TryFrom`] trait (conversion that returns a [`Result`])
-/// has a blanket implementation for all types where a reverse [`Into`] implementation exists.
-///
-/// ```ignore (illustrates std code, duplicating the impl in a doctest would be an error)
-/// impl<T, U> TryFrom<U> for T where U: Into<T> {
-///     type Error = Infallible;
-///
-///     fn try_from(value: U) -> Result<Self, Infallible> {
-///         Ok(U::into(value))  // Never returns `Err`
-///     }
-/// }
-/// ```
-///
-/// # Future compatibility
-///
-/// This enum has the same role as [the `!` “never” type][never],
-/// which is unstable in this version of Rust.
-/// When `!` is stabilized, we plan to make `Infallible` a type alias to it:
-///
-/// ```ignore (illustrates future std change)
-/// pub type Infallible = !;
-/// ```
-///
-/// … and eventually deprecate `Infallible`.
-///
-///
-/// However there is one case where `!` syntax can be used
-/// before `!` is stabilized as a full-fleged type: in the position of a function’s return type.
-/// Specifically, it is possible implementations for two different function pointer types:
-///
-/// ```
-/// trait MyTrait {}
-/// impl MyTrait for fn() -> ! {}
-/// impl MyTrait for fn() -> std::convert::Infallible {}
-/// ```
-///
-/// With `Infallible` being an enum, this code is valid.
-/// However when `Infallible` becomes an alias for the never type,
-/// the two `impl`s will start to overlap
-/// and therefore will be disallowed by the language’s trait coherence rules.
-///
-/// [`Ok`]: ../result/enum.Result.html#variant.Ok
-/// [`Result`]: ../result/enum.Result.html
-/// [`TryFrom`]: trait.TryFrom.html
-/// [`Into`]: trait.Into.html
-/// [never]: ../../std/primitive.never.html
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-#[derive(Copy)]
-pub enum Infallible {}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Clone for Infallible {
-    fn clone(&self) -> Infallible {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl fmt::Debug for Infallible {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl fmt::Display for Infallible {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl PartialEq for Infallible {
-    fn eq(&self, _: &Infallible) -> bool {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Eq for Infallible {}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl PartialOrd for Infallible {
-    fn partial_cmp(&self, _other: &Self) -> Option<crate::cmp::Ordering> {
-        match *self {}
-    }
-}
-
+/// Blah Blah Blah
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Ord for Infallible {
-    fn cmp(&self, _other: &Self) -> crate::cmp::Ordering {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl From<!> for Infallible {
-    fn from(x: !) -> Self {
-        x
-    }
-}
+pub type Infallible = !;

src/libcore/num/mod.rs

@@ -4,7 +4,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::convert::{TryFrom, Infallible};
+use crate::convert::{TryFrom};
 use crate::fmt;
 use crate::intrinsics;
 use crate::mem;
@@ -4674,13 +4674,6 @@ impl fmt::Display for TryFromIntError {
     }
 }
 
-#[stable(feature = "try_from", since = "1.34.0")]
-impl From<Infallible> for TryFromIntError {
-    fn from(x: Infallible) -> TryFromIntError {
-        match x {}
-    }
-}
-
 #[unstable(feature = "never_type", issue = "35121")]
 impl From<!> for TryFromIntError {
     fn from(never: !) -> TryFromIntError {

src/libstd/error.rs

@@ -536,13 +536,6 @@ impl Error for string::FromUtf16Error {
     }
 }
 
-#[stable(feature = "str_parse_error2", since = "1.8.0")]
-impl Error for string::ParseError {
-    fn description(&self) -> &str {
-        match *self {}
-    }
-}
-
 #[stable(feature = "decode_utf16", since = "1.9.0")]
 impl Error for char::DecodeUtf16Error {
     fn description(&self) -> &str {