introduce new subtyping

Author: nikomatsakis

src/librustc/dep_graph/graph.rs

@@ -39,7 +39,6 @@ pub struct DepGraph {
     fingerprints: Lrc<Lock<IndexVec<DepNodeIndex, Fingerprint>>>
 }
 
-
 newtype_index!(DepNodeIndex);
 
 impl DepNodeIndex {

src/librustc/infer/higher_ranked/mod.rs

@@ -617,6 +617,18 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         debug!("leak_check: skol_map={:?}",
                skol_map);
 
+        // If the user gave `-Zno-leak-check`, then skip the leak
+        // check completely. This is wildly unsound and also not
+        // unlikely to cause an ICE or two. It is intended for use
+        // only during a transition period, in which the MIR typeck
+        // uses the "universe-style" check, and the rest of typeck
+        // uses the more conservative leak check.  Since the leak
+        // check is more conservative, we can't test the
+        // universe-style check without disabling it.
+        if self.tcx.sess.opts.debugging_opts.no_leak_check {
+            return Ok(());
+        }
+
         let new_vars = self.region_vars_confined_to_snapshot(snapshot);
         for (&skol_br, &skol) in skol_map {
             // The inputs to a skolemized variable can only

src/librustc/infer/mod.rs

@@ -377,13 +377,16 @@ pub enum NLLRegionVariableOrigin {
     // elsewhere. This origin indices we've got one of those.
     FreeRegion,
 
+    BoundRegion(ty::UniverseIndex),
+
     Existential,
 }
 
 impl NLLRegionVariableOrigin {
     pub fn is_universal(self) -> bool {
         match self {
             NLLRegionVariableOrigin::FreeRegion => true,
+            NLLRegionVariableOrigin::BoundRegion(..) => true,
             NLLRegionVariableOrigin::Existential => false,
         }
     }
@@ -1394,6 +1397,17 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     fn universe(&self) -> ty::UniverseIndex {
         self.universe.get()
     }
+
+    /// Create and return a new subunivese of the current universe;
+    /// update `self.universe` to that new subuniverse. At present,
+    /// used only in the NLL subtyping code, which uses the new
+    /// universe-based scheme instead of the more limited leak-check
+    /// scheme.
+    pub fn create_subuniverse(&self) -> ty::UniverseIndex {
+        let u = self.universe.get().subuniverse();
+        self.universe.set(u);
+        u
+    }
 }
 
 impl<'a, 'gcx, 'tcx> TypeTrace<'tcx> {

src/librustc/session/config.rs

@@ -1353,6 +1353,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
           "generate build artifacts that are compatible with linker-based LTO."),
     no_parallel_llvm: bool = (false, parse_bool, [UNTRACKED],
           "don't run LLVM in parallel (while keeping codegen-units and ThinLTO)"),
+    no_leak_check: bool = (false, parse_bool, [UNTRACKED],
+        "disables the 'leak check' for subtyping; unsound, but useful for tests"),
 }
 
 pub fn default_lib_output() -> CrateType {

src/librustc/ty/mod.rs

@@ -1481,14 +1481,27 @@ impl<'tcx> InstantiatedPredicates<'tcx> {
 /// type name in a non-zero universe is a skolemized type -- an
 /// idealized representative of "types in general" that we use for
 /// checking generic functions.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 pub struct UniverseIndex(u32);
 
 impl UniverseIndex {
     /// The root universe, where things that the user defined are
     /// visible.
     pub const ROOT: Self = UniverseIndex(0);
 
+    /// The "max universe" -- this isn't really a valid universe, but
+    /// it's useful sometimes as a "starting value" when you are
+    /// taking the minimum of a (non-empty!) set of universes.
+    pub const MAX: Self = UniverseIndex(::std::u32::MAX);
+
+    /// Creates a universe index from the given integer.  Not to be
+    /// used lightly lest you pick a bad value. But sometimes we
+    /// convert universe indicies into integers and back for various
+    /// reasons.
+    pub fn from_u32(index: u32) -> Self {
+        UniverseIndex(index)
+    }
+
     /// A "subuniverse" corresponds to being inside a `forall` quantifier.
     /// So, for example, suppose we have this type in universe `U`:
     ///
@@ -1504,6 +1517,11 @@ impl UniverseIndex {
         UniverseIndex(self.0.checked_add(1).unwrap())
     }
 
+    /// True if the names in this universe are a subset of the names in `other`.
+    pub fn is_subset_of(self, other: UniverseIndex) -> bool {
+        self.0 <= other.0
+    }
+
     pub fn as_u32(&self) -> u32 {
         self.0
     }
@@ -1513,6 +1531,12 @@ impl UniverseIndex {
     }
 }
 
+impl fmt::Debug for UniverseIndex {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "U{}", self.as_u32())
+    }
+}
+
 impl From<u32> for UniverseIndex {
     fn from(index: u32) -> Self {
         UniverseIndex(index)

src/librustc_mir/borrow_check/nll/region_infer/dump_mir.rs

@@ -13,6 +13,7 @@
 //! state of region inference. This code handles emitting the region
 //! context internal state.
 
+use rustc::infer::NLLRegionVariableOrigin;
 use std::io::{self, Write};
 use super::{OutlivesConstraint, RegionInferenceContext};
 
@@ -27,8 +28,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         writeln!(out, "| Free Region Mapping")?;
 
         for region in self.regions() {
-            if self.definitions[region].origin.is_universal() {
-                let classification = self.universal_regions
+            if let NLLRegionVariableOrigin::FreeRegion = self.definitions[region].origin {
+                let classification = self
+                    .universal_regions
                     .region_classification(region)
                     .unwrap();
                 let outlived_by = self.universal_regions.regions_outlived_by(region);
@@ -49,9 +51,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         for region in self.regions() {
             writeln!(
                 out,
-                "| {r:rw$} | {v}",
+                "| {r:rw$} | {ui:4?} | {v}",
                 r = format!("{:?}", region),
                 rw = REGION_WIDTH,
+                ui = self.region_universe(region),
                 v = self.region_value_str(region),
             )?;
         }

src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs

@@ -401,16 +401,20 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     // `elem`.
     crate fn find_sub_region_live_at(&self, fr1: RegionVid, elem: Location) -> RegionVid {
         // Find all paths
-        let (_path, r) = self
-            .find_constraint_paths_between_regions(fr1, |r| {
+        let (_path, r) =
+            self.find_constraint_paths_between_regions(fr1, |r| {
                 self.liveness_constraints.contains(r, elem)
-            })
-            .unwrap();
+            }).unwrap();
         r
     }
 
     // Finds a good span to blame for the fact that `fr1` outlives `fr2`.
-    crate fn find_outlives_blame_span(&self, mir: &Mir<'tcx>, fr1: RegionVid, fr2: RegionVid) -> Span {
+    crate fn find_outlives_blame_span(
+        &self,
+        mir: &Mir<'tcx>,
+        fr1: RegionVid,
+        fr2: RegionVid,
+    ) -> Span {
         let (_, span, _) = self.best_blame_constraint(mir, fr1, |r| r == fr2);
         span
     }