Rollup of 14 pull requests

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -403,6 +403,18 @@ pub(crate) struct InvalidTarget {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum InvalidTargetHelp {
+    #[multipart_suggestion(
+        "did you mean to use `#[export_name]`?",
+        applicability = "maybe-incorrect"
+    )]
+    UseExportName {
+        #[suggestion_part(code = "unsafe(")]
+        unsafe_open: Option<Span>,
+        #[suggestion_part(code = "export_name")]
+        name: Span,
+        #[suggestion_part(code = ")")]
+        unsafe_close: Option<Span>,
+    },
     #[help("use `#[rustc_align(...)]` instead")]
     UseRustcAlign,
     #[help("use `#[rustc_align_static(...)]` instead")]

compiler/rustc_attr_parsing/src/target_checking.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use rustc_ast::AttrStyle;
+use rustc_ast::{AttrStyle, Safety};
 use rustc_errors::{DiagArgValue, MultiSpan, StashKey};
 use rustc_feature::Features;
 use rustc_hir::attrs::AttributeKind;
@@ -187,6 +187,15 @@ impl<'sess> AttributeParser<'sess> {
         cx: &AcceptContext<'_, '_>,
     ) -> Option<InvalidTargetHelp> {
         match &*cx.attr_path.segments {
+            [sym::link_name] if cx.target == Target::Static => {
+                let needs_unsafe_wrapper = matches!(cx.attr_safety, Safety::Default);
+
+                Some(InvalidTargetHelp::UseExportName {
+                    unsafe_open: needs_unsafe_wrapper.then(|| cx.inner_span.shrink_to_lo()),
+                    name: cx.attr_path.span,
+                    unsafe_close: needs_unsafe_wrapper.then(|| cx.inner_span.shrink_to_hi()),
+                })
+            }
             [sym::repr] if attribute_args == "(align(...))" => match cx.target {
                 Target::Fn | Target::Method(..) if cx.features().fn_align() => {
                     Some(InvalidTargetHelp::UseRustcAlign)

compiler/rustc_borrowck/src/borrow_set.rs

@@ -217,7 +217,7 @@ impl LocalsStateAtExit {
                 HasStorageDead(DenseBitSet::new_empty(body.local_decls.len()));
             has_storage_dead.visit_body(body);
             let mut has_storage_dead_or_moved = has_storage_dead.0;
-            for move_out in &move_data.moves {
+            for move_out in &move_data.move_outs {
                 has_storage_dead_or_moved.insert(move_data.base_local(move_out.path));
             }
             LocalsStateAtExit::SomeAreInvalidated { has_storage_dead_or_moved }

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -129,7 +129,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
             }
 
             let is_partial_move = move_site_vec.iter().any(|move_site| {
-                let move_out = self.move_data.moves[(*move_site).moi];
+                let move_out = self.move_data.move_outs[(*move_site).moi];
                 let moved_place = &self.move_data.move_paths[move_out.path].place;
                 // `*(_1)` where `_1` is a `Box` is actually a move out.
                 let is_box_move = moved_place.as_ref().projection == [ProjectionElem::Deref]
@@ -215,7 +215,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
             let mut seen_spans = FxIndexSet::default();
 
             for move_site in &move_site_vec {
-                let move_out = self.move_data.moves[(*move_site).moi];
+                let move_out = self.move_data.move_outs[(*move_site).moi];
                 let moved_place = &self.move_data.move_paths[move_out.path].place;
 
                 let move_spans = self.move_spans(moved_place.as_ref(), move_out.source);
@@ -281,7 +281,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
                 _ => true,
             };
 
-            let mpi = self.move_data.moves[move_out_indices[0]].path;
+            let mpi = self.move_data.move_outs[move_out_indices[0]].path;
             let place = &self.move_data.move_paths[mpi].place;
             let ty = place.ty(self.body, self.infcx.tcx).ty;
 
@@ -3855,9 +3855,9 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
                 // worry about the other case: that is, if there is a move of a.b.c, it is already
                 // marked as a move of a.b and a as well, so we will generate the correct errors
                 // there.
-                for moi in &self.move_data.loc_map[location] {
+                for moi in &self.move_data.move_out_loc_map[location] {
                     debug!("report_use_of_moved_or_uninitialized: moi={:?}", moi);
-                    let path = self.move_data.moves[*moi].path;
+                    let path = self.move_data.move_outs[*moi].path;
                     if mpis.contains(&path) {
                         debug!(
                             "report_use_of_moved_or_uninitialized: found {:?}",

compiler/rustc_borrowck/src/lib.rs

@@ -2373,8 +2373,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 // of the union - we should error in that case.
                 let tcx = this.infcx.tcx;
                 if base.ty(this.body(), tcx).ty.is_union()
-                    && this.move_data.path_map[mpi].iter().any(|moi| {
-                        this.move_data.moves[*moi].source.is_predecessor_of(location, this.body)
+                    && this.move_data.move_out_path_map[mpi].iter().any(|moi| {
+                        this.move_data.move_outs[*moi].source.is_predecessor_of(location, this.body)
                     })
                 {
                     return;

compiler/rustc_borrowck/src/polonius/legacy/mod.rs

@@ -132,9 +132,9 @@ fn emit_move_facts(
 
     // moved_out_at
     // deinitialisation is assumed to always happen!
-    facts
-        .path_moved_at_base
-        .extend(move_data.moves.iter().map(|mo| (mo.path, location_table.mid_index(mo.source))));
+    facts.path_moved_at_base.extend(
+        move_data.move_outs.iter().map(|mo| (mo.path, location_table.mid_index(mo.source))),
+    );
 }
 
 /// Emit universal regions facts, and their relations.

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -5,14 +5,11 @@ use rustc_infer::infer::canonical::{QueryRegionConstraint, QueryRegionConstraint
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::outlives::obligations::{TypeOutlives, TypeOutlivesDelegate};
 use rustc_infer::infer::region_constraints::{GenericKind, VerifyBound};
-use rustc_infer::traits::query::type_op::Normalize;
-use rustc_middle::bug;
 use rustc_middle::ty::{
-    self, GenericArgKind, RegionExt, RegionUtilitiesExt, Ty, TyCtxt, TypeFoldable,
-    TypeVisitableExt, elaborate, fold_regions,
+    self, GenericArgKind, RegionExt, RegionUtilitiesExt, TyCtxt, TypeFoldable, TypeVisitableExt,
+    elaborate, fold_regions,
 };
 use rustc_span::Span;
-use rustc_trait_selection::traits::query::type_op::TypeOpOutput;
 use tracing::{debug, instrument};
 
 use crate::constraints::OutlivesConstraint;
@@ -137,83 +134,49 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 
         // Extract out various useful fields we'll need below.
         let ConstraintConversion {
-            infcx,
+            infcx: _,
             universal_regions,
             region_bound_pairs,
             known_type_outlives_obligations,
             ..
         } = *self;
 
-        let mut outlives_predicates = vec![(predicate, constraint_category)];
-        for iteration in 0.. {
-            if outlives_predicates.is_empty() {
-                break;
-            }
+        let pred = predicate;
+        // Constraint is implied by a coroutine's well-formedness.
+        if self.infcx.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
+            && higher_ranked_assumptions.contains(&pred)
+        {
+            return;
+        }
 
-            if !tcx.recursion_limit().value_within_limit(iteration) {
-                // This may actually be reachable. If so, we should convert
-                // this to a proper error/consider whether we should detect
-                // this somewhere else.
-                bug!(
-                    "unexpected overflowed when processing region obligations: {outlives_predicates:#?}"
-                );
+        let ty::OutlivesPredicate(k1, r2) = pred;
+        match k1.kind() {
+            GenericArgKind::Lifetime(r1) => {
+                let r1_vid = self.to_region_vid(r1);
+                let r2_vid = self.to_region_vid(r2);
+                self.add_outlives(r1_vid, r2_vid, constraint_category);
             }
 
-            let mut next_outlives_predicates = vec![];
-            for (pred, constraint_category) in outlives_predicates {
-                // Constraint is implied by a coroutine's well-formedness.
-                if self.infcx.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
-                    && higher_ranked_assumptions.contains(&pred)
-                {
-                    continue;
-                }
-
-                let ty::OutlivesPredicate(k1, r2) = pred;
-                match k1.kind() {
-                    GenericArgKind::Lifetime(r1) => {
-                        let r1_vid = self.to_region_vid(r1);
-                        let r2_vid = self.to_region_vid(r2);
-                        self.add_outlives(r1_vid, r2_vid, constraint_category);
-                    }
-
-                    GenericArgKind::Type(mut t1) => {
-                        // Scraped constraints may have had inference vars.
-                        t1 = self.infcx.resolve_vars_if_possible(t1);
-
-                        // Normalize the type we receive from a `TypeOutlives` obligation
-                        // in the new trait solver.
-                        if infcx.next_trait_solver() {
-                            t1 = self.normalize_and_add_type_outlives_constraints(
-                                ty::Unnormalized::new_wip(t1),
-                                &mut next_outlives_predicates,
-                            );
-                        }
+            GenericArgKind::Type(mut t1) => {
+                // Scraped constraints may have had inference vars.
+                t1 = self.infcx.resolve_vars_if_possible(t1);
 
-                        let implicit_region_bound =
-                            ty::Region::new_var(tcx, universal_regions.implicit_region_bound());
-                        // we don't actually use this for anything, but
-                        // the `TypeOutlives` code needs an origin.
-                        let origin = SubregionOrigin::RelateParamBound(self.span, t1, None);
-                        TypeOutlives::new(
-                            &mut *self,
-                            tcx,
-                            region_bound_pairs,
-                            Some(implicit_region_bound),
-                            known_type_outlives_obligations,
-                        )
-                        .type_must_outlive(
-                            origin,
-                            t1,
-                            r2,
-                            constraint_category,
-                        );
-                    }
-
-                    GenericArgKind::Const(_) => unreachable!(),
-                }
+                let implicit_region_bound =
+                    ty::Region::new_var(tcx, universal_regions.implicit_region_bound());
+                // we don't actually use this for anything, but
+                // the `TypeOutlives` code needs an origin.
+                let origin = SubregionOrigin::RelateParamBound(self.span, t1, None);
+                TypeOutlives::new(
+                    &mut *self,
+                    tcx,
+                    region_bound_pairs,
+                    Some(implicit_region_bound),
+                    known_type_outlives_obligations,
+                )
+                .type_must_outlive(origin, t1, r2, constraint_category);
             }
 
-            outlives_predicates = next_outlives_predicates;
+            GenericArgKind::Const(_) => unreachable!(),
         }
     }
 
@@ -279,32 +242,6 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         debug!("add_type_test(type_test={:?})", type_test);
         self.constraints.type_tests.push(type_test);
     }
-
-    // FIXME(trait-refactor-initiative#260): This function should be
-    // removed.
-    fn normalize_and_add_type_outlives_constraints(
-        &self,
-        ty: ty::Unnormalized<'tcx, Ty<'tcx>>,
-        next_outlives_predicates: &mut Vec<(
-            ty::ArgOutlivesPredicate<'tcx>,
-            ConstraintCategory<'tcx>,
-        )>,
-    ) -> Ty<'tcx> {
-        match self.infcx.fully_perform(Normalize { value: ty }, self.span) {
-            Ok(TypeOpOutput { output: ty, constraints, .. }) => {
-                // FIXME(higher_ranked_auto): What should we do with the assumptions here?
-                if let Some(QueryRegionConstraints { constraints, assumptions: _ }) = constraints {
-                    next_outlives_predicates.extend(constraints.iter().flat_map(
-                        |QueryRegionConstraint { constraint, category, .. }| {
-                            constraint.iter_outlives().map(|outlives| (outlives, *category))
-                        },
-                    ));
-                }
-                ty
-            }
-            Err(_) => ty.skip_norm_wip(),
-        }
-    }
 }
 
 impl<'a, 'b, 'tcx> TypeOutlivesDelegate<'tcx> for &'a mut ConstraintConversion<'b, 'tcx> {

compiler/rustc_borrowck/src/used_muts.rs

@@ -93,8 +93,8 @@ impl<'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'_, '_, '_, 'tcx> {
     fn visit_local(&mut self, local: Local, place_context: PlaceContext, location: Location) {
         if place_context.is_place_assignment() && self.temporary_used_locals.contains(&local) {
             // Propagate the Local assigned at this Location as a used mutable local variable
-            for moi in &self.mbcx.move_data.loc_map[location] {
-                let mpi = &self.mbcx.move_data.moves[*moi].path;
+            for moi in &self.mbcx.move_data.move_out_loc_map[location] {
+                let mpi = &self.mbcx.move_data.move_outs[*moi].path;
                 let path = &self.mbcx.move_data.move_paths[*mpi];
                 debug!(
                     "assignment of {:?} to {:?}, adding {:?} to used mutable set",

compiler/rustc_builtin_macros/src/cfg_eval.rs

@@ -107,40 +107,42 @@ impl CfgEval<'_> {
         // our attribute target will correctly configure the tokens as well.
         let mut parser = Parser::new(&self.0.sess.psess, orig_tokens, None);
         parser.capture_cfg = true;
-        let res: PResult<'_, Annotatable> = try {
-            match annotatable {
-                Annotatable::Item(_) => {
-                    let item =
-                        parser.parse_item(ForceCollect::Yes, AllowConstBlockItems::Yes)?.unwrap();
-                    Annotatable::Item(self.flat_map_item(item).pop().unwrap())
-                }
+        let res: PResult<'_, Option<Annotatable>> = try {
+            match &annotatable {
+                Annotatable::Item(_) => parser
+                    .parse_item(ForceCollect::Yes, AllowConstBlockItems::Yes)?
+                    .and_then(|item| self.flat_map_item(item).pop().map(Annotatable::Item)),
                 Annotatable::AssocItem(_, ctxt) => {
-                    let item = parser.parse_trait_item(ForceCollect::Yes)?.unwrap().unwrap();
-                    Annotatable::AssocItem(
-                        self.flat_map_assoc_item(item, ctxt).pop().unwrap(),
-                        ctxt,
-                    )
+                    parser.parse_trait_item(ForceCollect::Yes)?.flatten().and_then(|item| {
+                        self.flat_map_assoc_item(item, *ctxt)
+                            .pop()
+                            .map(|item| Annotatable::AssocItem(item, *ctxt))
+                    })
                 }
                 Annotatable::ForeignItem(_) => {
-                    let item = parser.parse_foreign_item(ForceCollect::Yes)?.unwrap().unwrap();
-                    Annotatable::ForeignItem(self.flat_map_foreign_item(item).pop().unwrap())
+                    parser.parse_foreign_item(ForceCollect::Yes)?.flatten().and_then(|item| {
+                        self.flat_map_foreign_item(item).pop().map(Annotatable::ForeignItem)
+                    })
                 }
                 Annotatable::Stmt(_) => {
                     let stmt =
                         parser.parse_stmt_without_recovery(false, ForceCollect::Yes, false)?;
-                    Annotatable::Stmt(Box::new(self.flat_map_stmt(stmt).pop().unwrap()))
+                    self.flat_map_stmt(stmt).pop().map(|stmt| Annotatable::Stmt(Box::new(stmt)))
                 }
                 Annotatable::Expr(_) => {
                     let mut expr = parser.parse_expr_force_collect()?;
                     self.visit_expr(&mut expr);
-                    Annotatable::Expr(expr)
+                    Some(Annotatable::Expr(expr))
                 }
                 _ => unreachable!(),
             }
         };
 
         match res {
-            Ok(ann) => ann,
+            Ok(Some(ann)) => ann,
+            // Parser recovery may emit errors without reconstructing an annotatable.
+            // Keep the original node so cfg-eval stays best-effort instead of ICEing.
+            Ok(None) => annotatable,
             Err(err) => {
                 err.emit();
                 annotatable

compiler/rustc_hir_analysis/src/check/always_applicable.rs

@@ -282,7 +282,7 @@ fn ensure_impl_predicates_are_implied_by_item_defn<'tcx>(
     // reference the params from the ADT instead of from the impl which is bad UX. To resolve
     // this we "rename" the ADT's params to be the impl's params which should not affect behaviour.
     let impl_adt_ty = Ty::new_adt(tcx, tcx.adt_def(adt_def_id), adt_to_impl_args);
-    let adt_env = ty::EarlyBinder::bind(tcx, tcx.param_env(adt_def_id))
+    let adt_env = ty::EarlyBinder::bind_unchecked(tcx.param_env(adt_def_id))
         .instantiate(tcx, adt_to_impl_args)
         .skip_norm_wip();
 

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -31,7 +31,7 @@ use rustc_session::diagnostics::feature_err;
 use rustc_span::{DUMMY_SP, Span, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::regions::{
-    InferCtxtRegionExt, OutlivesEnvironmentBuildExt, region_known_to_outlive, ty_known_to_outlive,
+    OutlivesEnvironmentBuildExt, region_known_to_outlive, ty_known_to_outlive,
 };
 use rustc_trait_selection::traits::misc::{
     ConstParamTyImplementationError, type_allowed_to_implement_const_param_ty,

compiler/rustc_hir_analysis/src/outlives/utils.rs

@@ -83,7 +83,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(
                         span_bug!(span, "Should not deduce placeholder outlives component");
                     }
 
-                    Component::Alias(alias_ty) => {
+                    Component::Alias(is_rigid, alias_ty) => {
                         // This would either arise from something like:
                         //
                         // ```
@@ -102,7 +102,7 @@ pub(crate) fn insert_outlives_predicate<'tcx>(
                         //
                         // Here we want to add an explicit `where <T as Iterator>::Item: 'a`
                         // or `Opaque<T>: 'a` depending on the alias kind.
-                        let ty = alias_ty.to_ty(tcx, ty::IsRigid::No);
+                        let ty = alias_ty.to_ty(tcx, is_rigid);
                         required_predicates
                             .entry(ty::OutlivesPredicate(ty.into(), outlived_region))
                             .or_insert(span);

compiler/rustc_infer/src/infer/mod.rs

@@ -355,7 +355,7 @@ impl<'tcx> Drop for InferCtxt<'tcx> {
 
         // No need for the drop bomb when we're in `TypingMode::PostTypeckUntilBorrowck`, and the `InferCtxt`
         // doesn't consider regions. This is okay since after typeck, the only reason we care about opaques is
-        // in relation to regions. In some places *after* typeck that aren't borrowck, like in lints we use
+        // in relation to regions. In some places *after* typeck that aren't borrowck, we use
         // `TypingMode::PostTypeckUntilBorrowck` to prevent defining opaque types and we simply don't care about regions.
         match self.typing_mode_raw() {
             TypingMode::Coherence