Introduce a fast-path for type_is_sized/type_moves_by_default

This seems to improve performance by the same 2-3% of my selection
fast-path.

Author: Ariel Ben-Yehuda

src/librustc/middle/check_rvalues.rs

@@ -60,7 +60,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for RvalueContextDelegate<'a, 'tcx> {
                cmt: mc::cmt<'tcx>,
                _: euv::ConsumeMode) {
         debug!("consume; cmt: {:?}; type: {}", *cmt, ty_to_string(self.tcx, cmt.ty));
-        if !ty::type_is_sized(self.param_env, span, cmt.ty) {
+        if !ty::type_is_sized(Some(self.param_env), self.tcx, span, cmt.ty) {
             span_err!(self.tcx.sess, span, E0161,
                 "cannot move a value of type {0}: the size of {0} cannot be statically determined",
                 ty_to_string(self.tcx, cmt.ty));

src/librustc/middle/intrinsicck.rs

@@ -212,7 +212,7 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> {
                 debug!("with_each_combination: space={:?}, index={}, param_ty={}",
                        space, index, param_ty.repr(self.tcx));
 
-                if !ty::type_is_sized(param_env, span, param_ty) {
+                if !ty::type_is_sized(Some(param_env), self.tcx, span, param_ty) {
                     debug!("with_each_combination: param_ty is not known to be sized");
 
                     substs.types.get_mut_slice(space)[index] = self.dummy_unsized_ty;

src/librustc/middle/ty.rs

@@ -756,16 +756,6 @@ pub struct ctxt<'tcx> {
     /// Caches the representation hints for struct definitions.
     pub repr_hint_cache: RefCell<DefIdMap<Rc<Vec<attr::ReprAttr>>>>,
 
-    /// Caches whether types are known to impl Copy. Note that type
-    /// parameters are never placed into this cache, because their
-    /// results are dependent on the parameter environment.
-    pub type_impls_copy_cache: RefCell<HashMap<Ty<'tcx>,bool>>,
-
-    /// Caches whether types are known to impl Sized. Note that type
-    /// parameters are never placed into this cache, because their
-    /// results are dependent on the parameter environment.
-    pub type_impls_sized_cache: RefCell<HashMap<Ty<'tcx>,bool>>,
-
     /// Maps Expr NodeId's to their constant qualification.
     pub const_qualif_map: RefCell<NodeMap<check_const::ConstQualif>>,
 
@@ -828,6 +818,17 @@ bitflags! {
                                   TypeFlags::HAS_SELF.bits |
                                   TypeFlags::HAS_REGIONS.bits,
 
+        // Flags representing the nominal content of a type,
+        // computed by FlagsComputetion
+        const NOMINAL_FLAGS     = TypeFlags::HAS_PARAMS.bits |
+                                  TypeFlags::HAS_SELF.bits |
+                                  TypeFlags::HAS_TY_INFER.bits |
+                                  TypeFlags::HAS_RE_INFER.bits |
+                                  TypeFlags::HAS_RE_LATE_BOUND.bits |
+                                  TypeFlags::HAS_REGIONS.bits |
+                                  TypeFlags::HAS_TY_ERR.bits |
+                                  TypeFlags::HAS_PROJECTION.bits,
+
         // Caches for type_is_sized, type_moves_by_default
         const SIZEDNESS_CACHED  = 1 << 16,
         const IS_SIZED          = 1 << 17,
@@ -2776,8 +2777,6 @@ pub fn mk_ctxt<'tcx>(s: Session,
         stability: RefCell::new(stability),
         selection_cache: traits::SelectionCache::new(),
         repr_hint_cache: RefCell::new(DefIdMap()),
-        type_impls_copy_cache: RefCell::new(HashMap::new()),
-        type_impls_sized_cache: RefCell::new(HashMap::new()),
         const_qualif_map: RefCell::new(NodeMap()),
         custom_coerce_unsized_kinds: RefCell::new(DefIdMap()),
         cast_kinds: RefCell::new(NodeMap()),
@@ -2908,7 +2907,7 @@ impl FlagComputation {
     }
 
     fn add_flags(&mut self, flags: TypeFlags) {
-        self.flags = self.flags | flags;
+        self.flags = self.flags | (flags & TypeFlags::NOMINAL_FLAGS);
     }
 
     fn add_depth(&mut self, depth: u32) {
@@ -3917,18 +3916,27 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
     }
 }
 
-fn type_impls_bound<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>,
+fn type_impls_bound<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'tcx>>,
+                             tcx: &ty::ctxt<'tcx>,
                              ty: Ty<'tcx>,
                              bound: ty::BuiltinBound,
                              span: Span)
                              -> bool
 {
-    let infcx = infer::new_infer_ctxt(param_env.tcx);
+    let pe;
+    let param_env = match param_env {
+        Some(e) => e,
+        None => {
+            pe = empty_parameter_environment(tcx);
+            &pe
+        }
+    };
+    let infcx = infer::new_infer_ctxt(tcx);
 
     let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, ty, bound, span);
 
     debug!("type_impls_bound({}, {:?}) = {:?}",
-           ty.repr(param_env.tcx),
+           ty.repr(tcx),
            bound,
            is_impld);
 
@@ -3960,7 +3968,11 @@ pub fn type_moves_by_default<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>,
         ty_vec(..) | ty_trait(..) | ty_tup(..) |
         ty_closure(..) | ty_enum(..) | ty_struct(..) |
         ty_projection(..) | ty_param(..) | ty_infer(..) | ty_err => None
-    }.unwrap_or(!type_impls_bound(param_env, ty, ty::BoundCopy, span));
+    }.unwrap_or_else(|| !type_impls_bound(Some(param_env),
+                                          param_env.tcx,
+                                          ty,
+                                          ty::BoundCopy,
+                                          span));
 
     if !type_has_params(ty) && !type_has_self(ty) {
         ty.flags.set(ty.flags.get() | if result {
@@ -3973,33 +3985,38 @@ pub fn type_moves_by_default<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>,
     result
 }
 
-pub fn type_is_sized<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>,
+#[inline]
+pub fn type_is_sized<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'tcx>>,
+                              tcx: &ty::ctxt<'tcx>,
                               span: Span,
                               ty: Ty<'tcx>)
                               -> bool
 {
     if ty.flags.get().intersects(TypeFlags::SIZEDNESS_CACHED) {
         let result = ty.flags.get().intersects(TypeFlags::IS_SIZED);
-        debug!("type_is_sized({}) = {} (cached)", ty.repr(param_env.tcx),
-               result);
         return result;
     }
 
+    type_is_sized_uncached(param_env, tcx, span, ty)
+}
+
+fn type_is_sized_uncached<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'tcx>>,
+                                   tcx: &ty::ctxt<'tcx>,
+                                   span: Span,
+                                   ty: Ty<'tcx>) -> bool {
     assert!(!ty::type_needs_infer(ty));
 
     // Fast-path for primitive types
     let result = match ty.sty {
         ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) |
         ty_uniq(..) | ty_ptr(..) | ty_rptr(..) | ty_bare_fn(..) |
-        ty_vec(_, Some(..)) | ty_tup(..) | ty_closure(..) => {
-            Some(true)
-        }
+        ty_vec(_, Some(..)) | ty_tup(..) | ty_closure(..) => Some(true),
 
         ty_str | ty_trait(..) | ty_vec(_, None) => Some(false),
 
         ty_enum(..) | ty_struct(..) | ty_projection(..) | ty_param(..) |
         ty_infer(..) | ty_err => None
-    }.unwrap_or(type_impls_bound(param_env, ty, ty::BoundSized, span));
+    }.unwrap_or_else(|| type_impls_bound(param_env, tcx, ty, ty::BoundSized, span));
 
     if !type_has_params(ty) && !type_has_self(ty) {
         ty.flags.set(ty.flags.get() | if result {
@@ -4009,8 +4026,6 @@ pub fn type_is_sized<'a,'tcx>(param_env: &ParameterEnvironment<'a,'tcx>,
         });
     }
 
-    debug!("type_is_sized({}) = {}", ty.repr(param_env.tcx),
-           result);
     result
 }
 

src/librustc_trans/trans/common.rs

@@ -118,19 +118,9 @@ pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T
     }
 }
 
-// Is the type's representation size known at compile time?
+/// Is the type's representation size known at compile time?
 pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
-    let param_env = ty::empty_parameter_environment(tcx);
-    // FIXME(#4287) This can cause errors due to polymorphic recursion,
-    // a better span should be provided, if available.
-    let err_count = tcx.sess.err_count();
-    let is_sized = ty::type_is_sized(&param_env, DUMMY_SP, ty);
-    // Those errors aren't fatal, but an incorrect result can later
-    // trip over asserts in both rustc's trans and LLVM.
-    if err_count < tcx.sess.err_count() {
-        tcx.sess.abort_if_errors();
-    }
-    is_sized
+    ty::type_is_sized(None, tcx, DUMMY_SP, ty)
 }
 
 pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {