Auto merge of rust-lang#122607 - fmease:rollup-ozl1eeq, r=fmease

Rollup of 9 pull requests

Successful merges:

 - rust-lang#117918 (Add `wasm_c_abi` `future-incompat` lint)
 - rust-lang#121545 (fix attribute validation on associated items in traits)
 - rust-lang#121720 (Split refining_impl_trait lint into _reachable, _internal variants)
 - rust-lang#122270 (fix `long-linker-command-lines` failure caused by `rust.rpath=false`)
 - rust-lang#122564 (Delegation: fix ICE on duplicated associative items)
 - rust-lang#122577 (Remove obsolete parameter `speculative` from `instantiate_poly_trait_ref`)
 - rust-lang#122601 (Optimize `ptr::replace`)
 - rust-lang#122604 (Mention jieyouxu for changes to compiletest, run-make tests and the run-make-support library)
 - rust-lang#122605 (rustc-metadata: Store crate name in self-profile of metadata_register_crate)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_ast_lowering/src/item.rs

@@ -373,6 +373,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         (trait_ref, lowered_ty)
                     });
 
+                self.is_in_trait_impl = trait_ref.is_some();
                 let new_impl_items = self
                     .arena
                     .alloc_from_iter(impl_items.iter().map(|item| self.lower_impl_item_ref(item)));
@@ -978,13 +979,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
-        let trait_item_def_id = self
-            .resolver
-            .get_partial_res(i.id)
-            .map(|r| r.expect_full_res().opt_def_id())
-            .unwrap_or(None);
-        self.is_in_trait_impl = trait_item_def_id.is_some();
-
         hir::ImplItemRef {
             id: hir::ImplItemId { owner_id: hir::OwnerId { def_id: self.local_def_id(i.id) } },
             ident: self.lower_ident(i.ident),
@@ -1000,7 +994,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 },
                 AssocItemKind::MacCall(..) => unimplemented!(),
             },
-            trait_item_def_id,
+            trait_item_def_id: self
+                .resolver
+                .get_partial_res(i.id)
+                .map(|r| r.expect_full_res().opt_def_id())
+                .unwrap_or(None),
         }
     }
 

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1527,6 +1527,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     generics,
                     body.as_deref(),
                 );
+                walk_list!(self, visit_attribute, &item.attrs);
                 self.visit_fn(kind, item.span, item.id);
             }
             AssocItemKind::Type(_) => {

compiler/rustc_hir_analysis/messages.ftl

@@ -351,6 +351,7 @@ hir_analysis_rpitit_refined = impl trait in impl method signature does not match
     .label = return type from trait method defined here
     .unmatched_bound_label = this bound is stronger than that defined on the trait
     .note = add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate
+    .feedback_note = we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information
 
 hir_analysis_self_in_impl_self =
     `Self` is not valid in the self type of an impl block

compiler/rustc_hir_analysis/src/astconv/bounds.rs

@@ -149,7 +149,6 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                         polarity,
                         param_ty,
                         bounds,
-                        false,
                         only_self_bounds,
                     );
                 }
@@ -231,14 +230,13 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
     /// **A note on binders:** given something like `T: for<'a> Iterator<Item = &'a u32>`, the
     /// `trait_ref` here will be `for<'a> T: Iterator`. The `binding` data however is from *inside*
     /// the binder (e.g., `&'a u32`) and hence may reference bound regions.
-    #[instrument(level = "debug", skip(self, bounds, speculative, dup_bindings, path_span))]
+    #[instrument(level = "debug", skip(self, bounds, dup_bindings, path_span))]
     pub(super) fn add_predicates_for_ast_type_binding(
         &self,
         hir_ref_id: hir::HirId,
         trait_ref: ty::PolyTraitRef<'tcx>,
         binding: &hir::TypeBinding<'tcx>,
         bounds: &mut Bounds<'tcx>,
-        speculative: bool,
         dup_bindings: &mut FxIndexMap<DefId, Span>,
         path_span: Span,
         only_self_bounds: OnlySelfBounds,
@@ -317,19 +315,17 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
         }
         tcx.check_stability(assoc_item.def_id, Some(hir_ref_id), binding.span, None);
 
-        if !speculative {
-            dup_bindings
-                .entry(assoc_item.def_id)
-                .and_modify(|prev_span| {
-                    tcx.dcx().emit_err(errors::ValueOfAssociatedStructAlreadySpecified {
-                        span: binding.span,
-                        prev_span: *prev_span,
-                        item_name: binding.ident,
-                        def_path: tcx.def_path_str(assoc_item.container_id(tcx)),
-                    });
-                })
-                .or_insert(binding.span);
-        }
+        dup_bindings
+            .entry(assoc_item.def_id)
+            .and_modify(|prev_span| {
+                tcx.dcx().emit_err(errors::ValueOfAssociatedStructAlreadySpecified {
+                    span: binding.span,
+                    prev_span: *prev_span,
+                    item_name: binding.ident,
+                    def_path: tcx.def_path_str(assoc_item.container_id(tcx)),
+                });
+            })
+            .or_insert(binding.span);
 
         let projection_ty = if let ty::AssocKind::Fn = assoc_kind {
             let mut emitted_bad_param_err = None;
@@ -433,9 +429,8 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
             });
 
             // Provide the resolved type of the associated constant to `type_of(AnonConst)`.
