Stabilize the re_rebalance_coherence feature

Author: ohadravid

src/doc/unstable-book/src/language-features/re-rebalance-coherence.md

@@ -367,118 +367,52 @@ fn orphan_check_trait_ref<'tcx>(
              trait_ref);
     }
 
-    if tcx.features().re_rebalance_coherence {
-        // Given impl<P1..=Pn> Trait<T1..=Tn> for T0, an impl is valid only
-        // if at least one of the following is true:
-        //
-        // - Trait is a local trait
-        // (already checked in orphan_check prior to calling this function)
-        // - All of
-        //     - At least one of the types T0..=Tn must be a local type.
-        //      Let Ti be the first such type.
-        //     - No uncovered type parameters P1..=Pn may appear in T0..Ti (excluding Ti)
-        //
-        fn uncover_fundamental_ty<'tcx>(
-            tcx: TyCtxt<'tcx>,
-            ty: Ty<'tcx>,
-            in_crate: InCrate,
-        ) -> Vec<Ty<'tcx>> {
-            if fundamental_ty(ty) && ty_is_non_local(tcx, ty, in_crate).is_some() {
-                ty.walk_shallow().flat_map(|ty| uncover_fundamental_ty(tcx, ty, in_crate)).collect()
-            } else {
-                vec![ty]
-            }
+    // Given impl<P1..=Pn> Trait<T1..=Tn> for T0, an impl is valid only
+    // if at least one of the following is true:
+    //
+    // - Trait is a local trait
+    // (already checked in orphan_check prior to calling this function)
+    // - All of
+    //     - At least one of the types T0..=Tn must be a local type.
+    //      Let Ti be the first such type.
+    //     - No uncovered type parameters P1..=Pn may appear in T0..Ti (excluding Ti)
+    //
+    fn uncover_fundamental_ty<'tcx>(
+        tcx: TyCtxt<'tcx>,
+        ty: Ty<'tcx>,
+        in_crate: InCrate,
+    ) -> Vec<Ty<'tcx>> {
+        if fundamental_ty(ty) && ty_is_non_local(tcx, ty, in_crate).is_some() {
+            ty.walk_shallow().flat_map(|ty| uncover_fundamental_ty(tcx, ty, in_crate)).collect()
+        } else {
+            vec![ty]
         }
+    }
 
