remove the coherence_leak_check lint

Author: lcnr

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::{ErrorGuaranteed, Symbol};
-use rustc_trait_selection::traits::{self, SkipLeakCheck};
+use rustc_trait_selection::traits;
 use smallvec::SmallVec;
 use std::collections::hash_map::Entry;
 
@@ -145,15 +145,8 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
         impl1_def_id: DefId,
         impl2_def_id: DefId,
     ) -> Result<(), ErrorGuaranteed> {
-        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)

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(),

compiler/rustc_infer/src/infer/mod.rs

@@ -258,12 +258,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.
@@ -611,7 +605,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,
@@ -629,7 +622,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(),
         }
@@ -663,11 +655,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
@@ -693,15 +680,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(),

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(());
         }
 

compiler/rustc_lint/src/lib.rs

@@ -416,6 +416,11 @@ 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 issue #119820 \
+         <https://github.com/rust-lang/rust/issues/119820> for more information",
+    );
     store.register_removed(
         "resolve_trait_on_defaulted_unit",
         "converted into hard error, see issue #48950 \

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.
     ///

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -14,7 +14,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,
@@ -85,12 +84,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
@@ -115,27 +113,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)
 }
 
@@ -177,7 +162,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,
@@ -193,7 +177,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();
@@ -231,8 +214,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;

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -71,24 +71,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 {

compiler/rustc_trait_selection/src/traits/specialize/mod.rs

@@ -24,7 +24,6 @@ use rustc_errors::{codes::*, 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::{sym, ErrorGuaranteed, Span, DUMMY_SP};
 
@@ -460,7 +459,6 @@ fn report_conflicting_impls<'tcx>(
         Some(kind) => {
             let lint = match kind {
                 FutureCompatOverlapErrorKind::Issue33140 => ORDER_DEPENDENT_TRAIT_OBJECTS,
-                FutureCompatOverlapErrorKind::LeakCheck => COHERENCE_LEAK_CHECK,
             };
             tcx.node_span_lint(
                 lint,