Auto merge of rust-lang#161906 - JonathanBrouwer:rollup-obMe707, r=JonathanBrouwer

Rollup of 21 pull requests

Successful merges:

 - rust-lang#150075 (Implement clamp_to)
 - rust-lang#159103 (fix(reborrow): recursive implementation)
 - rust-lang#160562 (add target feature ABI checks for SPARC)
 - rust-lang#160848 (std: avoid aliasing violations when wrapping opaque C types)
 - rust-lang#161421 (Include startup crt objects on WASI for more outputs)
 - rust-lang#161805 (Prefer ambiguous candidates when deduplicating traits in scope, so `ambiguous_glob_imported_traits` doesn't depend on import order)
 - rust-lang#161862 (Put data segment in specified section with link_section on wasm)
 - rust-lang#161866 (delegation: add tests fixating behavior of delegating to default trait implementations)
 - rust-lang#157218 (Track items behind `cfg_select` in the same way we do for `cfg`)
 - rust-lang#161456 (reduce perf impact of scalar size checks)
 - rust-lang#161528 (Add regression test to ensure optimal compilation)
 - rust-lang#161666 (Print vendor instructions in `x vendor`)
 - rust-lang#161730 (Improve type mismatch annotation for lets with block-wrapped initializers)
 - rust-lang#161828 (Never type after-stabilization cleanup)
 - rust-lang#161859 (Do not optimize MIR for comptime ConstFns)
 - rust-lang#161860 (atomicptr.rs test: remove unused import)
 - rust-lang#161870 (bind to [::1] instead of 127.0.0.1 in documentation examples for v6 UDP methods)
 - rust-lang#161876 (rustdoc: Correctly handle when a macro generates multiple items in `--generate-macro-expansion`)
 - rust-lang#161889 (Add link to ownership section in ptr::read docs)
 - rust-lang#161890 (rustdoc: some clarifying comments)
 - rust-lang#161891 (Mark `extern_item_impls` feature as incomplete)

Failed merges:

 - rust-lang#161702 (Use `drop_guard` in some places in {core,alloc,std})

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/cfg_select.rs

@@ -47,25 +47,28 @@ pub struct CfgSelectBranches {
 impl CfgSelectBranches {
     /// Removes the top-most branch for which `predicate` returns `true`,
     /// or the wildcard if none of the reachable branches satisfied the predicate.
-    pub fn pop_first_match<F>(&mut self, predicate: F) -> Option<(TokenStream, Span)>
+    pub fn pop_first_match<F>(&mut self, predicate: F) -> Option<(CfgEntry, TokenStream, Span)>
     where
         F: Fn(&CfgEntry) -> bool,
     {
         for (index, (cfg, _, _)) in self.reachable.iter().enumerate() {
             if predicate(cfg) {
-                let matched = self.reachable.remove(index);
-                return Some((matched.1, matched.2));
+                return Some(self.reachable.remove(index));
             }
         }
 
-        self.wildcard.take().map(|(_, tts, span)| (tts, span))
+        self.wildcard.take().map(|(_, tts, span)| (CfgEntry::Bool(true, span), tts, span))
     }
 
     /// Consume this value and iterate over all the `TokenStream`s that it stores.
-    pub fn into_iter_tts(self) -> impl Iterator<Item = (TokenStream, Span)> {
-        let it1 = self.reachable.into_iter().map(|(_, tts, span)| (tts, span));
-        let it2 = self.wildcard.into_iter().map(|(_, tts, span)| (tts, span));
-        let it3 = self.unreachable.into_iter().map(|(_, tts, span)| (tts, span));
+    pub fn into_iter_tts(self) -> impl Iterator<Item = (CfgEntry, TokenStream, Span)> {
+        let it1 = self.reachable.into_iter();
+        let it2 =
+            self.wildcard.into_iter().map(|(_, tts, span)| (CfgEntry::Bool(true, span), tts, span));
+        let it3 = self
+            .unreachable
+            .into_iter()
+            .map(|(_, tts, span)| (CfgEntry::Bool(false, span), tts, span));
 
         it1.chain(it2).chain(it3)
     }

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>,