Make ExprUseVisitor<..> use inherited parameter environments.

Author: nikomatsakis

src/librustc/middle/check_match.rs

@@ -1065,7 +1065,7 @@ fn check_for_mutation_in_guard<'a, 'tcx>(cx: &'a MatchCheckCtxt<'a, 'tcx>,
     };
     let mut visitor = ExprUseVisitor::new(&mut checker,
                                           checker.cx.tcx,
-                                          cx.param_env.clone());
+                                          &cx.param_env);
     visitor.walk_expr(guard);
 }
 

src/librustc/middle/check_rvalues.rs

@@ -40,7 +40,7 @@ impl<'a, 'tcx, 'v> visit::Visitor<'v> for RvalueContext<'a, 'tcx> {
                 fn_id: ast::NodeId) {
         {
             let param_env = ParameterEnvironment::for_item(self.tcx, fn_id);
-            let mut euv = euv::ExprUseVisitor::new(self, self.tcx, param_env);
+            let mut euv = euv::ExprUseVisitor::new(self, self.tcx, &param_env);
             euv.walk_fn(fd, b);
         }
         visit::walk_fn(self, fk, fd, b, s)

src/librustc/middle/check_static.rs

@@ -71,7 +71,7 @@ pub fn check_crate(tcx: &ty::ctxt) {
     };
     {
         let param_env = ty::empty_parameter_environment();
-        let visitor = euv::ExprUseVisitor::new(&mut checker, tcx, param_env);
+        let visitor = euv::ExprUseVisitor::new(&mut checker, tcx, &param_env);
         visit::walk_crate(&mut GlobalVisitor(visitor), tcx.map.krate());
     }
     visit::walk_crate(&mut CheckStaticVisitor {

src/librustc/middle/expr_use_visitor.rs

@@ -295,11 +295,11 @@ impl OverloadedCallType {
 // supplies types from the tree. After type checking is complete, you
 // can just use the tcx as the typer.
 
-pub struct ExprUseVisitor<'d,'t,'tcx,TYPER:'t> {
+pub struct ExprUseVisitor<'d,'t,'tcx:'t,TYPER:'t> {
     typer: &'t TYPER,
     mc: mc::MemCategorizationContext<'t,TYPER>,
     delegate: &'d mut (Delegate<'tcx>+'d),
-    param_env: ParameterEnvironment<'tcx>,
+    param_env: &'t ParameterEnvironment<'tcx>,
 }
 
 /// Whether the elements of an overloaded operation are passed by value or by reference
@@ -311,7 +311,7 @@ enum PassArgs {
 impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
     pub fn new(delegate: &'d mut Delegate<'tcx>,
                typer: &'t TYPER,
-               param_env: ParameterEnvironment<'tcx>)
+               param_env: &'t ParameterEnvironment<'tcx>)
                -> ExprUseVisitor<'d,'t,'tcx,TYPER> {
         ExprUseVisitor {
             typer: typer,
@@ -355,7 +355,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                         cmt: mc::cmt<'tcx>) {
         let mode = copy_or_move(self.tcx(),
                                 cmt.ty,
-                                &self.param_env,
+                                self.param_env,
                                 DirectRefMove);
         self.delegate.consume(consume_id, consume_span, cmt, mode);
     }
@@ -991,7 +991,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                     ast::PatIdent(ast::BindByValue(_), _, _) => {
                         match copy_or_move(tcx,
                                            cmt_pat.ty,
-                                           &self.param_env,
+                                           self.param_env,
                                            PatBindingMove) {
                             Copy => mode.lub(CopyingMatch),
                             Move(_) => mode.lub(MovingMatch),
@@ -1021,8 +1021,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
         let typer = self.typer;
         let def_map = &self.typer.tcx().def_map;
         let delegate = &mut self.delegate;
-        let param_env = &mut self.param_env;
-
+        let param_env = self.param_env;
         mc.cat_pattern(cmt_discr.clone(), pat, |mc, cmt_pat, pat| {
             if pat_util::pat_is_binding(def_map, pat) {
                 let tcx = typer.tcx();
@@ -1242,7 +1241,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                                                 closure_expr.span,
                                                 freevar.def);
             let mode = copy_or_move(self.tcx(), cmt_var.ty,
-                                    &self.param_env, CaptureMove);
+                                    self.param_env, CaptureMove);
             self.delegate.consume(closure_expr.id, freevar.span, cmt_var, mode);
         }
     }

src/librustc_borrowck/borrowck/check_loans.rs

@@ -210,7 +210,7 @@ pub fn check_loans<'a, 'b, 'c, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
     {
         let mut euv = euv::ExprUseVisitor::new(&mut clcx,
                                                bccx.tcx,
-                                               param_env.clone());
+                                               &param_env);
         euv.walk_fn(decl, body);
     }
 }

src/librustc_borrowck/borrowck/gather_loans/mod.rs

@@ -53,7 +53,7 @@ pub fn gather_loans_in_fn<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
     {
         let mut euv = euv::ExprUseVisitor::new(&mut glcx,
                                                bccx.tcx,
-                                               param_env);
+                                               &param_env);
         euv.walk_fn(decl, body);
     }
 

src/librustc_trans/trans/_match.rs

@@ -1261,7 +1261,7 @@ fn is_discr_reassigned(bcx: Block, discr: &ast::Expr, body: &ast::Expr) -> bool
     };
     {
         let param_env = ty::empty_parameter_environment();
-        let mut visitor = euv::ExprUseVisitor::new(&mut rc, bcx, param_env);
+        let mut visitor = euv::ExprUseVisitor::new(&mut rc, bcx, &param_env);
         visitor.walk_expr(body);
     }
     rc.reassigned