Fix unnecessary restrictions in struct-target-features.

Allow using struct-tf with functions with non-Rust ABI.
Also allow converting struct-tf functions to function pointers / let
them implement function traits.

Author: veluca93

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -611,13 +611,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 &mut additional_tf,
             )
         }
-        // FIXME(struct_target_features): is this really necessary?
-        if !additional_tf.is_empty() && sig.skip_binder().abi() != abi::Abi::Rust {
-            tcx.dcx().span_err(
-                tcx.hir().span(tcx.local_def_id_to_hir_id(did)),
-                "cannot use a struct with target features in a function with non-Rust ABI",
-            );
-        }
         if !additional_tf.is_empty() && codegen_fn_attrs.inline == InlineAttr::Always {
             tcx.dcx().span_err(
                 tcx.hir().span(tcx.local_def_id_to_hir_id(did)),

compiler/rustc_hir_typeck/src/coercion.rs

@@ -909,12 +909,15 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                         return Err(TypeError::IntrinsicCast);
                     }
 
-                    // Safe `#[target_feature]` functions are not assignable to safe fn pointers (RFC 2396).
-                    // FIXME(struct_target_features): should this be true also for functions that inherit
-                    // target features from structs?
-
+                    // Safe functions with explicit `#[target_feature]` attributes are not
+                    // assignable to safe fn pointers (RFC 2396).
                     if b_hdr.safety == hir::Safety::Safe
-                        && !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty()
+                        && self
+                            .tcx
+                            .codegen_fn_attrs(def_id)
+                            .target_features
+                            .iter()
+                            .any(|x| !x.implied)
                     {
                         return Err(TypeError::TargetFeatureCast(def_id));
                     }

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -464,9 +464,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         let is_target_feature_fn = if let ty::FnDef(def_id, _) =
                             *leaf_trait_ref.skip_binder().self_ty().kind()
                         {
-                            // FIXME(struct_target_features): should a function that inherits
-                            // target_features through arguments implement Fn traits?
-                            !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty()
+                            self.tcx.codegen_fn_attrs(def_id).target_features.iter().any(|x| !x.implied)
                         } else {
                             false
                         };

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -546,13 +546,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         .push(FnPointerCandidate { fn_host_effect: self.tcx().consts.true_ });
                 }
             }
-            // Provide an impl for suitable functions, rejecting `#[target_feature]` functions (RFC 2396).
+            // Provide an impl for suitable functions, rejecting functions with explicit
+            // `#[target_feature]` attributes (RFC 2396).
             ty::FnDef(def_id, args) => {
                 let tcx = self.tcx();
-                // FIXME(struct_target_features): should a function that inherits target_features
-                // through an argument implement Fn traits?
                 if tcx.fn_sig(def_id).skip_binder().is_fn_trait_compatible()
-                    && tcx.codegen_fn_attrs(def_id).target_features.is_empty()
+                    && !tcx.codegen_fn_attrs(def_id).target_features.iter().any(|x| !x.implied)
                 {
                     candidates.vec.push(FnPointerCandidate {
                         fn_host_effect: tcx