make unification infallible again

Author: aliemjay

compiler/rustc_infer/src/infer/region_constraints/leak_check.rs

@@ -98,13 +98,13 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
     }
 }
 
-struct LeakCheck<'me, 'tcx> {
+struct LeakCheck<'me, 'rcc, 'tcx> {
     tcx: TyCtxt<'tcx>,
     universe_at_start_of_snapshot: ty::UniverseIndex,
     /// Only used when reporting region errors.
     overly_polymorphic: bool,
     mini_graph: &'me MiniGraph<'tcx>,
-    rcc: &'me RegionConstraintCollector<'me, 'tcx>,
+    rcc: &'me mut RegionConstraintCollector<'rcc, 'tcx>,
 
     // Initially, for each SCC S, stores a placeholder `P` such that `S = P`
     // must hold.
@@ -127,14 +127,14 @@ struct LeakCheck<'me, 'tcx> {
     scc_universes: IndexVec<LeakCheckScc, SccUniverse<'tcx>>,
 }
 
-impl<'me, 'tcx> LeakCheck<'me, 'tcx> {
+impl<'me, 'rcc, 'tcx> LeakCheck<'me, 'rcc, 'tcx> {
     fn new(
         tcx: TyCtxt<'tcx>,
         universe_at_start_of_snapshot: ty::UniverseIndex,
         max_universe: ty::UniverseIndex,
         overly_polymorphic: bool,
         mini_graph: &'me MiniGraph<'tcx>,
-        rcc: &'me RegionConstraintCollector<'me, 'tcx>,
+        rcc: &'me mut RegionConstraintCollector<'rcc, 'tcx>,
     ) -> Self {
         let dummy_scc_universe = SccUniverse { universe: max_universe, region: None };
         Self {

compiler/rustc_infer/src/infer/region_constraints/mod.rs

@@ -13,7 +13,7 @@ use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::undo_log::UndoLogs;
 use rustc_data_structures::unify as ut;
 use rustc_index::vec::IndexVec;
-use rustc_middle::infer::unify_key::{RegionVidKey, UnifiedRegion, UniverseError};
+use rustc_middle::infer::unify_key::{RegionVidKey, UnifiedRegion};
 use rustc_middle::ty::ReStatic;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::ty::{ReLateBound, ReVar};
@@ -460,14 +460,8 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
     }
 
     /// Returns the universe for the given variable.
-    pub(super) fn var_universe(&self, vid: RegionVid) -> ty::UniverseIndex {
-        // WARN UB ahead!
-        unsafe {
-            (&mut *(self as *const Self as *mut Self))
-                .unification_table_mut()
-                .probe_value(vid)
-                .universe
-        }
+    pub(super) fn var_universe(&mut self, vid: RegionVid) -> ty::UniverseIndex {
+        self.unification_table_mut().probe_value(vid).universe
     }
 
     /// Returns the origin for the given variable.
@@ -527,20 +521,15 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
             match (sub, sup) {
                 (Region(Interned(ReVar(sub), _)), Region(Interned(ReVar(sup), _))) => {
                     debug!("make_eqregion: unifying {:?} with {:?}", sub, sup);
-                    self.unification_table_mut()
-                        .unify_var_var(*sub, *sup)
-                        .unwrap_or_else(|UniverseError| {});
+                    self.unification_table_mut().union(*sub, *sup);
                     self.any_unifications = true;
                 }
                 (Region(Interned(ReVar(vid), _)), value)
                 | (value, Region(Interned(ReVar(vid), _))) => {
                     debug!("make_eqregion: unifying {:?} with {:?}", vid, value);
-                    self.unification_table_mut()
-                        .unify_var_value(
-                            *vid,
-                            UnifiedRegion { universe: ty::UniverseIndex::MAX, value: Some(value) },
-                        )
-                        .unwrap_or_else(|UniverseError| {});
+                    let value =
+                        UnifiedRegion { universe: self.universe(value), value: Some(value) };
+                    self.unification_table_mut().union_value(*vid, value);
                     self.any_unifications = true;
                 }
                 (_, _) => {}
@@ -699,7 +688,7 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
         new_r
     }
 
-    pub fn universe(&self, region: Region<'tcx>) -> ty::UniverseIndex {
+    pub fn universe(&mut self, region: Region<'tcx>) -> ty::UniverseIndex {
         match *region {
             ty::ReStatic
             | ty::ReErased

compiler/rustc_middle/src/infer/unify_key.rs

@@ -43,30 +43,11 @@ impl<'tcx> UnifyKey for RegionVidKey<'tcx> {
     }
 }
 
-fn universe_of_universal_region(region: ty::Region<'_>) -> ty::UniverseIndex {
-    match *region {
-        ty::ReStatic | ty::ReFree(..) | ty::ReEarlyBound(..) => ty::UniverseIndex::ROOT,
-        ty::RePlaceholder(placeholder) => placeholder.universe,
-        _ => bug!("universe(): encountered region {:?}", region),
-    }
-}
-
-pub struct UniverseError;
-
 impl<'tcx> UnifyValue for UnifiedRegion<'tcx> {
-    type Error = UniverseError;
+    type Error = NoError;
 
     fn unify_values(value1: &Self, value2: &Self) -> Result<Self, Self::Error> {
-        let universe = value1.universe.min(value2.universe);
-        if [value1.value, value2.value]
-            .into_iter()
-            .flatten()
-            .any(|val| universe.cannot_name(universe_of_universal_region(val)))
-        {
-            Err(UniverseError)
-        } else {
-            Ok(Self { value: [value1.value, value2.value].into_iter().flatten().next(), universe })
-        }
+        Ok(cmp::min_by_key(*value1, *value2, |val| (val.universe, val.value.is_none())))
     }
 }
 

tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.rs

@@ -2,9 +2,6 @@
 //
 // In particular, we test this pattern in trait solving, where it is not connected
 // to any part of the source code.
-//
-// check-pass
-// Oops!
 
 use std::cell::Cell;
 
@@ -28,5 +25,5 @@ fn main() {
     //     yielding `fn(&!b u32)`, in a fresh universe U1
     //   - So we get `?a = !b` but the universe U0 assigned to `?a` cannot name `!b`.
 
-    foo::<()>();
+    foo::<()>(); //~ ERROR implementation of `Trait` is not general enough
 }

tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.stderr

@@ -0,0 +1,11 @@
+error: implementation of `Trait` is not general enough
+  --> $DIR/hrtb-exists-forall-trait-invariant.rs:28:5
+   |
+LL |     foo::<()>();
+   |     ^^^^^^^^^^^ implementation of `Trait` is not general enough
+   |
+   = note: `()` must implement `Trait<for<'b> fn(Cell<&'b u32>)>`
+   = note: ...but it actually implements `Trait<fn(Cell<&'0 u32>)>`, for some specific lifetime `'0`
+
+error: aborting due to previous error
+

tests/ui/higher-rank-trait-bounds/hrtb-just-for-static.stderr

@@ -14,6 +14,12 @@ LL | fn give_some<'a>() {
    |              -- lifetime `'a` defined here
 LL |     want_hrtb::<&'a u32>()
    |     ^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
+   |
+note: due to current limitations in the borrow checker, this implies a `'static` lifetime
+  --> $DIR/hrtb-just-for-static.rs:9:15
+   |
+LL |     where T : for<'a> Foo<&'a isize>
+   |               ^^^^^^^^^^^^^^^^^^^^^^
 
 error: implementation of `Foo` is not general enough
   --> $DIR/hrtb-just-for-static.rs:30:5