Add #![feature(no_never_type_spontaneous_decay)]

Author: WaffleLapkin

compiler/rustc_feature/src/unstable.rs

@@ -213,6 +213,8 @@ declare_features! (
     (internal, negative_bounds, "1.71.0", None),
     /// Turns off never type fallback altogether
     (unstable, no_never_type_fallback, "CURRENT_RUSTC_VERSION", None), // no tracking issue (yet?)
+    /// Makes never type fallback always be `!`
+    (unstable, no_never_type_spontaneous_decay, "CURRENT_RUSTC_VERSION", None), // no tracking issue (yet?)
     /// Allows using `#[omit_gdb_pretty_printer_section]`.
     (internal, omit_gdb_pretty_printer_section, "1.5.0", None),
     /// Set the maximum pattern complexity allowed (not limited by default).

compiler/rustc_hir_typeck/src/fallback.rs

@@ -12,6 +12,9 @@ enum DivergingFallbackBehavior {
     FallbackToUnit,
     /// Sometimes fallback to `!`, but mainly fallback to `()` so that most of the crates are not broken.
     FallbackToNiko,
+    /// Always fallback to `!` (which should be equivalent to never falling back + not making
+    /// never-to-any coercions unless necessary)
+    FallbackToNever,
     /// Don't fallback at all
     Nope,
 }
@@ -91,9 +94,10 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
 
     fn diverging_fallback_behavior(&self) -> DivergingFallbackBehavior {
         let niko = self.tcx.features().never_type_fallback;
+        let never = self.tcx.features().no_never_type_spontaneous_decay;
         let nope = self.tcx.features().no_never_type_fallback;
 
-        if niko as u32 + nope as u32 > 1 {
+        if niko as u32 + never as u32 + nope as u32 > 1 {
             self.tcx.dcx().err("can't enable multiple never type fallback features (`never_type_fallback`, `no_never_type_fallback`)");
             return DivergingFallbackBehavior::FallbackToUnit;
         }
@@ -102,6 +106,10 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
             return DivergingFallbackBehavior::FallbackToNiko;
         }
 
+        if never {
+            return DivergingFallbackBehavior::FallbackToNever;
+        }
+
         if nope {
             return DivergingFallbackBehavior::Nope;
         }
@@ -419,6 +427,13 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
                         diverging_fallback.insert(diverging_ty, self.tcx.types.never);
                     }
                 }
+                FallbackToNever => {
+                    debug!(
+                        "fallback to ! - `feature(no_never_type_spontaneous_decay)`: {:?}",
+                        diverging_vid
+                    );
+                    diverging_fallback.insert(diverging_ty, self.tcx.types.never);
+                }
                 Nope => {
                     debug!("not fallback - `feature(no_never_type_fallback)`: {:?}", diverging_vid);
                 }

compiler/rustc_span/src/symbol.rs

@@ -1239,6 +1239,7 @@ symbols! {
         no_main,
         no_mangle,
         no_never_type_fallback,
+        no_never_type_spontaneous_decay,
         no_sanitize,
         no_stack_check,
         no_start,

tests/ui/feature-gates/feature-gate-no-never-type-spontaneous-decay.rs

@@ -0,0 +1,10 @@
+fn main() {
+    // Because of the default never type fallback, this infers `?T = ?R = ()`, which makes this
+    // fail because of the `T: Error` bound. However, with
+    // `#![feature(no_never_type_spontaneous_decay)]` this would compile (it would infer
+    // `?T = ?R = !` and `!: Error` can be satisfied)
+    #[allow(unreachable_code)]
+    polymorphic_only_never(return); //~ error: the trait bound `(): std::error::Error` is not satisfied
+}
+
+fn polymorphic_only_never<T: std::error::Error>(_: T) {}

tests/ui/feature-gates/feature-gate-no-never-type-spontaneous-decay.stderr

@@ -0,0 +1,17 @@
+error[E0277]: the trait bound `(): std::error::Error` is not satisfied
+  --> $DIR/feature-gate-no-never-type-spontaneous-decay.rs:7:28
+   |
+LL |     polymorphic_only_never(return);
+   |     ---------------------- ^^^^^^ the trait `std::error::Error` is not implemented for `()`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `polymorphic_only_never`
+  --> $DIR/feature-gate-no-never-type-spontaneous-decay.rs:10:30
+   |
+LL | fn polymorphic_only_never<T: std::error::Error>(_: T) {}
+   |                              ^^^^^^^^^^^^^^^^^ required by this bound in `polymorphic_only_never`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.