Skip the lint if there is unstable_feature_bound

Author: tiif

compiler/rustc_passes/src/stability.rs

@@ -801,22 +801,47 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     // FIXME(jdonszelmann): make it impossible to miss the or_else in the typesystem
                     let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability{stability, ..} => *stability);
 
+                    let unstable_feature_stab =  
+                        find_attr!(attrs, AttributeKind::AllowUnstableFeature(i) => i)
+                        .map(|i| i.as_slice())
+                        .unwrap_or_default();
+
                     // If this impl block has an #[unstable] attribute, give an
                     // error if all involved types and traits are stable, because
                     // it will have no effect.
                     // See: https://github.com/rust-lang/rust/issues/55436
+                    //
+                    // The exception is when there is both  #[unstable_feature_bound(..)] and
+                    //  #![unstable(feature = "..", issue = "..")] that have the same symbol because 
+                    // that can effectively mark an impl as unstable.
+                    //
+                    // For example:
+                    // ```
+                    // #[unstable_feature_bound(feat_foo)] 
+                    // #![unstable(feature = "feat_foo", issue = "none")]
+                    // impl Foo for Bar {}
+                    // ```
                     if let Some((
-                        Stability { level: attrs::StabilityLevel::Unstable { .. }, .. },
+                        Stability { level: attrs::StabilityLevel::Unstable { ..}, feature},
                         span,
                     )) = stab
                     {
                         let mut c = CheckTraitImplStable { tcx: self.tcx, fully_stable: true };
                         c.visit_ty_unambig(self_ty);
                         c.visit_trait_ref(t);
 
+                        // Skip the lint if the impl is marked as unstable using
+                        // #[unstable_feature_bound(..)] 
+                        let mut unstable_feature_bound_in_effect = false;
+                        for (unstable_bound_feat_name, _) in unstable_feature_stab {
+                            if *unstable_bound_feat_name == feature {
+                                unstable_feature_bound_in_effect = true;
+                            }
+                        }
+
                         // do not lint when the trait isn't resolved, since resolution error should
                         // be fixed first
-                        if t.path.res != Res::Err && c.fully_stable {
+                        if t.path.res != Res::Err && c.fully_stable && !unstable_feature_bound_in_effect {
                             self.tcx.emit_node_span_lint(
                                 INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
                                 item.hir_id(),

tests/ui/internal/unstable-feature-bound-no-effect.rs

@@ -0,0 +1,25 @@
+#![allow(internal_features)] // Enabled to use #![feature(staged_api)] and #![feature(impl_stability)]
+//~^ ERROR:  module has missing stability attribute
+#![feature(staged_api)] // Enabled to use  #![unstable(feature = "feat_foo", issue = "none")]
+#![feature(impl_stability)] // Enabled to use #[unstable_feature_bound(feat_foo)] 
+#![allow(dead_code)]
+
+#[stable(feature = "a", since = "1.1.1" )]
+trait Moo {}
+#[stable(feature = "a", since = "1.1.1" )]
+trait Foo {}
+#[stable(feature = "a", since = "1.1.1" )]
+pub struct Bar;
+
+
+// If #[unstable_feature_bound] and #[unstable] has different name,
+// It should throw an error. 
+#[unstable(feature = "feat_moo", issue = "none" )]
+#[unstable_feature_bound(feat_foo)] //~^ ERROR: an `#[unstable]` annotation here has no effect
+impl Moo for Bar {}
+
+#[unstable(feature = "feat_foo", issue = "none" )]
+#[unstable_feature_bound(feat_foo)]
+impl Foo for Bar {}
+
+fn main() {}