-            if !speculative
-                && let hir::TypeBindingKind::Equality { term: hir::Term::Const(anon_const) } =
-                    binding.kind
+            if let hir::TypeBindingKind::Equality { term: hir::Term::Const(anon_const) } =
+                binding.kind
             {
                 let ty = alias_ty.map_bound(|ty| tcx.type_of(ty.def_id).instantiate(tcx, ty.args));
                 // Since the arguments passed to the alias type above may contain early-bound
@@ -463,42 +458,40 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                     hir::Term::Const(ct) => ty::Const::from_anon_const(tcx, ct.def_id).into(),
                 };
 
-                if !speculative {
-                    // Find any late-bound regions declared in `ty` that are not
-                    // declared in the trait-ref or assoc_item. These are not well-formed.
-                    //
-                    // Example:
-                    //
-                    //     for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad
-                    //     for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok
-                    let late_bound_in_projection_ty =
-                        tcx.collect_constrained_late_bound_regions(projection_ty);
-                    let late_bound_in_term =
-                        tcx.collect_referenced_late_bound_regions(trait_ref.rebind(term));
-                    debug!(?late_bound_in_projection_ty);
-                    debug!(?late_bound_in_term);
+                // Find any late-bound regions declared in `ty` that are not
+                // declared in the trait-ref or assoc_item. These are not well-formed.
+                //
+                // Example:
+                //
+                //     for<'a> <T as Iterator>::Item = &'a str // <-- 'a is bad
+                //     for<'a> <T as FnMut<(&'a u32,)>>::Output = &'a str // <-- 'a is ok
+                let late_bound_in_projection_ty =
+                    tcx.collect_constrained_late_bound_regions(projection_ty);
+                let late_bound_in_term =
+                    tcx.collect_referenced_late_bound_regions(trait_ref.rebind(term));
+                debug!(?late_bound_in_projection_ty);
+                debug!(?late_bound_in_term);
 
-                    // FIXME: point at the type params that don't have appropriate lifetimes:
-                    // struct S1<F: for<'a> Fn(&i32, &i32) -> &'a i32>(F);
-                    //                         ----  ----     ^^^^^^^
-                    // NOTE(associated_const_equality): This error should be impossible to trigger
-                    //                                  with associated const equality bounds.
-                    self.validate_late_bound_regions(
-                        late_bound_in_projection_ty,
-                        late_bound_in_term,
-                        |br_name| {
-                            struct_span_code_err!(
-                                tcx.dcx(),
-                                binding.span,
-                                E0582,
-                                "binding for associated type `{}` references {}, \
-                                 which does not appear in the trait input types",
-                                binding.ident,
-                                br_name
-                            )
-                        },
-                    );
-                }
+                // FIXME: point at the type params that don't have appropriate lifetimes:
+                // struct S1<F: for<'a> Fn(&i32, &i32) -> &'a i32>(F);
+                //                         ----  ----     ^^^^^^^
+                // NOTE(associated_const_equality): This error should be impossible to trigger
+                //                                  with associated const equality bounds.
+                self.validate_late_bound_regions(
+                    late_bound_in_projection_ty,
+                    late_bound_in_term,
+                    |br_name| {
+                        struct_span_code_err!(
+                            tcx.dcx(),
+                            binding.span,
+                            E0582,
+                            "binding for associated type `{}` references {}, \
+                                which does not appear in the trait input types",
+                            binding.ident,
+                            br_name
+                        )
+                    },
+                );
 
                 // "Desugar" a constraint like `T: Iterator<Item = u32>` this to
                 // the "projection predicate" for:

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -639,7 +639,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
     /// where `'a` is a bound region at depth 0. Similarly, the `poly_trait_ref` would be
     /// `Bar<'a>`. The returned poly-trait-ref will have this binder instantiated explicitly,
     /// however.
