Auto merge of #161875 - JonathanBrouwer:rollup-jDGOOBv, r=<try>

Rollup of 11 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>,

compiler/rustc_codegen_llvm/src/consts.rs

@@ -544,8 +544,9 @@ impl<'ll> CodegenCx<'ll, '_> {
         }
 
         // Wasm statics with custom link sections get special treatment as they
-        // go into custom sections of the wasm executable. The exception to this
-        // is the `.init_array` section which are treated specially by the wasm linker.
+        // also go into custom sections of the wasm executable. The exception to
+        // this is the `.init_array` section for which we can't emit a custom
+        // section as it contains relocations.
         if self.tcx.sess.target.is_like_wasm
             && attrs
                 .link_section
@@ -564,10 +565,9 @@ impl<'ll> CodegenCx<'ll, '_> {
                 let data = [section, alloc];
                 self.module_add_named_metadata_node(self.llmod(), c"wasm.custom_sections", &data);
             }
-        } else {
-            base::set_link_section(g, attrs);
         }
 
+        base::set_link_section(g, attrs);
         base::set_variable_sanitizer_attrs(g, attrs);
 
         if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER) {

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -153,6 +153,8 @@ fn visit_implementation_of_unpin(checker: &Checker<'_>) -> Result<(), ErrorGuara
                 }));
             }
             ty::Adt(_, _) => {}
+            // `extern type`s have no fields, so they can't be structurally pinned.
+            ty::Foreign(_) => {}
             _ => {
                 return Err(tcx.dcx().span_delayed_bug(span, "impl of `Unpin` for a non-adt type"));
             }

compiler/rustc_hir_typeck/src/demand.rs

@@ -711,9 +711,31 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expr: &hir::Expr<'_>,
         error: Option<TypeError<'tcx>>,
     ) {
-        match (self.tcx.parent_hir_node(expr.hir_id), error) {
+        // Skip nested block to find the correct parent node to point at.
+        let mut current_hir_id = expr.hir_id;
+        let parent = self
+            .tcx
+            .hir_parent_iter(expr.hir_id)
+            .find_map(|(parent_hir_id, parent)| match parent {
+                hir::Node::Block(block)
+                    if block.expr.is_some_and(|expr| expr.hir_id == current_hir_id) =>
+                {
+                    current_hir_id = parent_hir_id;
+                    None
+                }
+                hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Block(block, _), .. })
+                    if block.hir_id == current_hir_id =>
+                {
+                    current_hir_id = parent_hir_id;
+                    None
+                }
+                parent => Some(parent),
+            })
+            .expect("an expression must have a non-block ancestor");
+
+        match (parent, error) {
             (hir::Node::LetStmt(hir::LetStmt { ty: Some(ty), init: Some(init), .. }), _)
-                if init.hir_id == expr.hir_id && !ty.span.source_equal(init.span) =>
+                if init.hir_id == current_hir_id && !ty.span.source_equal(init.span) =>
             {
                 // Point at `let` assignment type.
                 err.span_label(ty.span, "expected due to this");