Auto merge of #123508 - WaffleLapkin:never-type-2024, r=compiler-errors

Edition 2024: Make `!` fall back to `!`

This PR changes never type fallback to be `!` (the never type itself) in the next, 2024, edition.

This makes the never type's behavior more intuitive (in 2024 edition) and is the first step of the path to stabilize it.

r? `@compiler-errors`

compiler/rustc_hir_typeck/src/fallback.rs

@@ -18,12 +18,12 @@
 #[derive(Copy, Clone)]
 pub enum DivergingFallbackBehavior {
     /// Always fallback to `()` (aka "always spontaneous decay")
-    FallbackToUnit,
+    ToUnit,
     /// Sometimes fallback to `!`, but mainly fallback to `()` so that most of the crates are not broken.
-    FallbackToNiko,
+    ContextDependent,
     /// Always fallback to `!` (which should be equivalent to never falling back + not making
     /// never-to-any coercions unless necessary)
-    FallbackToNever,
+    ToNever,
     /// Don't fallback at all
     NoFallback,
 }
@@ -373,13 +373,12 @@ fn calculate_diverging_fallback(
                 diverging_fallback.insert(diverging_ty, ty);
             };
 
-            use DivergingFallbackBehavior::*;
             match behavior {
-                FallbackToUnit => {
+                DivergingFallbackBehavior::ToUnit => {
                     debug!("fallback to () - legacy: {:?}", diverging_vid);
                     fallback_to(self.tcx.types.unit);
                 }
-                FallbackToNiko => {
+                DivergingFallbackBehavior::ContextDependent => {
                     if found_infer_var_info.self_in_trait && found_infer_var_info.output {
                         // This case falls back to () to ensure that the code pattern in
                         // tests/ui/never_type/fallback-closure-ret.rs continues to
@@ -415,14 +414,14 @@ fn calculate_diverging_fallback(
                         fallback_to(self.tcx.types.never);
                     }
                 }
-                FallbackToNever => {
+                DivergingFallbackBehavior::ToNever => {
                     debug!(
                         "fallback to ! - `rustc_never_type_mode = \"fallback_to_never\")`: {:?}",
                         diverging_vid
                     );
                     fallback_to(self.tcx.types.never);
                 }
-                NoFallback => {
+                DivergingFallbackBehavior::NoFallback => {
                     debug!(
                         "no fallback - `rustc_never_type_mode = \"no_fallback\"`: {:?}",
                         diverging_vid

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -124,7 +124,7 @@ pub fn new(
         body_id: LocalDefId,
     ) -> FnCtxt<'a, 'tcx> {
         let (diverging_fallback_behavior, diverging_block_behavior) =
-            parse_never_type_options_attr(root_ctxt.tcx);
+            never_type_behavior(root_ctxt.tcx);
         FnCtxt {
             body_id,
             param_env,
@@ -387,11 +387,33 @@ pub fn from_raw(fcx: &FnCtxt<'_, 'tcx>, span: Span, raw: Ty<'tcx>) -> LoweredTy<
     }
 }
 
+fn never_type_behavior(tcx: TyCtxt<'_>) -> (DivergingFallbackBehavior, DivergingBlockBehavior) {
+    let (fallback, block) = parse_never_type_options_attr(tcx);
+    let fallback = fallback.unwrap_or_else(|| default_fallback(tcx));
+    let block = block.unwrap_or_default();
+
+    (fallback, block)
+}
+
+/// Returns the default fallback which is used when there is no explicit override via `#![never_type_options(...)]`.
+fn default_fallback(tcx: TyCtxt<'_>) -> DivergingFallbackBehavior {
+    // Edition 2024: fallback to `!`
+    if tcx.sess.edition().at_least_rust_2024() {
+        return DivergingFallbackBehavior::ToNever;
+    }
+
+    // `feature(never_type_fallback)`: fallback to `!` or `()` trying to not break stuff
+    if tcx.features().never_type_fallback {
+        return DivergingFallbackBehavior::ContextDependent;
+    }
+
+    // Otherwise: fallback to `()`
+    DivergingFallbackBehavior::ToUnit
+}
+
 fn parse_never_type_options_attr(
     tcx: TyCtxt<'_>,
-) -> (DivergingFallbackBehavior, DivergingBlockBehavior) {
-    use DivergingFallbackBehavior::*;
-
+) -> (Option<DivergingFallbackBehavior>, Option<DivergingBlockBehavior>) {
     // Error handling is dubious here (unwraps), but that's probably fine for an internal attribute.
     // Just don't write incorrect attributes <3
 
@@ -407,10 +429,10 @@ fn parse_never_type_options_attr(
         if item.has_name(sym::fallback) && fallback.is_none() {
             let mode = item.value_str().unwrap();
             match mode {
-                sym::unit => fallback = Some(FallbackToUnit),
-                sym::niko => fallback = Some(FallbackToNiko),
-                sym::never => fallback = Some(FallbackToNever),
-                sym::no => fallback = Some(NoFallback),
+                sym::unit => fallback = Some(DivergingFallbackBehavior::ToUnit),
+                sym::niko => fallback = Some(DivergingFallbackBehavior::ContextDependent),
+                sym::never => fallback = Some(DivergingFallbackBehavior::ToNever),
+                sym::no => fallback = Some(DivergingFallbackBehavior::NoFallback),
                 _ => {
                     tcx.dcx().span_err(item.span(), format!("unknown never type fallback mode: `{mode}` (supported: `unit`, `niko`, `never` and `no`)"));
                 }
@@ -439,11 +461,5 @@ fn parse_never_type_options_attr(
         );
     }
 
-    let fallback = fallback.unwrap_or_else(|| {
-        if tcx.features().never_type_fallback { FallbackToNiko } else { FallbackToUnit }
-    });
-
-    let block = block.unwrap_or_default();
-
     (fallback, block)
 }

tests/ui/editions/never-type-fallback-breaking.e2024.stderr

@@ -0,0 +1,26 @@
+error[E0277]: the trait bound `!: Default` is not satisfied
+  --> $DIR/never-type-fallback-breaking.rs:17:17
+   |
+LL |         true => Default::default(),
+   |                 ^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `!`
+   |
+   = note: this error might have been caused by changes to Rust's type-inference algorithm (see issue #48950 <https://github.com/rust-lang/rust/issues/48950> for more information)
+   = help: did you intend to use the type `()` here instead?
+
+error[E0277]: the trait bound `!: Default` is not satisfied
+  --> $DIR/never-type-fallback-breaking.rs:30:5
+   |
+LL |     deserialize()?;
+   |     ^^^^^^^^^^^^^ the trait `Default` is not implemented for `!`
+   |
+   = note: this error might have been caused by changes to Rust's type-inference algorithm (see issue #48950 <https://github.com/rust-lang/rust/issues/48950> for more information)
+   = help: did you intend to use the type `()` here instead?
+note: required by a bound in `deserialize`
+  --> $DIR/never-type-fallback-breaking.rs:26:23
+   |
+LL |     fn deserialize<T: Default>() -> Option<T> {
+   |                       ^^^^^^^ required by this bound in `deserialize`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

tests/ui/editions/never-type-fallback-breaking.rs

@@ -0,0 +1,34 @@
+//@ revisions: e2021 e2024
+//
+//@[e2021] edition: 2021
+//@[e2024] edition: 2024
+//@[e2024] compile-flags: -Zunstable-options
+//
+//@[e2021] run-pass
+//@[e2024] check-fail
+
+fn main() {
+    m();
+    q();
+}
+
+fn m() {
+    let x = match true {
+        true => Default::default(),
+        //[e2024]~^ error: the trait bound `!: Default` is not satisfied
+        false => panic!("..."),
+    };
+
+    dbg!(x);
+}
+
+fn q() -> Option<()> {
+    fn deserialize<T: Default>() -> Option<T> {
+        Some(T::default())
+    }
+
+    deserialize()?;
+    //[e2024]~^ error: the trait bound `!: Default` is not satisfied
+
+    None
+}

tests/ui/editions/never-type-fallback.e2021.run.stdout

@@ -0,0 +1 @@
+return type = ()

tests/ui/editions/never-type-fallback.e2024.run.stdout

@@ -0,0 +1 @@
+return type = !

tests/ui/editions/never-type-fallback.rs

@@ -0,0 +1,16 @@
+//@ revisions: e2021 e2024
+//
+//@[e2021] edition: 2021
+//@[e2024] edition: 2024
+//@[e2024] compile-flags: -Zunstable-options
+//
+//@ run-pass
+//@ check-run-results
+
+fn main() {
+    print_return_type_of(|| panic!());
+}
+
+fn print_return_type_of<R>(_: impl FnOnce() -> R) {
+    println!("return type = {}", std::any::type_name::<R>());
+}

tests/ui/never_type/from_infer_breaking_with_unit_fallback.rs

@@ -0,0 +1,29 @@
+// issue: rust-lang/rust#66757
+//
+// This is a *minimization* of the issue.
+// Note that the original version with the `?` does not fail anymore even with fallback to unit,
+// see `tests/ui/never_type/question_mark_from_never.rs`.
+//
+//@ revisions: unit never
+//@[never] check-pass
+#![allow(internal_features)]
+#![feature(rustc_attrs, never_type)]
+#![cfg_attr(unit, rustc_never_type_options(fallback = "unit"))]
+#![cfg_attr(never, rustc_never_type_options(fallback = "never"))]
+
+struct E;
+
+impl From<!> for E {
+    fn from(_: !) -> E {
+        E
+    }
+}
+
+#[allow(unreachable_code)]
+fn foo(never: !) {
+    <E as From<!>>::from(never); // Ok
+    <E as From<_>>::from(never); // Should the inference fail?
+    //[unit]~^ error: the trait bound `E: From<()>` is not satisfied
+}
+
+fn main() {}

tests/ui/never_type/from_infer_breaking_with_unit_fallback.unit.stderr

@@ -0,0 +1,12 @@
+error[E0277]: the trait bound `E: From<()>` is not satisfied
+  --> $DIR/from_infer_breaking_with_unit_fallback.rs:25:6
+   |
+LL |     <E as From<_>>::from(never); // Should the inference fail?
+   |      ^ the trait `From<()>` is not implemented for `E`
+   |
+   = help: the trait `From<!>` is implemented for `E`
+   = help: for that trait implementation, expected `!`, found `()`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.

tests/ui/never_type/question_mark_from_never.rs

@@ -0,0 +1,46 @@
+// issue: rust-lang/rust#66757
+//
+// See also: `tests/ui/never_type/from_infer_breaking_with_unit_fallback.rs`.
+//
+//@ revisions: unit never
+//@ check-pass
+#![allow(internal_features)]
+#![feature(rustc_attrs, never_type)]
+#![cfg_attr(unit, rustc_never_type_options(fallback = "unit"))]
+#![cfg_attr(never, rustc_never_type_options(fallback = "never"))]
+
+type Infallible = !;
+
+struct E;
+
+impl From<Infallible> for E {
+    fn from(_: Infallible) -> E {
+        E
+    }
+}
+
+fn u32_try_from(x: u32) -> Result<u32, Infallible> {
+    Ok(x)
+}
+
+fn _f() -> Result<(), E> {
+    // In an old attempt to make `Infallible = !` this caused a problem.
+    //
+    // Because at the time the code desugared to
+    //
+    //   match u32::try_from(1u32) {
+    //       Ok(x) => x, Err(e) => return Err(E::from(e))
+    //   }
+    //
+    // With `Infallible = !`, `e: !` but with fallback to `()`, `e` in `E::from(e)` decayed to `()`
+    // causing an error.
+    //
+    // This does not happen with `Infallible = !`.
+    // And also does not happen with the newer `?` desugaring that does not pass `e` by value.
+    // (instead we only pass `Result<!, Error>` (where `Error = !` in this case) which does not get
+    // the implicit coercion and thus does not decay even with fallback to unit)
+    u32_try_from(1u32)?;
+    Ok(())
+}
+
+fn main() {}