Add empty and erased regions

Author: matthewjasper

chalk-engine/src/slg/resolvent.rs

@@ -506,7 +506,9 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
             }
 
             (LifetimeData::Static, LifetimeData::Static)
-            | (LifetimeData::Placeholder(_), LifetimeData::Placeholder(_)) => {
+            | (LifetimeData::Placeholder(_), LifetimeData::Placeholder(_))
+            | (LifetimeData::Erased, LifetimeData::Erased)
+            | (LifetimeData::Empty(_), LifetimeData::Empty(_)) => {
                 assert_eq!(answer, pending);
                 Ok(())
             }
@@ -518,12 +520,14 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
 
             (LifetimeData::Static, _)
             | (LifetimeData::BoundVar(_), _)
-            | (LifetimeData::Placeholder(_), _) => panic!(
+            | (LifetimeData::Placeholder(_), _)
+            | (LifetimeData::Erased, _)
+            | (LifetimeData::Empty(_), _) => panic!(
                 "structural mismatch between answer `{:?}` and pending goal `{:?}`",
                 answer, pending,
             ),
 
-            (LifetimeData::Phantom(..), _) => unreachable!(),
+            (LifetimeData::Phantom(void, _), _) => match *void {},
         }
     }
 

chalk-integration/src/lowering.rs

@@ -866,6 +866,14 @@ impl LowerWithEnv for Lifetime {
                 interner,
                 chalk_ir::LifetimeData::Static,
             )),
+            Lifetime::Empty => Ok(chalk_ir::Lifetime::new(
+                interner,
+                chalk_ir::LifetimeData::Empty(chalk_ir::UniverseIndex { counter: 0 }),
+            )),
+            Lifetime::Erased => Ok(chalk_ir::Lifetime::new(
+                interner,
+                chalk_ir::LifetimeData::Erased,
+            )),
         }
     }
 }

chalk-ir/src/debug.rs

@@ -280,6 +280,9 @@ impl<I: Interner> Debug for LifetimeData<I> {
             LifetimeData::InferenceVar(var) => write!(fmt, "'{:?}", var),
             LifetimeData::Placeholder(index) => write!(fmt, "'{:?}", index),
             LifetimeData::Static => write!(fmt, "'static"),
+            LifetimeData::Empty(UniverseIndex::ROOT) => write!(fmt, "'<empty>"),
+            LifetimeData::Empty(universe) => write!(fmt, "'<empty:{:?}>", universe),
+            LifetimeData::Erased => write!(fmt, "'<erased>"),
             LifetimeData::Phantom(..) => unreachable!(),
         }
     }

chalk-ir/src/fold.rs

@@ -523,7 +523,9 @@ where
                 folder.fold_free_placeholder_lifetime(*universe, outer_binder)
             }
             LifetimeData::Static => Ok(LifetimeData::<I>::Static.intern(folder.interner())),
-            LifetimeData::Phantom(..) => unreachable!(),
+            LifetimeData::Empty(ui) => Ok(LifetimeData::<I>::Empty(*ui).intern(folder.interner())),
+            LifetimeData::Erased => Ok(LifetimeData::<I>::Erased.intern(folder.interner())),
+            LifetimeData::Phantom(void, ..) => match *void {},
         }
     }
 }

chalk-ir/src/lib.rs

@@ -1055,6 +1055,8 @@ impl<I: Interner> Lifetime<I> {
             LifetimeData::InferenceVar(_) => false,
             LifetimeData::Placeholder(_) => false,
             LifetimeData::Static => false,
+            LifetimeData::Empty(_) => false,
+            LifetimeData::Erased => false,
             LifetimeData::Phantom(..) => unreachable!(),
         }
     }
