Make ReScope values opaque when exporting to crate metadata.

Author: michaelwoerister

src/librustc/ich/impls_ty.rs

@@ -68,6 +68,9 @@ for ty::RegionKind {
             ty::ReScope(code_extent) => {
                 code_extent.hash_stable(hcx, hasher);
             }
+            ty::ReScopeAnon(ref fingerprint) => {
+                fingerprint.hash_stable(hcx, hasher);
+            }
             ty::ReFree(ref free_region) => {
                 free_region.hash_stable(hcx, hasher);
             }

src/librustc/infer/combine.rs

@@ -453,6 +453,7 @@ impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, '
             ty::ReEmpty |
             ty::ReStatic |
             ty::ReScope(..) |
+            ty::ReScopeAnon(..) |
             ty::ReVar(..) |
             ty::ReEarlyBound(..) |
             ty::ReFree(..) => {

src/librustc/infer/error_reporting/mod.rs

@@ -244,6 +244,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             ty::ReSkolemized(..) |
             ty::ReVar(_) |
             ty::ReLateBound(..) |
+            ty::ReScopeAnon(..) |
             ty::ReErased => {
                 (format!("lifetime {:?}", region), None)
             }

src/librustc/infer/freshen.rs

@@ -94,6 +94,7 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for TypeFreshener<'a, 'gcx, 'tcx> {
             ty::ReEarlyBound(..) |
             ty::ReFree(_) |
             ty::ReScope(_) |
+            ty::ReScopeAnon(_) |
             ty::ReVar(_) |
             ty::ReSkolemized(..) |
             ty::ReEmpty |

src/librustc/infer/region_inference/mod.rs

@@ -26,7 +26,7 @@ use middle::free_region::RegionRelations;
 use ty::{self, Ty, TyCtxt};
 use ty::{Region, RegionVid};
 use ty::{ReEmpty, ReStatic, ReFree, ReEarlyBound, ReErased};
-use ty::{ReLateBound, ReScope, ReVar, ReSkolemized, BrFresh};
+use ty::{ReLateBound, ReScope, ReScopeAnon, ReVar, ReSkolemized, BrFresh};
 
 use std::cell::{Cell, RefCell};
 use std::fmt;
@@ -905,6 +905,8 @@ impl<'a, 'gcx, 'tcx> RegionVarBindings<'a, 'gcx, 'tcx> {
         match (a, b) {
             (&ReLateBound(..), _) |
             (_, &ReLateBound(..)) |
+            (&ReScopeAnon(..), _) |
+            (_, &ReScopeAnon(..)) |
             (&ReErased, _) |
             (_, &ReErased) => {
                 bug!("cannot relate region: LUB({:?}, {:?})", a, b);

src/librustc/ty/fold.rs

@@ -654,3 +654,49 @@ impl<'tcx> TypeVisitor<'tcx> for LateBoundRegionsCollector {
         false
     }
 }
+
+///////////////////////////////////////////////////////////////////////////
+// ReScope Anonymizer
+
+impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
+
+    /// Transforms RegionKind::ReScope values into equivalent
+    /// RegionKind::ReScopeAnon values. This should be done before exporting to
+    /// crate metadata (as long as we can't use erase_regions() on everything
+    /// that is exported).
+    pub fn anonymize_scope_regions<T>(self, value: &T) -> T
+        where T : TypeFoldable<'tcx>
+    {
+        use rustc_data_structures::stable_hasher::{StableHasher, HashStable};
+        use ich::{StableHashingContext, Fingerprint};
+
+        let hcx = StableHashingContext::new(self);
+
+        return value.fold_with(&mut AnonReScopes {
+            tcx: self,
+            hcx,
+        });
+
+        struct AnonReScopes<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
+            tcx: TyCtxt<'a, 'gcx, 'tcx>,
+            hcx: StableHashingContext<'a, 'gcx, 'tcx>,
+        }
+
+        impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for AnonReScopes<'a, 'gcx, 'tcx> {
+
+            fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.tcx }
+
+            fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
+                match *r {
+                    ty::ReScope(code_extent) => {
+                        let mut hasher = StableHasher::new();
+                        code_extent.hash_stable(&mut self.hcx, &mut hasher);
+                        let code_extent_fingerprint: Fingerprint = hasher.finish();
+                        self.tcx.mk_region(ty::ReScopeAnon(code_extent_fingerprint))
+                    },
+                    _ => r,
+                }
+            }
+        }
+    }
+}

src/librustc/ty/sty.rs

@@ -29,6 +29,7 @@ use util::nodemap::FxHashMap;
 use serialize;
 
 use hir;
+use ich;
 
 use self::InferTy::*;
 use self::TypeVariants::*;
@@ -785,6 +786,13 @@ pub enum RegionKind {
     /// current function.
     ReScope(region::CodeExtent),
 
+    /// The same as ReScope but with the CodeExtent transformed into a opaque,
+    /// stable representation. Any ReScope that gets exported to crate metadata
+    /// should be transformed into such a ReScopeAnon in order to avoid mixing
+    /// NodeIds from different crates. Note that ReScopeAnon values can still
+    /// safely be hashed and compared for equality.
+    ReScopeAnon(ich::Fingerprint),
+
     /// Static data that has an "infinite" lifetime. Top in the region lattice.
     ReStatic,
 

src/librustc/ty/util.rs

@@ -753,6 +753,7 @@ impl<'a, 'gcx, 'tcx, W> TypeVisitor<'tcx> for TypeIdHasher<'a, 'gcx, 'tcx, W>
             ty::ReLateBound(..) |
             ty::ReFree(..) |
             ty::ReScope(..) |
+            ty::ReScopeAnon(..) |
             ty::ReVar(..) |
             ty::ReSkolemized(..) => {
                 bug!("TypeIdHasher: unexpected region {:?}", r)

src/librustc/util/ppaux.rs

@@ -481,6 +481,10 @@ impl fmt::Debug for ty::RegionKind {
                 write!(f, "ReScope({:?})", id)
             }
 
+            ty::ReScopeAnon(fingerprint) => {
+                write!(f, "ReScopeAnon({:?})", fingerprint)
+            }
+
             ty::ReStatic => write!(f, "ReStatic"),
 
             ty::ReVar(ref vid) => {
@@ -543,6 +547,7 @@ impl fmt::Display for ty::RegionKind {
                 write!(f, "'{}rv", region_vid.index)
             }
             ty::ReScope(_) |
+            ty::ReScopeAnon(_) |
             ty::ReVar(_) |
             ty::ReErased => Ok(()),
             ty::ReStatic => write!(f, "'static"),

src/librustc_borrowck/borrowck/gather_loans/mod.rs

@@ -367,6 +367,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
                     ty::ReLateBound(..) |
                     ty::ReVar(..) |
                     ty::ReSkolemized(..) |
+                    ty::ReScopeAnon(..) |
                     ty::ReErased => {
                         span_bug!(
                             cmt.span,