Add a fast path for computing if a type should be in the local interner

Author: Zoxc

src/librustc/ty/context.rs

@@ -2267,17 +2267,23 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     }
 
     pub fn mk_ty(&self, st: TypeVariants<'tcx>) -> Ty<'tcx> {
-        let flags = super::flags::FlagComputation::for_sty(&st);
+        let keep_in_local_tcx = super::flags::sty_in_local_arena(&st);
 
         // HACK(eddyb) Depend on flags being accurate to
         // determine that all contents are in the global tcx.
         // See comments on Lift for why we can't use that.
-        if flags.flags.intersects(ty::TypeFlags::KEEP_IN_LOCAL_TCX) {
+        if keep_in_local_tcx {
             let mut interner = self.interners.type_.borrow_mut();
             if let Some(&Interned(ty)) = interner.get(&st) {
                 return ty;
             }
 
+            let flags = super::flags::FlagComputation::for_sty(&st);
+
+            assert_eq!(
+                flags.flags.intersects(ty::TypeFlags::KEEP_IN_LOCAL_TCX),
+                true);
+
             let ty_struct = TyS {
                 sty: st,
                 flags: flags.flags,
@@ -2302,6 +2308,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                 return ty;
             }
 
+            let flags = super::flags::FlagComputation::for_sty(&st);
+
+            assert_eq!(
+                flags.flags.intersects(ty::TypeFlags::KEEP_IN_LOCAL_TCX),
+                false);
+
             let ty_struct = TyS {
                 sty: st,
                 flags: flags.flags,

src/librustc/ty/flags.rs

@@ -250,3 +250,160 @@ impl FlagComputation {
         }
     }
 }
+
+pub(crate) fn sty_in_local_arena(st: &ty::TypeVariants) -> bool {
+    match *st {
+        ty::TyBool |
+        ty::TyChar |
+        ty::TyInt(_) |
+        ty::TyFloat(_) |
+        ty::TyUint(_) |
+        ty::TyNever |
+        ty::TyStr |
+        ty::TyForeign(..) |
+        ty::TyError |
+        ty::TyParam(..) => false,
+
+        ty::TyGenerator(_, ref substs, ref interior) => {
+            substs_in_local_arena(&substs.substs) ||
+            ty_in_local_arena(interior.witness)
+        }
+
+        ty::TyGeneratorWitness(ref ts) => {
+            tys_in_local_arena(&ts.skip_binder()[..])
+        }
+
+        ty::TyClosure(_, ref substs) => {
+            substs_in_local_arena(&substs.substs)
+        }
+
+        ty::TyInfer(infer) => {
+            match infer {
+                ty::FreshTy(_) |
+                ty::FreshIntTy(_) |
+                ty::FreshFloatTy(_) |
+                ty::CanonicalTy(_) => false,
+                ty::TyVar(_) |
+                ty::IntVar(_) |
+                ty::FloatVar(_) => true
+            }
+        }
+
+        ty::TyAdt(_, substs) => {
+            substs_in_local_arena(substs)
+        }
+
+        ty::TyProjection(ref data) => {
+            substs_in_local_arena(data.substs)
+        }
+
+        ty::TyAnon(_, substs) => {
+            substs_in_local_arena(substs)
+        }
+
+        ty::TyDynamic(ref obj, r) => {
+            for predicate in obj.skip_binder().iter() {
+                match *predicate {
+                    ty::ExistentialPredicate::Trait(tr) => {
+                        if substs_in_local_arena(tr.substs) {
+                            return true;
+                        }
+                    }
+                    ty::ExistentialPredicate::Projection(p) => {
+                        if substs_in_local_arena(p.substs) || ty_in_local_arena(p.ty) {
+                            return true;
+                        }
+                    }
+                    ty::ExistentialPredicate::AutoTrait(_) => {}
+                }
+            }
+            region_in_local_arena(r)
+        }
+
+        ty::TyArray(tt, len) => {
+            ty_in_local_arena(tt) ||
+            const_in_local_arena(len)
+        }
+
+        ty::TySlice(tt) => {
+            ty_in_local_arena(tt)
+        }
+
+        ty::TyRawPtr(ref m) => {
+            ty_in_local_arena(m.ty)
+        }
+
+        ty::TyRef(r, ref m) => {
+            region_in_local_arena(r) ||
+            ty_in_local_arena(m.ty)
+        }
+
+        ty::TyTuple(ref ts) => {
+            tys_in_local_arena(&ts[..])
+        }
+
+        ty::TyFnDef(_, substs) => {
+            substs_in_local_arena(substs)
+        }
+
+        ty::TyFnPtr(f) => {
+            tys_in_local_arena(f.skip_binder().inputs()) ||
+            ty_in_local_arena(f.skip_binder().output())
+        }
+    }
+}
+
+#[inline(always)]
+fn ty_in_local_arena(ty: Ty) -> bool {
+    ty.flags.intersects(ty::TypeFlags::KEEP_IN_LOCAL_TCX)
+}
+
+fn tys_in_local_arena(tys: &[Ty]) -> bool {
+    for &ty in tys {
+        if ty_in_local_arena(ty) {
+            return true;
+        }
+    }
+    false
+}
+
+fn region_in_local_arena(r: ty::Region) -> bool {
+    match *r {
+        ty::ReVar(..) | ty::ReSkolemized(..) => true,
+        ty::ReLateBound(..) |
+        ty::ReEarlyBound(..) |
+        ty::ReEmpty |
+        ty::ReStatic |
+        ty::ReFree { .. } |
+        ty::ReScope { .. } |
+        ty::ReErased |
+        ty::ReCanonical(..) |
+        ty::ReClosureBound(..) => false
+    }
+}
+
+#[inline(always)]
+fn const_in_local_arena(constant: &ty::Const) -> bool {
+    if ty_in_local_arena(constant.ty) {
+        return true;
+    }
+    match constant.val {
+        ConstVal::Value(_) => false,
+        ConstVal::Unevaluated(_, substs) => substs_in_local_arena(substs),
+    }
+}
+
+fn substs_in_local_arena(substs: &Substs) -> bool {
+    for ty in substs.types() {
+        if ty_in_local_arena(ty) {
+            return true;
+        }
+    }
+
+    for r in substs.regions() {
+        if region_in_local_arena(r) {
+            return true;
+        }
+    }
+    false
+}