Fiddle param env through to try_eval_bits in most places

Author: oli-obk

src/librustc/infer/combine.rs

@@ -340,6 +340,7 @@ impl<'infcx, 'tcx> CombineFields<'infcx, 'tcx> {
             ambient_variance,
             needs_wf: false,
             root_ty: ty,
+            param_env: self.param_env,
         };
 
         let ty = match generalize.relate(&ty, &ty) {
@@ -379,6 +380,8 @@ struct Generalizer<'cx, 'tcx> {
 
     /// The root type that we are generalizing. Used when reporting cycles.
     root_ty: Ty<'tcx>,
+
+    param_env: ty::ParamEnv<'tcx>,
 }
 
 /// Result from a generalization operation. This includes
@@ -419,6 +422,7 @@ impl TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
     fn tcx(&self) -> TyCtxt<'tcx> {
         self.infcx.tcx
     }
+    fn param_env(&self) -> ty::ParamEnv<'tcx> { self.param_env }
 
     fn tag(&self) -> &'static str {
         "Generalizer"

src/librustc/infer/equate.rs

@@ -30,6 +30,8 @@ impl TypeRelation<'tcx> for Equate<'combine, 'infcx, 'tcx> {
 
     fn tcx(&self) -> TyCtxt<'tcx> { self.fields.tcx() }
 
+    fn param_env(&self) -> ty::ParamEnv<'tcx> { self.fields.param_env }
+
     fn a_is_expected(&self) -> bool { self.a_is_expected }
 
     fn relate_item_substs(&mut self,

src/librustc/infer/glb.rs

@@ -27,6 +27,8 @@ impl TypeRelation<'tcx> for Glb<'combine, 'infcx, 'tcx> {
 
     fn tcx(&self) -> TyCtxt<'tcx> { self.fields.tcx() }
 
+    fn param_env(&self) -> ty::ParamEnv<'tcx> { self.fields.param_env }
+
     fn a_is_expected(&self) -> bool { self.a_is_expected }
 
     fn relate_with_variance<T: Relate<'tcx>>(&mut self,

src/librustc/infer/lub.rs

@@ -27,6 +27,8 @@ impl TypeRelation<'tcx> for Lub<'combine, 'infcx, 'tcx> {
 
     fn tcx(&self) -> TyCtxt<'tcx> { self.fields.tcx() }
 
+    fn param_env(&self) -> ty::ParamEnv<'tcx> { self.fields.param_env }
+
     fn a_is_expected(&self) -> bool { self.a_is_expected }
 
     fn relate_with_variance<T: Relate<'tcx>>(&mut self,

src/librustc/infer/nll_relate/mod.rs

@@ -502,6 +502,9 @@ where
         self.infcx.tcx
     }
 
+    // FIXME(oli-obk): not sure how to get the correct ParamEnv
+    fn param_env(&self) -> ty::ParamEnv<'tcx> { ty::ParamEnv::empty() }
+
     fn tag(&self) -> &'static str {
         "nll::subtype"
     }
@@ -831,6 +834,9 @@ where
         self.infcx.tcx
     }
 
+    // FIXME(oli-obk): not sure how to get the correct ParamEnv
+    fn param_env(&self) -> ty::ParamEnv<'tcx> { ty::ParamEnv::empty() }
+
     fn tag(&self) -> &'static str {
         "nll::generalizer"
     }

src/librustc/infer/outlives/env.rs

@@ -27,7 +27,7 @@ use crate::ty::{self, Ty};
 /// interested in the `OutlivesEnvironment`. -nmatsakis
 #[derive(Clone)]
 pub struct OutlivesEnvironment<'tcx> {
-    param_env: ty::ParamEnv<'tcx>,
+    pub param_env: ty::ParamEnv<'tcx>,
     free_region_map: FreeRegionMap<'tcx>,
 
     // Contains, for each body B that we are checking (that is, the fn

src/librustc/infer/sub.rs

