[experiment] meow

compiler/rustc_arena/src/lib.rs

@@ -10,12 +10,12 @@
 // tidy-alphabetical-start
 #![allow(clippy::mut_from_ref)] // Arena allocators are one place where this pattern is fine.
 #![allow(internal_features)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![doc(test(no_crate_inject, attr(deny(warnings), allow(internal_features))))]
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
-#![feature(never_type)]
 #![feature(rustc_attrs)]
 #![feature(unwrap_infallible)]
 // tidy-alphabetical-end

compiler/rustc_ast_ir/src/lib.rs

@@ -6,8 +6,8 @@
 //! `rustc_type_ir` for a single import.
 
 // tidy-alphabetical-start
+#![cfg_attr(all(feature = "nightly", bootstrap), feature(never_type))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
-#![cfg_attr(feature = "nightly", feature(never_type))]
 #![cfg_attr(feature = "nightly", feature(rustc_attrs))]
 // tidy-alphabetical-end
 

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -288,9 +288,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 // Function pointers cannot be `const`
                 self.check_late_bound_lifetime_defs(&fn_ptr_ty.generic_params);
             }
-            ast::TyKind::Never => {
-                gate!(self, never_type, ty.span, "the `!` type is experimental");
-            }
             ast::TyKind::Pat(..) => {
                 gate!(self, pattern_types, ty.span, "pattern types are unstable");
             }
@@ -318,15 +315,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
     }
 
     fn visit_generic_args(&mut self, args: &'a ast::GenericArgs) {
-        // This check needs to happen here because the never type can be returned from a function,
-        // but cannot be used in any other context. If this check was in `visit_fn_ret_ty`, it
-        // include both functions and generics like `impl Fn() -> !`.
-        if let ast::GenericArgs::Parenthesized(generic_args) = args
-            && let ast::FnRetTy::Ty(ref ty) = generic_args.output
-            && matches!(ty.kind, ast::TyKind::Never)
-        {
-            gate!(self, never_type, ty.span, "the `!` type is experimental");
-        }
         visit::walk_generic_args(self, args);
     }
 

compiler/rustc_borrowck/src/lib.rs

@@ -2,11 +2,11 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(box_patterns)]
 #![feature(default_field_values)]
 #![feature(file_buffered)]
 #![feature(negative_impls)]
-#![feature(never_type)]
 #![feature(rustc_attrs)]
 #![feature(stmt_expr_attributes)]
 #![feature(try_blocks)]

compiler/rustc_const_eval/src/lib.rs

@@ -1,8 +1,8 @@
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(array_try_map)]
 #![feature(box_patterns)]
 #![feature(decl_macro)]
-#![feature(never_type)]
 #![feature(slice_ptr_get)]
 #![feature(trait_alias)]
 #![feature(unqualified_local_imports)]

compiler/rustc_data_structures/src/lib.rs

@@ -10,6 +10,7 @@
 #![allow(internal_features)]
 #![allow(rustc::default_hash_types)]
 #![allow(rustc::potential_query_instability)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![feature(allocator_api)]
@@ -24,7 +25,6 @@
 #![feature(map_try_insert)]
 #![feature(min_specialization)]
 #![feature(negative_impls)]
-#![feature(never_type)]
 #![feature(pattern_type_macro)]
 #![feature(pattern_types)]
 #![feature(ptr_alignment_type)]

compiler/rustc_error_codes/src/error_codes/E0725.md

@@ -4,8 +4,9 @@ command line flags.
 Erroneous code example:
 
 ```ignore (can't specify compiler flags from doctests)
-#![feature(never_type)] // error: the feature `never_type` is not in
-                        // the list of allowed features
+#![feature(extern_item_impls)]
+//~^ error: the feature `extern_item_impls`
+//          is not in the list of allowed features
 ```
 
 Delete the offending feature attribute, or add it to the list of allowed

compiler/rustc_errors/src/lib.rs

@@ -5,11 +5,11 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(associated_type_defaults)]
 #![feature(default_field_values)]
 #![feature(macro_metavar_expr_concat)]
 #![feature(negative_impls)]