-        let mut non_local_spans = vec![];
-        for (i, input_ty) in trait_ref
-            .input_types()
-            .flat_map(|ty| uncover_fundamental_ty(tcx, ty, in_crate))
-            .enumerate()
-        {
-            debug!("orphan_check_trait_ref: check ty `{:?}`", input_ty);
-            let non_local_tys = ty_is_non_local(tcx, input_ty, in_crate);
-            if non_local_tys.is_none() {
-                debug!("orphan_check_trait_ref: ty_is_local `{:?}`", input_ty);
-                return Ok(());
-            } else if let ty::Param(_) = input_ty.kind {
-                debug!("orphan_check_trait_ref: uncovered ty: `{:?}`", input_ty);
-                return Err(OrphanCheckErr::UncoveredTy(input_ty))
-            }
-            if let Some(non_local_tys) = non_local_tys {
-                for input_ty in non_local_tys {
-                    non_local_spans.push((input_ty, i == 0));
-                }
-            }
+    let mut non_local_spans = vec![];
+    for (i, input_ty) in trait_ref
+        .input_types()
+        .flat_map(|ty| uncover_fundamental_ty(tcx, ty, in_crate))
+        .enumerate()
+    {
+        debug!("orphan_check_trait_ref: check ty `{:?}`", input_ty);
+        let non_local_tys = ty_is_non_local(tcx, input_ty, in_crate);
+        if non_local_tys.is_none() {
+            debug!("orphan_check_trait_ref: ty_is_local `{:?}`", input_ty);
+            return Ok(());
+        } else if let ty::Param(_) = input_ty.kind {
+            debug!("orphan_check_trait_ref: uncovered ty: `{:?}`", input_ty);
+            return Err(OrphanCheckErr::UncoveredTy(input_ty))
         }
-        // If we exit above loop, never found a local type.
-        debug!("orphan_check_trait_ref: no local type");
-        Err(OrphanCheckErr::NonLocalInputType(non_local_spans))
-    } else {
-        let mut non_local_spans = vec![];
-        // First, create an ordered iterator over all the type
-        // parameters to the trait, with the self type appearing
-        // first.  Find the first input type that either references a
-        // type parameter OR some local type.
-        for (i, input_ty) in trait_ref.input_types().enumerate() {
-            let non_local_tys = ty_is_non_local(tcx, input_ty, in_crate);
-            if non_local_tys.is_none() {
-                debug!("orphan_check_trait_ref: ty_is_local `{:?}`", input_ty);
-
-                // First local input type. Check that there are no
-                // uncovered type parameters.
-                let uncovered_tys = uncovered_tys(tcx, input_ty, in_crate);
-                for uncovered_ty in uncovered_tys {
-                    if let Some(param) = uncovered_ty.walk()
-                        .find(|t| is_possibly_remote_type(t, in_crate))
-                    {
-                        debug!("orphan_check_trait_ref: uncovered type `{:?}`", param);
-                        return Err(OrphanCheckErr::UncoveredTy(param));
-                    }
-                }
-
-                // OK, found local type, all prior types upheld invariant.
-                return Ok(());
-            }
-
-            // Otherwise, enforce invariant that there are no type
-            // parameters reachable.
-            if let Some(param) = input_ty.walk()
-                .find(|t| is_possibly_remote_type(t, in_crate))
-            {
-                debug!("orphan_check_trait_ref: uncovered type `{:?}`", param);
-                return Err(OrphanCheckErr::UncoveredTy(param));
-            }
-
-            if let Some(non_local_tys) = non_local_tys {
-                for input_ty in non_local_tys {
-                    non_local_spans.push((input_ty, i == 0));
-                }
+        if let Some(non_local_tys) = non_local_tys {
+            for input_ty in non_local_tys {
+                non_local_spans.push((input_ty, i == 0));
             }
         }
-        // If we exit above loop, never found a local type.
-        debug!("orphan_check_trait_ref: no local type");
-        Err(OrphanCheckErr::NonLocalInputType(non_local_spans))
-    }
-}
-
-fn uncovered_tys<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, in_crate: InCrate) -> Vec<Ty<'tcx>> {
-    if ty_is_non_local_constructor(tcx, ty, in_crate).is_none() {
-        vec![]
-    } else if fundamental_ty(ty) {
-        ty.walk_shallow()
-          .flat_map(|t| uncovered_tys(tcx, t, in_crate))
-          .collect()
-    } else {
-        vec![ty]
-    }
-}
-
-fn is_possibly_remote_type(ty: Ty<'_>, _in_crate: InCrate) -> bool {
-    match ty.kind {
-        ty::Projection(..) | ty::Param(..) => true,
-        _ => false,
     }
+    // If we exit above loop, never found a local type.
+    debug!("orphan_check_trait_ref: no local type");
+    Err(OrphanCheckErr::NonLocalInputType(non_local_spans))
 }
 
 fn ty_is_non_local<'t>(tcx: TyCtxt<'t>, ty: Ty<'t>, in_crate: InCrate) -> Option<Vec<Ty<'t>>> {

src/librustc/traits/coherence.rs

@@ -253,6 +253,9 @@ declare_features! (
     (accepted, const_constructor, "1.40.0", Some(61456), None),
     /// Allows the use of `#[cfg(doctest)]`, set when rustdoc is collecting doctests.
     (accepted, cfg_doctest, "1.40.0", Some(62210), None),
+    /// Allows relaxing the coherence rules such that
+    /// `impl<T> ForeignTrait<LocalType> for ForeignType<T>` is permitted.
+    (accepted, re_rebalance_coherence, "1.40.0", Some(55437), None),
 
     // -------------------------------------------------------------------------
     // feature-group-end: accepted features

src/libsyntax/feature_gate/accepted.rs

@@ -469,10 +469,6 @@ declare_features! (
     /// Allows exhaustive integer pattern matching on `usize` and `isize`.
     (active, precise_pointer_size_matching, "1.32.0", Some(56354), None),
 
-    /// Allows relaxing the coherence rules such that
-    /// `impl<T> ForeignTrait<LocalType> for ForeignType<T>` is permitted.
-    (active, re_rebalance_coherence, "1.32.0", Some(55437), None),
-
     /// Allows using `#[ffi_returns_twice]` on foreign functions.
     (active, ffi_returns_twice, "1.34.0", Some(58314), None),
 

src/libsyntax/feature_gate/active.rs

@@ -1,13 +1,9 @@
 // aux-build:coherence_lib.rs
-// revisions: old re
-
-#![cfg_attr(re, feature(re_rebalance_coherence))]
 
 extern crate coherence_lib as lib;
 use lib::Remote1;
 
 impl<T> Remote1<T> for isize { }
-//[old]~^ ERROR E0210
-//[re]~^^ ERROR E0210
+//~^ ERROR E0210
 
 fn main() { }

src/test/ui/coherence/coherence-all-remote.re.stderr

@@ -1,5 +1,5 @@
 error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
-  --> $DIR/coherence-all-remote.rs:9:6
+  --> $DIR/coherence-all-remote.rs:6:6
    |
 LL | impl<T> Remote1<T> for isize { }
    |      ^ type parameter `T` must be used as the type parameter for some local type

src/test/ui/coherence/coherence-all-remote.rs

@@ -1,8 +1,5 @@
 // run-pass
 // aux-build:coherence_lib.rs
-// revisions: old re
-
-#![cfg_attr(re, feature(re_rebalance_coherence))]
 
 // pretty-expanded FIXME #23616
 

src/test/ui/coherence/coherence-all-remote.old.stderr renamed to src/test/ui/coherence/coherence-all-remote.stderr

@@ -1,15 +1,11 @@
 // aux-build:coherence_lib.rs
-// revisions: old re
-
-#![cfg_attr(re, feature(re_rebalance_coherence))]
 
 extern crate coherence_lib as lib;
 use lib::Remote1;
 
 pub struct BigInt;
 
 impl<T> Remote1<BigInt> for T { }
-//[old]~^ ERROR type parameter `T` must be used as the type parameter for some local type
-//[re]~^^ ERROR E0210
+//~^ ERROR E0210
 
 fn main() { }