@@ -35,6 +35,9 @@ impl<'combine, 'infcx, 'tcx> Sub<'combine, 'infcx, 'tcx> {
 impl TypeRelation<'tcx> for Sub<'combine, 'infcx, 'tcx> {
     fn tag(&self) -> &'static str { "Sub" }
     fn tcx(&self) -> TyCtxt<'tcx> { self.fields.infcx.tcx }
+
+    fn param_env(&self) -> ty::ParamEnv<'tcx> { self.fields.param_env }
+
     fn a_is_expected(&self) -> bool { self.a_is_expected }
 
     fn with_cause<F,R>(&mut self, cause: Cause, f: F) -> R

src/librustc/middle/expr_use_visitor.rs

@@ -277,6 +277,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
     ) -> Self {
         ExprUseVisitor {
             mc: mc::MemCategorizationContext::new(tcx,
+                                                  param_env,
                                                   body_owner,
                                                   region_scope_tree,
                                                   tables,
@@ -299,6 +300,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
         ExprUseVisitor {
             mc: mc::MemCategorizationContext::with_infer(
                 infcx,
+                param_env,
                 body_owner,
                 region_scope_tree,
                 tables,

src/librustc/middle/mem_categorization.rs

@@ -214,6 +214,7 @@ impl HirNode for hir::Pat {
 #[derive(Clone)]
 pub struct MemCategorizationContext<'a, 'tcx> {
     pub tcx: TyCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
     pub body_owner: DefId,
     pub upvars: Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>>,
     pub region_scope_tree: &'a region::ScopeTree,
@@ -330,6 +331,7 @@ impl MutabilityCategory {
 impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
     pub fn new(
         tcx: TyCtxt<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
         body_owner: DefId,
         region_scope_tree: &'a region::ScopeTree,
         tables: &'a ty::TypeckTables<'tcx>,
@@ -342,7 +344,8 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
             region_scope_tree,
             tables,
             rvalue_promotable_map,
-            infcx: None
+            infcx: None,
+            param_env,
         }
     }
 }
@@ -359,6 +362,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
     ///   known, the results around upvar accesses may be incorrect.
     pub fn with_infer(
         infcx: &'a InferCtxt<'a, 'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
         body_owner: DefId,
         region_scope_tree: &'a region::ScopeTree,
         tables: &'a ty::TypeckTables<'tcx>,
@@ -379,6 +383,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
             tables,
             rvalue_promotable_map,
             infcx: Some(infcx),
+            param_env,
         }
     }
 
@@ -896,7 +901,7 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
 
         // Always promote `[T; 0]` (even when e.g., borrowed mutably).
         let promotable = match expr_ty.sty {
-            ty::Array(_, len) if len.try_eval_usize(self.tcx) == Some(0) => true,
+            ty::Array(_, len) if len.try_eval_usize(self.tcx, self.param_env) == Some(0) => true,
             _ => promotable,
         };
 

src/librustc/mir/tcx.rs

@@ -57,7 +57,7 @@ impl<'tcx> PlaceTy<'tcx> {
     /// `PlaceElem`, where we can just use the `Ty` that is already
     /// stored inline on field projection elems.
     pub fn projection_ty(self, tcx: TyCtxt<'tcx>, elem: &PlaceElem<'tcx>) -> PlaceTy<'tcx> {
-        self.projection_ty_core(tcx, elem, |_, _, ty| ty)
+        self.projection_ty_core(tcx, ty::ParamEnv::empty(), elem, |_, _, ty| ty)
     }
 
     /// `place_ty.projection_ty_core(tcx, elem, |...| { ... })`
@@ -68,6 +68,7 @@ impl<'tcx> PlaceTy<'tcx> {
     pub fn projection_ty_core<V, T>(
         self,
         tcx: TyCtxt<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
         elem: &ProjectionElem<V, T>,
         mut handle_field: impl FnMut(&Self, &Field, &T) -> Ty<'tcx>,
     ) -> PlaceTy<'tcx>
@@ -90,7 +91,7 @@ impl<'tcx> PlaceTy<'tcx> {
             ProjectionElem::Subslice { from, to } => {
                 PlaceTy::from_ty(match self.ty.sty {
                     ty::Array(inner, size) => {
-                        let size = size.eval_usize(tcx);
+                        let size = size.eval_usize(tcx, param_env);
                         let len = size - (from as u64) - (to as u64);
                         tcx.mk_array(inner, len)
                     }