-#![feature(never_type)]
 #![feature(rustc_attrs)]
 // tidy-alphabetical-end
 

compiler/rustc_feature/src/accepted.rs

@@ -326,6 +326,8 @@ declare_features! (
     (accepted, native_link_modifiers_verbatim, "1.67.0", Some(81490)),
     /// Allows specifying the whole-archive link modifier
     (accepted, native_link_modifiers_whole_archive, "1.61.0", Some(81490)),
+    /// Allows the `!` type.
+    (accepted, never_type, "CURRENT_RUSTC_VERSION", Some(35121)),
     /// Allows using non lexical lifetimes (RFC 2094).
     (accepted, nll, "1.63.0", Some(43234)),
     /// Allows using `#![no_std]`.

compiler/rustc_feature/src/unstable.rs

@@ -612,8 +612,6 @@ declare_features! (
     (unstable, negative_impls, "1.44.0", Some(68318)),
     /// Allows the `!` pattern.
     (incomplete, never_patterns, "1.76.0", Some(118155)),
-    /// Allows the `!` type. Does not imply 'exhaustive_patterns' (below) any more.
-    (unstable, never_type, "1.13.0", Some(35121)),
     /// Switch `..` syntax to use the new (`Copy + IntoIterator`) range types.
     (unstable, new_range, "1.86.0", Some(123741)),
     /// Allows `#![no_core]`.

compiler/rustc_hir/src/lib.rs

@@ -3,13 +3,13 @@
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
 
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(associated_type_defaults)]
 #![feature(closure_track_caller)]
 #![feature(const_default)]
 #![feature(const_trait_impl)]
 #![feature(derive_const)]
 #![feature(exhaustive_patterns)]
-#![feature(never_type)]
 #![feature(variant_count)]
 #![recursion_limit = "256"]
 // tidy-alphabetical-end

compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs

@@ -263,9 +263,7 @@ pub(super) fn find_opaque_ty_constraints_for_rpit<'tcx>(
                 // resolves to itself. We interpret this as the
                 // no values of the hidden type ever being constructed,
                 // so we can just make the hidden type be `!`.
-                // For backwards compatibility reasons, we fall back to
-                // `()` until we the diverging default is changed.
-                EarlyBinder::bind(tcx.types.unit)
+                EarlyBinder::bind(tcx.types.never)
             }
         }
         DefiningScopeKind::MirBorrowck => match tcx.mir_borrowck(owner_def_id) {

compiler/rustc_hir_analysis/src/lib.rs

@@ -56,10 +56,10 @@ This API is completely unstable and subject to change.
 */
 
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(default_field_values)]
 #![feature(gen_blocks)]
 #![feature(iter_intersperse)]
-#![feature(never_type)]
 #![feature(slice_partition_dedup)]
 #![feature(try_blocks)]
 #![feature(unwrap_infallible)]

compiler/rustc_hir_typeck/src/errors.rs

@@ -12,7 +12,7 @@ use rustc_errors::{
 use rustc_hir as hir;
 use rustc_hir::ExprKind;
 use rustc_macros::{Diagnostic, Subdiagnostic};
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::Ty;
 use rustc_span::edition::{Edition, LATEST_STABLE_EDITION};
 use rustc_span::{Ident, Span, Spanned, Symbol};
 
@@ -248,17 +248,6 @@ pub(crate) enum NeverTypeFallbackFlowingIntoUnsafe {
     },
 }
 
-#[derive(Diagnostic)]
-#[help("specify the types explicitly")]
-#[diag("this function depends on never type fallback being `()`")]
-pub(crate) struct DependencyOnUnitNeverTypeFallback<'tcx> {
-    #[note("in edition 2024, the requirement `{$obligation}` will fail")]
-    pub obligation_span: Span,
-    pub obligation: ty::Predicate<'tcx>,
-    #[subdiagnostic]
-    pub sugg: SuggestAnnotations,
-}
-
 #[derive(Clone)]
 pub(crate) enum SuggestAnnotation {
     Unit(Span),

compiler/rustc_hir_typeck/src/fallback.rs

@@ -15,7 +15,6 @@ use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable};
 use rustc_session::lint;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{DUMMY_SP, Span};
