remove the coherence_leak_check lint

Author: lcnr

Diff for: compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs

@@ -7,7 +7,7 @@ use rustc_index::IndexVec;
 use rustc_middle::traits::specialization_graph::OverlapMode;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::Symbol;
-use rustc_trait_selection::traits::{self, SkipLeakCheck};
+use rustc_trait_selection::traits;
 use smallvec::SmallVec;
 use std::collections::hash_map::Entry;
 
@@ -139,15 +139,8 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
         impl1_def_id: DefId,
         impl2_def_id: DefId,
     ) {
-        let maybe_overlap = traits::overlapping_impls(
-            self.tcx,
-            impl1_def_id,
-            impl2_def_id,
-            // We go ahead and just skip the leak check for
-            // inherent impls without warning.
-            SkipLeakCheck::Yes,
-            overlap_mode,
-        );
+        let maybe_overlap =
+            traits::overlapping_impls(self.tcx, impl1_def_id, impl2_def_id, overlap_mode);
 
         if let Some(overlap) = maybe_overlap {
             self.check_for_common_items_in_impls(impl1_def_id, impl2_def_id, overlap);

Diff for: compiler/rustc_infer/src/infer/at.rs

@@ -78,7 +78,6 @@ impl<'tcx> InferCtxt<'tcx> {
             tcx: self.tcx,
             defining_use_anchor: self.defining_use_anchor,
             considering_regions: self.considering_regions,
-            skip_leak_check: self.skip_leak_check,
             inner: self.inner.clone(),
             lexical_region_resolutions: self.lexical_region_resolutions.clone(),
             selection_cache: self.selection_cache.clone(),

Diff for: compiler/rustc_infer/src/infer/mod.rs

@@ -256,12 +256,6 @@ pub struct InferCtxt<'tcx> {
     /// solving is left to borrowck instead.
     pub considering_regions: bool,
 
-    /// If set, this flag causes us to skip the 'leak check' during
-    /// higher-ranked subtyping operations. This flag is a temporary one used
-    /// to manage the removal of the leak-check: for the time being, we still run the
-    /// leak-check, but we issue warnings.
-    skip_leak_check: bool,
-
     pub inner: RefCell<InferCtxtInner<'tcx>>,
 
     /// Once region inference is done, the values for each variable.
@@ -606,7 +600,6 @@ pub struct InferCtxtBuilder<'tcx> {
     tcx: TyCtxt<'tcx>,
     defining_use_anchor: DefiningAnchor,
     considering_regions: bool,
-    skip_leak_check: bool,
     /// Whether we are in coherence mode.
     intercrate: bool,
     /// Whether we should use the new trait solver in the local inference context,
@@ -624,7 +617,6 @@ impl<'tcx> TyCtxtInferExt<'tcx> for TyCtxt<'tcx> {
             tcx: self,
             defining_use_anchor: DefiningAnchor::Error,
             considering_regions: true,
-            skip_leak_check: false,
             intercrate: false,
             next_trait_solver: self.next_trait_solver_globally(),
         }
@@ -658,11 +650,6 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
         self
     }
 
-    pub fn skip_leak_check(mut self, skip_leak_check: bool) -> Self {
-        self.skip_leak_check = skip_leak_check;
-        self
-    }
-
     /// Given a canonical value `C` as a starting point, create an
     /// inference context that contains each of the bound values
     /// within instantiated as a fresh variable. The `f` closure is
@@ -688,15 +675,13 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
             tcx,
             defining_use_anchor,
             considering_regions,
-            skip_leak_check,
             intercrate,
             next_trait_solver,
         } = *self;
         InferCtxt {
             tcx,
             defining_use_anchor,
             considering_regions,
-            skip_leak_check,
             inner: RefCell::new(InferCtxtInner::new()),
             lexical_region_resolutions: RefCell::new(None),
             selection_cache: Default::default(),

Diff for: compiler/rustc_infer/src/infer/relate/higher_ranked.rs

@@ -116,13 +116,11 @@ impl<'tcx> InferCtxt<'tcx> {
         outer_universe: ty::UniverseIndex,
         only_consider_snapshot: Option<&CombinedSnapshot<'tcx>>,
     ) -> RelateResult<'tcx, ()> {
-        // If the user gave `-Zno-leak-check`, or we have been
-        // configured to skip the leak check, then skip the leak check
-        // completely. The leak check is deprecated. Any legitimate
-        // subtyping errors that it would have caught will now be
-        // caught later on, during region checking. However, we
-        // continue to use it for a transition period.
-        if self.tcx.sess.opts.unstable_opts.no_leak_check || self.skip_leak_check {
+        // If the user gave `-Zno-leak-check`, then skip the leak check
+        // completely. While we considered to remove the leak check at
+        // some point, we are now confident that it will remain in some
+        // form or another.
+        if self.tcx.sess.opts.unstable_opts.no_leak_check {
             return Ok(());
         }
 

Diff for: compiler/rustc_lint/src/lib.rs

@@ -418,6 +418,10 @@ fn register_builtins(store: &mut LintStore) {
         "converted into hard error, see issue #48950 \
          <https://github.com/rust-lang/rust/issues/48950> for more information",
     );
+    store.register_removed(
+        "coherence_leak_check",
+        "no longer a warning, see TODO for more information",
+    );
     store.register_removed(
         "resolve_trait_on_defaulted_unit",
         "converted into hard error, see issue #48950 \

Diff for: compiler/rustc_lint_defs/src/builtin.rs

@@ -25,7 +25,6 @@ declare_lint_pass! {
         BREAK_WITH_LABEL_AND_LOOP,
         BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE,
         CENUM_IMPL_DROP_CAST,
-        COHERENCE_LEAK_CHECK,
         CONFLICTING_REPR_HINTS,
         CONST_EVALUATABLE_UNCHECKED,
         CONST_ITEM_MUTATION,
@@ -1467,46 +1466,6 @@ declare_lint! {
     };
 }
 
-declare_lint! {
-    /// The `coherence_leak_check` lint detects conflicting implementations of
-    /// a trait that are only distinguished by the old leak-check code.
-    ///
-    /// ### Example
-    ///
-    /// ```rust
-    /// trait SomeTrait { }
-    /// impl SomeTrait for for<'a> fn(&'a u8) { }
-    /// impl<'a> SomeTrait for fn(&'a u8) { }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// In the past, the compiler would accept trait implementations for
-    /// identical functions that differed only in where the lifetime binder
-    /// appeared. Due to a change in the borrow checker implementation to fix
-    /// several bugs, this is no longer allowed. However, since this affects
-    /// existing code, this is a [future-incompatible] lint to transition this
-    /// to a hard error in the future.
-    ///
-    /// Code relying on this pattern should introduce "[newtypes]",
-    /// like `struct Foo(for<'a> fn(&'a u8))`.
-    ///
-    /// See [issue #56105] for more details.
-    ///
-    /// [issue #56105]: https://github.com/rust-lang/rust/issues/56105
-    /// [newtypes]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#using-the-newtype-pattern-for-type-safety-and-abstraction
-    /// [future-incompatible]: ../index.md#future-incompatible-lints
-    pub COHERENCE_LEAK_CHECK,
-    Warn,
-    "distinct impls distinguished only by the leak-check code",
-    @future_incompatible = FutureIncompatibleInfo {
-        reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
-        reference: "issue #56105 <https://github.com/rust-lang/rust/issues/56105>",
-    };
-}
-
 declare_lint! {
     /// The `deprecated` lint detects use of deprecated items.
     ///

Diff for: compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -13,7 +13,6 @@ use crate::traits::query::evaluate_obligation::InferCtxtExt;
 use crate::traits::select::IntercrateAmbiguityCause;
 use crate::traits::structural_normalize::StructurallyNormalizeExt;
 use crate::traits::NormalizeExt;
-use crate::traits::SkipLeakCheck;
 use crate::traits::{
     Obligation, ObligationCause, ObligationCtxt, PredicateObligation, PredicateObligations,
     SelectionContext,
@@ -84,12 +83,11 @@ impl TrackAmbiguityCauses {
 /// If there are types that satisfy both impls, returns `Some`
 /// with a suitably-freshened `ImplHeader` with those types
 /// substituted. Otherwise, returns `None`.
-#[instrument(skip(tcx, skip_leak_check), level = "debug")]
+#[instrument(skip(tcx), level = "debug")]
 pub fn overlapping_impls(
     tcx: TyCtxt<'_>,
     impl1_def_id: DefId,
     impl2_def_id: DefId,
-    skip_leak_check: SkipLeakCheck,
     overlap_mode: OverlapMode,
 ) -> Option<OverlapResult<'_>> {
     // Before doing expensive operations like entering an inference context, do
@@ -114,27 +112,14 @@ pub fn overlapping_impls(
         return None;
     }
 
-    let _overlap_with_bad_diagnostics = overlap(
-        tcx,
-        TrackAmbiguityCauses::No,
-        skip_leak_check,
-        impl1_def_id,
-        impl2_def_id,
-        overlap_mode,
-    )?;
+    let _overlap_with_bad_diagnostics =
+        overlap(tcx, TrackAmbiguityCauses::No, impl1_def_id, impl2_def_id, overlap_mode)?;
 
     // In the case where we detect an error, run the check again, but
     // this time tracking intercrate ambiguity causes for better
     // diagnostics. (These take time and can lead to false errors.)
-    let overlap = overlap(
-        tcx,
-        TrackAmbiguityCauses::Yes,
-        skip_leak_check,
-        impl1_def_id,
-        impl2_def_id,
-        overlap_mode,
-    )
-    .unwrap();
+    let overlap =
+        overlap(tcx, TrackAmbiguityCauses::Yes, impl1_def_id, impl2_def_id, overlap_mode).unwrap();
     Some(overlap)
 }
 
@@ -176,7 +161,6 @@ fn fresh_impl_header_normalized<'tcx>(
 fn overlap<'tcx>(
     tcx: TyCtxt<'tcx>,
     track_ambiguity_causes: TrackAmbiguityCauses,
-    skip_leak_check: SkipLeakCheck,
     impl1_def_id: DefId,
     impl2_def_id: DefId,
     overlap_mode: OverlapMode,
@@ -192,7 +176,6 @@ fn overlap<'tcx>(
     let infcx = tcx
         .infer_ctxt()
         .with_opaque_type_inference(DefiningAnchor::Bubble)
-        .skip_leak_check(skip_leak_check.is_yes())
         .intercrate(true)
         .with_next_trait_solver(tcx.next_trait_solver_in_coherence())
         .build();
@@ -230,8 +213,15 @@ fn overlap<'tcx>(
         }
     }
 
-    // We toggle the `leak_check` by using `skip_leak_check` when constructing the
-    // inference context, so this may be a noop.
+    // Detect any region errors caused by equating these two impls.
+    //
+    // Only higher ranked region errors are possible here, given that we
+    // replaced all parameter regions with existentials.
+    //
+    // Unlike a full region check, which sometimes incompletely handles
+    // `TypeOutlives` constraints, the leak check is a complete. While the
+    // leak check does not detect all region errors, it never
+    // fails in cases which would later pass full region checking.
     if infcx.leak_check(ty::UniverseIndex::ROOT, None).is_err() {
         debug!("overlap: leak check failed");
         return None;

Diff for: compiler/rustc_trait_selection/src/traits/mod.rs

@@ -70,24 +70,6 @@ pub use self::util::{get_vtable_index_of_object_method, impl_item_is_final, upca
 
 pub use rustc_infer::traits::*;
 
-/// Whether to skip the leak check, as part of a future compatibility warning step.
-///
-/// The "default" for skip-leak-check corresponds to the current
-/// behavior (do not skip the leak check) -- not the behavior we are
-/// transitioning into.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
-pub enum SkipLeakCheck {
-    Yes,
-    #[default]
-    No,
-}
-
-impl SkipLeakCheck {
-    fn is_yes(self) -> bool {
-        self == SkipLeakCheck::Yes
-    }
-}
-
 /// The mode that trait queries run in.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum TraitQueryMode {

Diff for: compiler/rustc_trait_selection/src/traits/specialize/mod.rs

@@ -24,7 +24,6 @@ use rustc_errors::{error_code, DelayDm, Diagnostic};
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::ty::{self, ImplSubject, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::ty::{GenericArgs, GenericArgsRef};
-use rustc_session::lint::builtin::COHERENCE_LEAK_CHECK;
 use rustc_session::lint::builtin::ORDER_DEPENDENT_TRAIT_OBJECTS;
 use rustc_span::{Span, DUMMY_SP};
 
@@ -441,7 +440,6 @@ fn report_conflicting_impls<'tcx>(
         Some(kind) => {
             let lint = match kind {
                 FutureCompatOverlapErrorKind::Issue33140 => ORDER_DEPENDENT_TRAIT_OBJECTS,
-                FutureCompatOverlapErrorKind::LeakCheck => COHERENCE_LEAK_CHECK,
             };
             tcx.struct_span_lint_hir(
                 lint,

Diff for: compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs

@@ -11,7 +11,6 @@ pub use rustc_middle::traits::specialization_graph::*;
 #[derive(Copy, Clone, Debug)]
 pub enum FutureCompatOverlapErrorKind {
     Issue33140,
-    LeakCheck,
 }
 
 #[derive(Debug)]
@@ -118,64 +117,31 @@ impl<'tcx> ChildrenExt<'tcx> for Children {
                 }
             };
 
-            let report_overlap_error = |overlap: traits::coherence::OverlapResult<'tcx>,
-                                        last_lint: &mut _| {
-                // Found overlap, but no specialization; error out or report future-compat warning.
-
-                // Do we *still* get overlap if we disable the future-incompatible modes?
-                let should_err = traits::overlapping_impls(
-                    tcx,
-                    possible_sibling,
-                    impl_def_id,
-                    traits::SkipLeakCheck::default(),
-                    overlap_mode,
-                )
-                .is_some();
-
-                let error = create_overlap_error(overlap);
-
-                if should_err {
-                    Err(error)
-                } else {
-                    *last_lint = Some(FutureCompatOverlapError {
-                        error,
-                        kind: FutureCompatOverlapErrorKind::LeakCheck,
-                    });
-
-                    Ok((false, false))
-                }
-            };
-
             let last_lint_mut = &mut last_lint;
-            let (le, ge) = traits::overlapping_impls(
-                tcx,
-                possible_sibling,
-                impl_def_id,
-                traits::SkipLeakCheck::Yes,
-                overlap_mode,
-            )
-            .map_or(Ok((false, false)), |overlap| {
-                if let Some(overlap_kind) =
-                    tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling)
-                {
-                    match overlap_kind {
-                        ty::ImplOverlapKind::Permitted { marker: _ } => {}
-                        ty::ImplOverlapKind::Issue33140 => {
-                            *last_lint_mut = Some(FutureCompatOverlapError {
-                                error: create_overlap_error(overlap),
-                                kind: FutureCompatOverlapErrorKind::Issue33140,
-                            });
+            let (le, ge) =
+                traits::overlapping_impls(tcx, possible_sibling, impl_def_id, overlap_mode)
+                    .map_or(Ok((false, false)), |overlap| {
+                        if let Some(overlap_kind) =
+                            tcx.impls_are_allowed_to_overlap(impl_def_id, possible_sibling)
+                        {
+                            match overlap_kind {
+                                ty::ImplOverlapKind::Permitted { marker: _ } => {}
+                                ty::ImplOverlapKind::Issue33140 => {
+                                    *last_lint_mut = Some(FutureCompatOverlapError {
+                                        error: create_overlap_error(overlap),
+                                        kind: FutureCompatOverlapErrorKind::Issue33140,
+                                    });
+                                }
+                            }
+
+                            return Ok((false, false));
                         }
-                    }
-
-                    return Ok((false, false));
-                }
 
-                let le = tcx.specializes((impl_def_id, possible_sibling));
-                let ge = tcx.specializes((possible_sibling, impl_def_id));
+                        let le = tcx.specializes((impl_def_id, possible_sibling));
+                        let ge = tcx.specializes((possible_sibling, impl_def_id));
 
-                if le == ge { report_overlap_error(overlap, last_lint_mut) } else { Ok((le, ge)) }
-            })?;
+                        if le == ge { Err(create_overlap_error(overlap)) } else { Ok((le, ge)) }
+                    })?;
 
             if le && !ge {
                 debug!(