Render fn defs with target_features attrs with the attribute [second site]

Author: oli-obk

compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs

@@ -1543,7 +1543,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         (false, Mismatch::Fixed("existential projection"))
                     }
                 };
-                let Some(vals) = self.values_str(values) else {
+                let Some(vals) = self.values_str(values, cause) else {
                     // Derived error. Cancel the emitter.
                     // NOTE(eddyb) this was `.cancel()`, but `diag`
                     // is borrowed, so we can't fully defuse it.
@@ -1969,7 +1969,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         })
         | ObligationCauseCode::BlockTailExpression(.., source)) = code
             && let hir::MatchSource::TryDesugar(_) = source
-            && let Some((expected_ty, found_ty, _)) = self.values_str(trace.values)
+            && let Some((expected_ty, found_ty, _)) = self.values_str(trace.values, &trace.cause)
         {
             suggestions.push(TypeErrorAdditionalDiags::TryCannotConvert {
                 found: found_ty.content(),
@@ -2096,6 +2096,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
     fn values_str(
         &self,
         values: ValuePairs<'tcx>,
+        cause: &ObligationCause<'tcx>,
     ) -> Option<(DiagStyledString, DiagStyledString, Option<PathBuf>)> {
         match values {
             ValuePairs::Regions(exp_found) => self.expected_found_str(exp_found),
@@ -2120,7 +2121,28 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 if exp_found.references_error() {
                     return None;
                 }
-                let (exp, fnd) = self.cmp_fn_sig(&exp_found.expected, None, &exp_found.found, None);
+                let (fn_def1, fn_def2) = if let ObligationCauseCode::CompareImplItem {
+                    impl_item_def_id,
+                    trait_item_def_id,
+                    ..
+                } = *cause.code()
+                {
+                    (
+                        Some((
+                            trait_item_def_id,
+                            &ty::GenericArgs::identity_for_item(self.tcx, trait_item_def_id)[..],
+                        )),
+                        Some((
+                            impl_item_def_id.to_def_id(),
+                            &ty::GenericArgs::identity_for_item(self.tcx, impl_item_def_id)[..],
+                        )),
+                    )
+                } else {
+                    (None, None)
+                };
+
+                let (exp, fnd) =
+                    self.cmp_fn_sig(&exp_found.expected, fn_def1, &exp_found.found, fn_def2);
                 Some((exp, fnd, None))
             }
         }

compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/trait_impl_difference.rs

@@ -3,14 +3,14 @@
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir as hir;
 use rustc_hir::def::{Namespace, Res};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::Visitor;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::traits::ObligationCauseCode;
 use rustc_middle::ty::error::ExpectedFound;
 use rustc_middle::ty::print::RegionHighlightMode;
 use rustc_middle::ty::{self, TyCtxt, TypeVisitable};
-use rustc_span::Span;
+use rustc_span::{Span, sym};
 use tracing::debug;
 
 use crate::error_reporting::infer::nice_region_error::NiceRegionError;
@@ -33,14 +33,21 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
             _,
         ) = error.clone()
             && let (Subtype(sup_trace), Subtype(sub_trace)) = (&sup_origin, &sub_origin)
-            && let &ObligationCauseCode::CompareImplItem { trait_item_def_id, .. } =
-                sub_trace.cause.code()
+            && let &ObligationCauseCode::CompareImplItem {
+                trait_item_def_id, impl_item_def_id, ..
+            } = sub_trace.cause.code()
             && sub_trace.values == sup_trace.values
             && let ValuePairs::PolySigs(ExpectedFound { expected, found }) = sub_trace.values
         {
             // FIXME(compiler-errors): Don't like that this needs `Ty`s, but
             // all of the region highlighting machinery only deals with those.
-            let guar = self.emit_err(var_origin.span(), expected, found, trait_item_def_id);
+            let guar = self.emit_err(
+                var_origin.span(),
+                expected,
+                found,
+                trait_item_def_id,
+                impl_item_def_id,
+            );
             return Some(guar);
         }
         None
@@ -52,6 +59,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         expected: ty::PolyFnSig<'tcx>,
         found: ty::PolyFnSig<'tcx>,
         trait_item_def_id: DefId,
+        impl_item_def_id: LocalDefId,
     ) -> ErrorGuaranteed {
         let trait_sp = self.tcx().def_span(trait_item_def_id);
 
@@ -82,18 +90,31 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
 
         let expected_highlight = HighlightBuilder::build(expected);
         let tcx = self.cx.tcx;
-        let expected = Highlighted {
+        let mut expected = Highlighted {
             highlight: expected_highlight,
             ns: Namespace::TypeNS,
             tcx,
             value: expected,
         }
         .to_string();
+        // Cannot look at parsed codegen attributes, as those don't get emitted while we don't
+        // allow target_features on trait methods.
+        if let Some(trait_item_def_id) = trait_item_def_id.as_local() {
+            if tcx.has_attr(trait_item_def_id, sym::target_feature) {
+                expected = format!("#[target_features] {expected}");
+            }
+        }
         let found_highlight = HighlightBuilder::build(found);
-        let found =
+        let mut found =
             Highlighted { highlight: found_highlight, ns: Namespace::TypeNS, tcx, value: found }
                 .to_string();
 
+        // Cannot look at parsed codegen attributes, as those don't get emitted while we don't
+        // allow target_features on trait impl methods.
+        if tcx.has_attr(impl_item_def_id, sym::target_feature) {
+            found = format!("#[target_features] {found}");
+        }
+
         // Get the span of all the used type parameters in the method.
         let assoc_item = self.tcx().associated_item(trait_item_def_id);
         let mut visitor = TypeParamSpanVisitor { tcx: self.tcx(), types: vec![] };

compiler/rustc_trait_selection/src/error_reporting/infer/region.rs

@@ -222,7 +222,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             infer::Subtype(ref trace) => RegionOriginNote::WithRequirement {
                 span: trace.cause.span,
                 requirement: ObligationCauseAsDiagArg(trace.cause.clone()),
-                expected_found: self.values_str(trace.values).map(|(e, f, _)| (e, f)),
+                expected_found: self.values_str(trace.values, &trace.cause).map(|(e, f, _)| (e, f)),
             }
             .add_to_diag(err),
             infer::Reborrow(span) => {
@@ -947,8 +947,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
         if let infer::Subtype(ref sup_trace) = sup_origin
             && let infer::Subtype(ref sub_trace) = sub_origin
-            && let Some((sup_expected, sup_found, _)) = self.values_str(sup_trace.values)
-            && let Some((sub_expected, sub_found, _)) = self.values_str(sub_trace.values)
+            && let Some((sup_expected, sup_found, _)) =
+                self.values_str(sup_trace.values, &sup_trace.cause)
+            && let Some((sub_expected, sub_found, _)) =
+                self.values_str(sub_trace.values, &sup_trace.cause)
             && sub_expected == sup_expected
             && sub_found == sup_found
         {

tests/ui/rfcs/rfc-2396-target_feature-11/trait-impl.stderr

@@ -10,7 +10,7 @@ note: type in trait
 LL |     fn foo(&self);
    |     ^^^^^^^^^^^^^^
    = note: expected signature `fn(&Bar)`
-              found signature `unsafe fn(&Bar)`
+              found signature `#[target_feature] unsafe fn(&Bar)`
 
 error: `#[target_feature(..)]` cannot be applied to safe trait method
   --> $DIR/trait-impl.rs:13:5

tests/ui/target-feature/invalid-attribute.stderr

@@ -204,7 +204,7 @@ note: type in trait
 LL |     fn foo();
    |     ^^^^^^^^^
    = note: expected signature `fn()`
-              found signature `unsafe fn()`
+              found signature `#[target_feature] unsafe fn()`
 
 error[E0658]: `#[target_feature(..)]` can only be applied to `unsafe` functions
   --> $DIR/invalid-attribute.rs:104:5