-use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};
 use tracing::debug;
 
 use crate::{FnCtxt, errors};
@@ -197,11 +196,6 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         let mut diverging_fallback = UnordSet::with_capacity(diverging_vids.len());
         let unsafe_infer_vars = OnceCell::new();
 
-        self.lint_obligations_broken_by_never_type_fallback_change(
-            &diverging_vids,
-            &coercion_graph,
-        );
-
         for &diverging_vid in &diverging_vids {
             let diverging_ty = Ty::new_var(self.tcx, diverging_vid);
             let root_vid = self.root_var(diverging_vid);
@@ -265,58 +259,6 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
         }
     }
 
-    fn lint_obligations_broken_by_never_type_fallback_change(
-        &self,
-        diverging_vids: &[ty::TyVid],
-        coercions: &VecGraph<ty::TyVid, true>,
-    ) {
-        let DivergingFallbackBehavior::ToUnit = self.diverging_fallback_behavior else { return };
-
-        // Fallback happens if and only if there are diverging variables
-        if diverging_vids.is_empty() {
-            return;
-        }
-
-        // Returns errors which happen if fallback is set to `fallback`
-        let remaining_errors_if_fallback_to = |fallback| {
-            self.probe(|_| {
-                let obligations = self.fulfillment_cx.borrow().pending_obligations();
-                let ocx = ObligationCtxt::new_with_diagnostics(&self.infcx);
-                ocx.register_obligations(obligations.iter().cloned());
-
-                for &diverging_vid in diverging_vids {
-                    let diverging_ty = Ty::new_var(self.tcx, diverging_vid);
-
-                    ocx.eq(&ObligationCause::dummy(), self.param_env, diverging_ty, fallback)
-                        .expect("expected diverging var to be unconstrained");
-                }
-
-                ocx.try_evaluate_obligations()
-            })
-        };
-
-        // If we have no errors with `fallback = ()`, but *do* have errors with `fallback = !`,
-        // then this code will be broken by the never type fallback change.
-        let unit_errors = remaining_errors_if_fallback_to(self.tcx.types.unit);
-        if unit_errors.is_empty()
-            && let mut never_errors = remaining_errors_if_fallback_to(self.tcx.types.never)
-            && let [never_error, ..] = never_errors.as_mut_slice()
-        {
-            self.adjust_fulfillment_error_for_expr_obligation(never_error);
-            let sugg = self.try_to_suggest_annotations(diverging_vids, coercions);
-            self.tcx.emit_node_span_lint(
-                lint::builtin::DEPENDENCY_ON_UNIT_NEVER_TYPE_FALLBACK,
-                self.tcx.local_def_id_to_hir_id(self.body_id),
-                self.tcx.def_span(self.body_id),
-                errors::DependencyOnUnitNeverTypeFallback {
-                    obligation_span: never_error.obligation.cause.span,
-                    obligation: never_error.obligation.predicate,
-                    sugg,
-                },
-            )
-        }
-    }
-
     /// Returns a graph whose nodes are (unresolved) inference variables and where
     /// an edge `?A -> ?B` indicates that the variable `?A` is coerced to `?B`.
     fn create_coercion_graph(&self) -> VecGraph<ty::TyVid, true> {

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -491,24 +491,14 @@ impl<'tcx> LoweredTy<'tcx> {
 }
 
 fn never_type_behavior(tcx: TyCtxt<'_>) -> (DivergingFallbackBehavior, DivergingBlockBehavior) {
+    // FIXME(waffle): rip out the whole system which allows you to choose never type fallback
     let (fallback, block) = parse_never_type_options_attr(tcx);
-    let fallback = fallback.unwrap_or_else(|| default_fallback(tcx));
+    let fallback = fallback.unwrap_or_else(|| DivergingFallbackBehavior::ToNever);
     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;
-    }
-
-    // Otherwise: fallback to `()`
-    DivergingFallbackBehavior::ToUnit
-}
-
 fn parse_never_type_options_attr(
     tcx: TyCtxt<'_>,
 ) -> (Option<DivergingFallbackBehavior>, Option<DivergingBlockBehavior>) {

compiler/rustc_hir_typeck/src/lib.rs

@@ -1,8 +1,8 @@
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(box_patterns)]
 #![feature(iter_intersperse)]
 #![feature(iter_order_by)]