@@ -1071,6 +1073,14 @@ pub enum LifetimeData<I: Interner> {
     Placeholder(PlaceholderIndex),
     /// Static lifetime
     Static,
+    /// An empty lifetime: a lifetime shorter than any other lifetime in a
+    /// universe with a lesser or equal index. The universe only non-zero in
+    /// lexical region resolve in rustc, so chalk shouldn't ever see a non-zero
+    /// index.
+    Empty(UniverseIndex),
+    /// An erased lifetime, used by rustc to improve caching when we doesn't
+    /// care about lifetimes
+    Erased,
     /// Lifetime on phantom data.
     Phantom(Void, PhantomData<I>),
 }

chalk-ir/src/visit.rs

@@ -380,8 +380,10 @@ impl<I: Interner> SuperVisit<I> for Lifetime<I> {
             LifetimeData::Placeholder(universe) => {
                 visitor.visit_free_placeholder(*universe, outer_binder)
             }
-            LifetimeData::Static => ControlFlow::CONTINUE,
-            LifetimeData::Phantom(..) => unreachable!(),
+            LifetimeData::Static | LifetimeData::Empty(_) | LifetimeData::Erased => {
+                ControlFlow::CONTINUE
+            }
+            LifetimeData::Phantom(void, ..) => match *void {},
         }
     }
 }

chalk-parse/src/ast.rs

@@ -370,6 +370,8 @@ impl Default for Safety {
 pub enum Lifetime {
     Id { name: Identifier },
     Static,
+    Erased,
+    Empty,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -63,7 +63,7 @@ WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "fn_mut" ")" "]" => WellKnownTrait::FnMut,
      "#" "[" "lang" "(" "fn" ")" "]" => WellKnownTrait::Fn,
      "#" "[" "lang" "(" "unsize" ")" "]" => WellKnownTrait::Unsize,
-     "#" "[" "lang" "(" "unpin" ")" "]" => WellKnownTrait::Unpin, 
+     "#" "[" "lang" "(" "unpin" ")" "]" => WellKnownTrait::Unpin,
      "#" "[" "lang" "(" "coerce_unsized" ")" "]" => WellKnownTrait::CoerceUnsized,
 };
 
@@ -432,6 +432,8 @@ RawMutability: Mutability = {
 Lifetime: Lifetime = {
     <n:LifetimeId> => Lifetime::Id { name: n },
     "'static" => Lifetime::Static,
+    "'erased" => Lifetime::Erased,
+    "'empty" => Lifetime::Empty,
 };
 
 ConstWithoutId: Const = {

chalk-solve/src/display/ty.rs

@@ -240,6 +240,8 @@ impl<I: Interner> RenderAsRust<I> for LifetimeData<I> {
                 write!(f, "'_placeholder_{}_{}", ix.ui.counter, ix.idx)
             }
             LifetimeData::Static => write!(f, "'static"),
+            LifetimeData::Empty(_) => write!(f, "'<empty>"),
+            LifetimeData::Erased => write!(f, "'_"),
             // Matching the void ensures at compile time that this code is
             // unreachable
             LifetimeData::Phantom(void, _) => match *void {},

chalk-solve/src/infer/canonicalize.rs

@@ -1,6 +1,6 @@
 use crate::debug_span;
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::{Fold, Folder};
+use chalk_ir::fold::{Fold, Folder, SuperFold};
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::*;
 use std::cmp::max;
@@ -237,6 +237,21 @@ where
         }
     }
 
+    fn fold_lifetime(
+        &mut self,
+        lifetime: &Lifetime<I>,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Lifetime<I>> {
+        match *lifetime.data(self.interner) {
+            LifetimeData::Empty(ui) if ui.counter != 0 => {
+                // ReEmpty in non-root universes is only used by lexical region
+                // inference. We shouldn't see it in canonicalization.
+                panic!("Cannot canonicalize ReEmpty in non-root universe")
+            }
+            _ => lifetime.super_fold_with(self, outer_binder),
+        }
+    }
+
     fn interner(&self) -> &'i I {
         self.interner
     }