-    #[instrument(level = "debug", skip(self, span, constness, bounds, speculative))]
+    #[instrument(level = "debug", skip(self, span, constness, bounds))]
     pub(crate) fn instantiate_poly_trait_ref(
         &self,
         trait_ref: &hir::TraitRef<'tcx>,
@@ -648,7 +648,6 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
         polarity: ty::ImplPolarity,
         self_ty: Ty<'tcx>,
         bounds: &mut Bounds<'tcx>,
-        speculative: bool,
         only_self_bounds: OnlySelfBounds,
     ) -> GenericArgCountResult {
         let trait_def_id = trait_ref.trait_def_id().unwrap_or_else(|| FatalError.raise());
@@ -697,7 +696,6 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                 poly_trait_ref,
                 binding,
                 bounds,
-                speculative,
                 &mut dup_bindings,
                 binding.span,
                 only_self_bounds,

compiler/rustc_hir_analysis/src/astconv/object_safety.rs

@@ -44,7 +44,6 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                 ty::ImplPolarity::Positive,
                 dummy_self,
                 &mut bounds,
-                false,
                 // True so we don't populate `bounds` with associated type bounds, even
                 // though they're disallowed from object types.
                 OnlySelfBounds(true),

compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

@@ -2,7 +2,7 @@ use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::{outlives::env::OutlivesEnvironment, TyCtxtInferExt};
-use rustc_lint_defs::builtin::REFINING_IMPL_TRAIT;
+use rustc_lint_defs::builtin::{REFINING_IMPL_TRAIT_INTERNAL, REFINING_IMPL_TRAIT_REACHABLE};
 use rustc_middle::traits::{ObligationCause, Reveal};
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperVisitable, TypeVisitable, TypeVisitor,
@@ -23,26 +23,23 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
     if !tcx.impl_method_has_trait_impl_trait_tys(impl_m.def_id) {
         return;
     }
+
     // unreachable traits don't have any library guarantees, there's no need to do this check.
-    if trait_m
+    let is_internal = trait_m
         .container_id(tcx)
         .as_local()
         .is_some_and(|trait_def_id| !tcx.effective_visibilities(()).is_reachable(trait_def_id))
-    {
-        return;
-    }
+        // If a type in the trait ref is private, then there's also no reason to do this check.
+        || impl_trait_ref.args.iter().any(|arg| {
+            if let Some(ty) = arg.as_type()
+                && let Some(self_visibility) = type_visibility(tcx, ty)
+            {
+                return !self_visibility.is_public();
+            }
+            false
+        });
 
-    // If a type in the trait ref is private, then there's also no reason to do this check.
     let impl_def_id = impl_m.container_id(tcx);
-    for arg in impl_trait_ref.args {
-        if let Some(ty) = arg.as_type()
-            && let Some(self_visibility) = type_visibility(tcx, ty)
-            && !self_visibility.is_public()
-        {
-            return;
-        }
-    }
-
     let impl_m_args = ty::GenericArgs::identity_for_item(tcx, impl_m.def_id);
     let trait_m_to_impl_m_args = impl_m_args.rebase_onto(tcx, impl_def_id, impl_trait_ref.args);
     let bound_trait_m_sig = tcx.fn_sig(trait_m.def_id).instantiate(tcx, trait_m_to_impl_m_args);
@@ -85,6 +82,7 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
                 trait_m.def_id,
                 impl_m.def_id,
                 None,
+                is_internal,
             );
             return;
         };
@@ -104,6 +102,7 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
                 trait_m.def_id,
                 impl_m.def_id,
                 None,
+                is_internal,
             );
             return;
         }
@@ -198,6 +197,7 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
                 trait_m.def_id,
                 impl_m.def_id,
                 Some(span),
+                is_internal,
             );
             return;
         }
@@ -235,6 +235,7 @@ fn report_mismatched_rpitit_signature<'tcx>(
     trait_m_def_id: DefId,
     impl_m_def_id: DefId,
     unmatched_bound: Option<Span>,
+    is_internal: bool,
 ) {
     let mapping = std::iter::zip(
         tcx.fn_sig(trait_m_def_id).skip_binder().bound_vars(),
@@ -287,7 +288,7 @@ fn report_mismatched_rpitit_signature<'tcx>(
 
     let span = unmatched_bound.unwrap_or(span);
     tcx.emit_node_span_lint(
-        REFINING_IMPL_TRAIT,
+        if is_internal { REFINING_IMPL_TRAIT_INTERNAL } else { REFINING_IMPL_TRAIT_REACHABLE },
         tcx.local_def_id_to_hir_id(impl_m_def_id.expect_local()),
         span,
         crate::errors::ReturnPositionImplTraitInTraitRefined {

compiler/rustc_hir_analysis/src/errors.rs

@@ -1072,6 +1072,7 @@ pub struct UnusedAssociatedTypeBounds {
 #[derive(LintDiagnostic)]
 #[diag(hir_analysis_rpitit_refined)]
 #[note]
+#[note(hir_analysis_feedback_note)]
 pub(crate) struct ReturnPositionImplTraitInTraitRefined<'tcx> {
     #[suggestion(applicability = "maybe-incorrect", code = "{pre}{return_ty}{post}")]
     pub impl_return_span: Span,

compiler/rustc_lint/src/lib.rs

@@ -313,6 +313,12 @@ fn register_builtins(store: &mut LintStore) {
                                        // MACRO_USE_EXTERN_CRATE
     );
 
+    add_lint_group!(
+        "refining_impl_trait",
+        REFINING_IMPL_TRAIT_REACHABLE,
+        REFINING_IMPL_TRAIT_INTERNAL
+    );
+
     // Register renamed and removed lints.
     store.register_renamed("single_use_lifetime", "single_use_lifetimes");
     store.register_renamed("elided_lifetime_in_path", "elided_lifetimes_in_paths");