-#![feature(never_type)]
 #![feature(trim_prefix_suffix)]
 // tidy-alphabetical-end
 

compiler/rustc_lint/src/lib.rs

@@ -645,6 +645,10 @@ fn register_builtins(store: &mut LintStore) {
     );
     store.register_removed("wasm_c_abi", "the wasm C ABI has been fixed");
     store.register_removed("soft_unstable", "the general soft-unstable mechanism has been removed");
+    store.register_removed(
+        "dependency_on_unit_never_type_fallback",
+        "the code warned by this lint no longer compiles",
+    );
 }
 
 fn register_internals(store: &mut LintStore) {

compiler/rustc_lint_defs/src/builtin.rs

@@ -34,7 +34,6 @@ declare_lint_pass! {
         CONST_EVALUATABLE_UNCHECKED,
         CONST_ITEM_MUTATION,
         DEAD_CODE,
-        DEPENDENCY_ON_UNIT_NEVER_TYPE_FALLBACK,
         DEPRECATED,
         DEPRECATED_IN_FUTURE,
         DEPRECATED_SAFE_2024,
@@ -4222,59 +4221,6 @@ declare_lint! {
     report_in_external_macro
 }
 
-declare_lint! {
-    /// The `dependency_on_unit_never_type_fallback` lint detects cases where code compiles with
-    /// [never type fallback] being [`()`], but will stop compiling with fallback being [`!`].
-    ///
-    /// [never type fallback]: https://doc.rust-lang.org/nightly/core/primitive.never.html#never-type-fallback
-    /// [`!`]: https://doc.rust-lang.org/core/primitive.never.html
-    /// [`()`]: https://doc.rust-lang.org/core/primitive.unit.html
-    ///
-    /// ### Example
-    ///
-    /// ```rust,compile_fail,edition2021
-    /// # #![deny(dependency_on_unit_never_type_fallback)]
-    /// fn main() {
-    ///     if true {
-    ///         // return has type `!` which, is some cases, causes never type fallback
-    ///         return
-    ///     } else {
-    ///         // the type produced by this call is not specified explicitly,
-    ///         // so it will be inferred from the previous branch
-    ///         Default::default()
-    ///     };
-    ///     // depending on the fallback, this may compile (because `()` implements `Default`),
-    ///     // or it may not (because `!` does not implement `Default`)
-    /// }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// Due to historic reasons never type fallback was `()`, meaning that `!` got spontaneously
-    /// coerced to `()`. There are plans to change that, but they may make the code such as above
-    /// not compile. Instead of depending on the fallback, you should specify the type explicitly:
-    /// ```
-    /// if true {
-    ///     return
-    /// } else {
-    ///     // type is explicitly specified, fallback can't hurt us no more
-    ///     <() as Default>::default()
-    /// };
-    /// ```
-    ///
-    /// See [Tracking Issue for making `!` fall back to `!`](https://github.com/rust-lang/rust/issues/123748).
-    pub DEPENDENCY_ON_UNIT_NEVER_TYPE_FALLBACK,
-    Deny,
-    "never type fallback affecting unsafe function calls",
-    @future_incompatible = FutureIncompatibleInfo {
-        reason: fcw!(EditionAndFutureReleaseError 2024 "never-type-fallback"),
-        report_in_deps: true,
-    };
-    report_in_external_macro
-}
-
 declare_lint! {
     /// The `invalid_macro_export_arguments` lint detects cases where `#[macro_export]` is being used with invalid arguments.
     ///

compiler/rustc_macros/src/lib.rs

@@ -1,6 +1,6 @@
 // tidy-alphabetical-start
 #![allow(rustc::default_hash_types)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(proc_macro_diagnostic)]
 #![feature(proc_macro_tracked_env)]
 // tidy-alphabetical-end