Auto merge of #161905 - JonathanBrouwer:rollup-HgmRlVv, r=<try>

Rollup of 21 pull requests


try-job: dist-various-1
try-job: test-various
try-job: x86_64-gnu-aux
try-job: x86_64-gnu-llvm-21-3
try-job: x86_64-msvc-1
try-job: aarch64-apple-1
try-job: aarch64-apple-2
try-job: x86_64-mingw-1
try-job: i686-msvc-1
try-job: i686-msvc-2

Author: bors

compiler/rustc_attr_ir/src/data_structures.rs

@@ -70,42 +70,6 @@ pub enum CguFields {
     ExpectedCguReuse { cfg: Symbol, module: Symbol, kind: CguKind },
 }
 
-#[derive(Copy, Clone, PartialEq, Debug, PrintAttribute)]
-#[derive(StableHash, Encodable, Decodable)]
-pub enum DivergingFallbackBehavior {
-    /// Always fallback to `()` (aka "always spontaneous decay")
-    ToUnit,
-    /// Always fallback to `!` (which should be equivalent to never falling back + not making
-    /// never-to-any coercions unless necessary)
-    ToNever,
-    /// Don't fallback at all
-    NoFallback,
-}
-
-#[derive(Copy, Clone, PartialEq, Debug, PrintAttribute, Default)]
-#[derive(StableHash, Encodable, Decodable)]
-pub enum DivergingBlockBehavior {
-    /// This is the current stable behavior:
-    ///
-    /// ```rust
-    /// {
-    ///     return;
-    /// } // block has type = !, even though we are supposedly dropping it with `;`
-    /// ```
-    #[default]
-    Never,
-
-    /// Alternative behavior:
-    ///
-    /// ```ignore (very-unstable-new-attribute)
-    /// #![rustc_never_type_options(diverging_block_default = "unit")]
-    /// {
-    ///     return;
-    /// } // block has type = (), since we are dropping `!` from `return` with `;`
-    /// ```
-    Unit,
-}
-
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, StableHash, PrintAttribute)]
 pub enum InlineAttr {
     None,
@@ -1367,12 +1331,6 @@ pub enum AttributeKind {
     /// Represents `#[rustc_never_returns_null_ptr]`
     RustcNeverReturnsNullPtr,
 
-    /// Represents `#[rustc_never_type_options]`.
-    RustcNeverTypeOptions {
-        fallback: Option<DivergingFallbackBehavior>,
-        diverging_block_default: Option<DivergingBlockBehavior>,
-    },
-
     /// Represents `#[rustc_no_implicit_autorefs]`
     RustcNoImplicitAutorefs,
 

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -165,7 +165,6 @@ impl AttributeKind {
             RustcMustImplementOneOf { .. } => No,
             RustcMustMatchExhaustively(..) => Yes,
             RustcNeverReturnsNullPtr => Yes,
-            RustcNeverTypeOptions { .. } => No,
             RustcNoImplicitAutorefs => Yes,
             RustcNoImplicitBounds => No,
             RustcNoMirInline => Yes,

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -4,8 +4,8 @@ use rustc_ast::{LitIntType, LitKind, MetaItemLit};
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_attr_ir::target::GenericParamKind;
 use rustc_attr_ir::{
-    BorrowckGraphvizFormatKind, CguFields, CguKind, DivergingBlockBehavior,
-    DivergingFallbackBehavior, RustcCleanAttribute, RustcCleanQueries, RustcMirKind,
+    BorrowckGraphvizFormatKind, CguFields, CguKind, RustcCleanAttribute, RustcCleanQueries,
+    RustcMirKind,
 };
 use rustc_data_structures::fx::FxHashMap;
 use rustc_feature::AttributeStability;
@@ -397,79 +397,6 @@ impl NoArgsAttributeParser for RustcCaptureAnalysisParser {
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcCaptureAnalysis;
 }
 
-pub(crate) struct RustcNeverTypeOptionsParser;
-
-impl SingleAttributeParser for RustcNeverTypeOptionsParser {
-    const PATH: &[Symbol] = &[sym::rustc_never_type_options];
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
-    const TEMPLATE: AttributeTemplate = template!(List: &[
-        r#"fallback = "unit", "never", "no""#,
-        r#"diverging_block_default = "unit", "never""#,
-    ]);
-    const STABILITY: AttributeStability = unstable!(
-        rustc_attrs,
-        "`rustc_never_type_options` is used to experiment with never type fallback and work on never type stabilization"
-    );
-
-    fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
-        let list = cx.expect_list(args, cx.attr_span)?;
-
-        let mut fallback = None::<Ident>;
-        let mut diverging_block_default = None::<Ident>;
-
-        for arg in list.mixed() {
-            let Some((ident, arg)) = cx.expect_name_value(arg, arg.span(), None) else {
-                continue;
-            };
-
-            let res = match ident.name {
-                sym::fallback => &mut fallback,
-                sym::diverging_block_default => &mut diverging_block_default,
-                _ => {
-                    cx.adcx().expected_specific_argument(
-                        ident.span,
-                        &[sym::fallback, sym::diverging_block_default],
-                    );
-                    continue;
-                }
-            };
-
-            let field = cx.expect_string_literal(arg)?;
-
-            if res.is_some() {
-                cx.adcx().duplicate_key(ident.span, ident.name);
-                continue;
-            }
-
-            *res = Some(Ident { name: field, span: arg.value_span });
-        }
-
-        let fallback = match fallback {
-            None => None,
-            Some(Ident { name: sym::unit, .. }) => Some(DivergingFallbackBehavior::ToUnit),
-            Some(Ident { name: sym::never, .. }) => Some(DivergingFallbackBehavior::ToNever),
-            Some(Ident { name: sym::no, .. }) => Some(DivergingFallbackBehavior::NoFallback),
-            Some(Ident { span, .. }) => {
-                cx.adcx()
-                    .expected_specific_argument_strings(span, &[sym::unit, sym::never, sym::no]);
-                return None;
-            }
-        };
-
-        let diverging_block_default = match diverging_block_default {
-            None => None,
-            Some(Ident { name: sym::unit, .. }) => Some(DivergingBlockBehavior::Unit),
-            Some(Ident { name: sym::never, .. }) => Some(DivergingBlockBehavior::Never),
-            Some(Ident { span, .. }) => {
-                cx.adcx().expected_specific_argument_strings(span, &[sym::unit, sym::no]);
-                return None;
-            }
-        };
-
-        Some(AttributeKind::RustcNeverTypeOptions { fallback, diverging_block_default })
-    }
-}
-
 pub(crate) struct RustcTrivialFieldReadsParser;
 
 impl NoArgsAttributeParser for RustcTrivialFieldReadsParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -246,7 +246,6 @@ attribute_parsers!(
         Single<RustcLintOptDenyFieldAccessParser>,
         Single<RustcMacroTransparencyParser>,
         Single<RustcMustImplementOneOfParser>,
-        Single<RustcNeverTypeOptionsParser>,
         Single<RustcObjcClassParser>,
         Single<RustcObjcSelectorParser>,
         Single<RustcScalableVectorParser>,