From 250ae7923f9b41d826463d21a8187f1b5f0592ab Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Thu, 10 Apr 2014 16:43:26 +0300 Subject: [PATCH] rustc: make MemCategorizationContext immutable. --- .../middle/borrowck/gather_loans/mod.rs | 7 +-- src/librustc/middle/borrowck/mod.rs | 8 +-- src/librustc/middle/mem_categorization.rs | 58 +++++++++---------- src/librustc/middle/typeck/check/regionck.rs | 53 +++++++++-------- 4 files changed, 60 insertions(+), 66 deletions(-) diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs index b496ea1f15b..e4178cee144 100644 --- a/src/librustc/middle/borrowck/gather_loans/mod.rs +++ b/src/librustc/middle/borrowck/gather_loans/mod.rs @@ -381,8 +381,7 @@ impl<'a> GatherLoanCtxt<'a> { Some(method) => { // Treat overloaded autoderefs as if an AutoRef adjustment // was applied on the base type, as that is always the case. - let mut mc = self.bccx.mc(); - let cmt = match mc.cat_expr_autoderefd(expr, i) { + let cmt = match self.bccx.mc().cat_expr_autoderefd(expr, i) { Ok(v) => v, Err(()) => self.tcx().sess.span_bug(expr.span, "Err from mc") }; @@ -431,7 +430,7 @@ impl<'a> GatherLoanCtxt<'a> { autoref: Some(ref autoref), autoderefs}) => { self.guarantee_autoderefs(expr, autoderefs); - let mut mc = self.bccx.mc(); + let mc = self.bccx.mc(); let cmt = match mc.cat_expr_autoderefd(expr, autoderefs) { Ok(v) => v, Err(()) => self.tcx().sess.span_bug(expr.span, "Err from mc") @@ -793,7 +792,7 @@ impl<'a> GatherLoanCtxt<'a> { * `gather_pat()`. */ - let mut mc = self.bccx.mc(); + let mc = self.bccx.mc(); for arg in decl.inputs.iter() { let arg_ty = ty::node_id_to_type(self.tcx(), arg.pat.id); diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index a2de2e67fc8..0a040eb4e23 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -910,7 +910,7 @@ impl<'a> mc::Typer for &'a ty::ctxt { *self } - fn node_ty(&mut self, id: ast::NodeId) -> mc::McResult { + fn node_ty(&self, id: ast::NodeId) -> mc::McResult { Ok(ty::node_id_to_type(*self, id)) } @@ -922,15 +922,15 @@ impl<'a> mc::Typer for &'a ty::ctxt { &self.adjustments } - fn is_method_call(&mut self, id: ast::NodeId) -> bool { + fn is_method_call(&self, id: ast::NodeId) -> bool { self.method_map.borrow().contains_key(&typeck::MethodCall::expr(id)) } - fn temporary_scope(&mut self, id: ast::NodeId) -> Option { + fn temporary_scope(&self, id: ast::NodeId) -> Option { self.region_maps.temporary_scope(id) } - fn upvar_borrow(&mut self, id: ty::UpvarId) -> ty::UpvarBorrow { + fn upvar_borrow(&self, id: ty::UpvarId) -> ty::UpvarBorrow { self.upvar_borrow_map.borrow().get_copy(&id) } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index e74b9373c1e..1a54d7d937f 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -266,12 +266,12 @@ pub type McResult = Result; */ pub trait Typer { fn tcx<'a>(&'a self) -> &'a ty::ctxt; - fn node_ty(&mut self, id: ast::NodeId) -> McResult; + fn node_ty(&self, id: ast::NodeId) -> McResult; fn node_method_ty(&self, method_call: typeck::MethodCall) -> Option; - fn is_method_call(&mut self, id: ast::NodeId) -> bool; - fn temporary_scope(&mut self, rvalue_id: ast::NodeId) -> Option; - fn upvar_borrow(&mut self, upvar_id: ty::UpvarId) -> ty::UpvarBorrow; fn adjustments<'a>(&'a self) -> &'a RefCell>; + fn is_method_call(&self, id: ast::NodeId) -> bool; + fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option; + fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> ty::UpvarBorrow; } impl MutabilityCategory { @@ -353,30 +353,26 @@ impl MemCategorizationContext { self.typer.tcx() } - fn adjustment(&mut self, id: ast::NodeId) -> Option<@ty::AutoAdjustment> { - self.typer.adjustment(id) - } - - fn expr_ty(&mut self, expr: &ast::Expr) -> McResult { + fn expr_ty(&self, expr: &ast::Expr) -> McResult { self.typer.node_ty(expr.id) } - fn expr_ty_adjusted(&mut self, expr: &ast::Expr) -> McResult { + fn expr_ty_adjusted(&self, expr: &ast::Expr) -> McResult { let unadjusted_ty = if_ok!(self.expr_ty(expr)); Ok(ty::adjust_ty(self.tcx(), expr.span, expr.id, unadjusted_ty, self.typer.adjustments().borrow().find(&expr.id), |method_call| self.typer.node_method_ty(method_call))) } - fn node_ty(&mut self, id: ast::NodeId) -> McResult { + fn node_ty(&self, id: ast::NodeId) -> McResult { self.typer.node_ty(id) } - fn pat_ty(&mut self, pat: @ast::Pat) -> McResult { + fn pat_ty(&self, pat: @ast::Pat) -> McResult { self.typer.node_ty(pat.id) } - pub fn cat_expr(&mut self, expr: &ast::Expr) -> McResult { + pub fn cat_expr(&self, expr: &ast::Expr) -> McResult { match self.typer.adjustments().borrow().find(&expr.id) { None => { // No adjustments. @@ -420,7 +416,7 @@ impl MemCategorizationContext { } } - pub fn cat_expr_autoderefd(&mut self, expr: &ast::Expr, autoderefs: uint) + pub fn cat_expr_autoderefd(&self, expr: &ast::Expr, autoderefs: uint) -> McResult { let mut cmt = if_ok!(self.cat_expr_unadjusted(expr)); for deref in range(1u, autoderefs + 1) { @@ -429,7 +425,7 @@ impl MemCategorizationContext { return Ok(cmt); } - pub fn cat_expr_unadjusted(&mut self, expr: &ast::Expr) -> McResult { + pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> McResult { debug!("cat_expr: id={} expr={}", expr.id, expr.repr(self.tcx())); let expr_ty = if_ok!(self.expr_ty(expr)); @@ -478,7 +474,7 @@ impl MemCategorizationContext { } } - pub fn cat_def(&mut self, + pub fn cat_def(&self, id: ast::NodeId, span: Span, expr_ty: ty::t, @@ -593,7 +589,7 @@ impl MemCategorizationContext { } } - fn cat_upvar(&mut self, + fn cat_upvar(&self, id: ast::NodeId, span: Span, var_id: ast::NodeId, @@ -643,7 +639,7 @@ impl MemCategorizationContext { Ok(deref_cmt) } - pub fn cat_rvalue_node(&mut self, + pub fn cat_rvalue_node(&self, id: ast::NodeId, span: Span, expr_ty: ty::t) @@ -658,7 +654,7 @@ impl MemCategorizationContext { } } - pub fn cat_rvalue(&mut self, + pub fn cat_rvalue(&self, cmt_id: ast::NodeId, span: Span, temp_scope: ty::Region, @@ -672,7 +668,7 @@ impl MemCategorizationContext { } } - pub fn cat_field(&mut self, + pub fn cat_field(&self, node: &N, base_cmt: cmt, f_name: ast::Ident, @@ -687,11 +683,11 @@ impl MemCategorizationContext { } } - pub fn cat_deref_obj(&mut self, node: &N, base_cmt: cmt) -> cmt { + pub fn cat_deref_obj(&self, node: &N, base_cmt: cmt) -> cmt { self.cat_deref_common(node, base_cmt, 0, ty::mk_nil()) } - fn cat_deref(&mut self, + fn cat_deref(&self, node: &N, base_cmt: cmt, deref_cnt: uint) @@ -723,7 +719,7 @@ impl MemCategorizationContext { } } - fn cat_deref_common(&mut self, + fn cat_deref_common(&self, node: &N, base_cmt: cmt, deref_cnt: uint, @@ -749,7 +745,7 @@ impl MemCategorizationContext { } } - pub fn cat_index(&mut self, + pub fn cat_index(&self, elt: &N, base_cmt: cmt, derefs: uint) @@ -836,7 +832,7 @@ impl MemCategorizationContext { } } - pub fn cat_slice_pattern(&mut self, + pub fn cat_slice_pattern(&self, vec_cmt: cmt, slice_pat: @ast::Pat) -> McResult<(cmt, ast::Mutability, ty::Region)> { @@ -883,7 +879,7 @@ impl MemCategorizationContext { } } - pub fn cat_imm_interior(&mut self, + pub fn cat_imm_interior(&self, node: &N, base_cmt: cmt, interior_ty: ty::t, @@ -898,7 +894,7 @@ impl MemCategorizationContext { } } - pub fn cat_downcast(&mut self, + pub fn cat_downcast(&self, node: &N, base_cmt: cmt, downcast_ty: ty::t) @@ -912,12 +908,12 @@ impl MemCategorizationContext { } } - pub fn cat_pattern(&mut self, + pub fn cat_pattern(&self, cmt: cmt, - pat: @ast::Pat, - op: |&mut MemCategorizationContext, + pat: &ast::Pat, + op: |&MemCategorizationContext, cmt, - @ast::Pat|) + &ast::Pat|) -> McResult<()> { // Here, `cmt` is the categorization for the value being // matched and pat is the pattern it is being matched against. diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index 021318431a0..50ba1421458 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -236,7 +236,7 @@ impl<'a> Rcx<'a> { } /// Try to resolve the type for the given node. - fn resolve_node_type(&mut self, id: ast::NodeId) -> ty::t { + fn resolve_node_type(&self, id: ast::NodeId) -> ty::t { let t = self.fcx.node_ty(id); self.resolve_type(t) } @@ -261,12 +261,12 @@ impl<'a> Rcx<'a> { } } -impl<'a, 'b> mc::Typer for &'a mut Rcx<'b> { +impl<'a, 'b> mc::Typer for &'a Rcx<'b> { fn tcx<'a>(&'a self) -> &'a ty::ctxt { self.fcx.tcx() } - fn node_ty(&mut self, id: ast::NodeId) -> mc::McResult { + fn node_ty(&self, id: ast::NodeId) -> mc::McResult { let t = self.resolve_node_type(id); if ty::type_is_error(t) {Err(())} else {Ok(t)} } @@ -279,15 +279,15 @@ impl<'a, 'b> mc::Typer for &'a mut Rcx<'b> { &self.fcx.inh.adjustments } - fn is_method_call(&mut self, id: ast::NodeId) -> bool { + fn is_method_call(&self, id: ast::NodeId) -> bool { self.fcx.inh.method_map.borrow().contains_key(&MethodCall::expr(id)) } - fn temporary_scope(&mut self, id: ast::NodeId) -> Option { + fn temporary_scope(&self, id: ast::NodeId) -> Option { self.tcx().region_maps.temporary_scope(id) } - fn upvar_borrow(&mut self, id: ty::UpvarId) -> ty::UpvarBorrow { + fn upvar_borrow(&self, id: ty::UpvarId) -> ty::UpvarBorrow { self.fcx.inh.upvar_borrow_map.borrow().get_copy(&id) } } @@ -870,7 +870,7 @@ fn constrain_autoderefs(rcx: &mut Rcx, method.ty.repr(rcx.tcx()))) }; { - let mut mc = mc::MemCategorizationContext { typer: &mut *rcx }; + let mc = mc::MemCategorizationContext { typer: &*rcx }; let self_cmt = ignore_err!(mc.cat_expr_autoderefd(deref_expr, i)); link_region(mc.typer, deref_expr.span, r, m, self_cmt); } @@ -1027,13 +1027,13 @@ fn link_addr_of(rcx: &mut Rcx, expr: &ast::Expr, debug!("link_addr_of(base=?)"); let cmt = { - let mut mc = mc::MemCategorizationContext { typer: &mut *rcx }; + let mc = mc::MemCategorizationContext { typer: &*rcx }; ignore_err!(mc.cat_expr(base)) }; link_region_from_node_type(rcx, expr.span, expr.id, mutability, cmt); } -fn link_local(rcx: &mut Rcx, local: &ast::Local) { +fn link_local(rcx: &Rcx, local: &ast::Local) { /*! * Computes the guarantors for any ref bindings in a `let` and * then ensures that the lifetime of the resulting pointer is @@ -1045,12 +1045,12 @@ fn link_local(rcx: &mut Rcx, local: &ast::Local) { None => { return; } Some(expr) => expr, }; - let mut mc = mc::MemCategorizationContext { typer: rcx }; + let mc = mc::MemCategorizationContext { typer: rcx }; let discr_cmt = ignore_err!(mc.cat_expr(init_expr)); - link_pattern(&mut mc, discr_cmt, local.pat); + link_pattern(mc, discr_cmt, local.pat); } -fn link_match(rcx: &mut Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { +fn link_match(rcx: &Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { /*! * Computes the guarantors for any ref bindings in a match and * then ensures that the lifetime of the resulting pointer is @@ -1058,19 +1058,19 @@ fn link_match(rcx: &mut Rcx, discr: &ast::Expr, arms: &[ast::Arm]) { */ debug!("regionck::for_match()"); - let mut mc = mc::MemCategorizationContext { typer: rcx }; + let mc = mc::MemCategorizationContext { typer: rcx }; let discr_cmt = ignore_err!(mc.cat_expr(discr)); debug!("discr_cmt={}", discr_cmt.repr(mc.typer.tcx())); for arm in arms.iter() { for &root_pat in arm.pats.iter() { - link_pattern(&mut mc, discr_cmt, root_pat); + link_pattern(mc, discr_cmt, root_pat); } } } -fn link_pattern(mc: &mut mc::MemCategorizationContext<&mut Rcx>, +fn link_pattern(mc: mc::MemCategorizationContext<&Rcx>, discr_cmt: mc::cmt, - root_pat: @ast::Pat) { + root_pat: &ast::Pat) { /*! * Link lifetimes of any ref bindings in `root_pat` to * the pointers found in the discriminant, if needed. @@ -1100,7 +1100,7 @@ fn link_pattern(mc: &mut mc::MemCategorizationContext<&mut Rcx>, }); } -fn link_autoref(rcx: &mut Rcx, +fn link_autoref(rcx: &Rcx, expr: &ast::Expr, autoderefs: uint, autoref: &ty::AutoRef) { @@ -1110,7 +1110,7 @@ fn link_autoref(rcx: &mut Rcx, */ debug!("link_autoref(autoref={:?})", autoref); - let mut mc = mc::MemCategorizationContext { typer: rcx }; + let mc = mc::MemCategorizationContext { typer: rcx }; let expr_cmt = ignore_err!(mc.cat_expr_autoderefd(expr, autoderefs)); debug!("expr_cmt={}", expr_cmt.repr(mc.typer.tcx())); @@ -1133,7 +1133,7 @@ fn link_autoref(rcx: &mut Rcx, } } -fn link_by_ref(rcx: &mut Rcx, +fn link_by_ref(rcx: &Rcx, expr: &ast::Expr, callee_scope: ast::NodeId) { /*! @@ -1145,13 +1145,13 @@ fn link_by_ref(rcx: &mut Rcx, let tcx = rcx.tcx(); debug!("link_by_ref(expr={}, callee_scope={})", expr.repr(tcx), callee_scope); - let mut mc = mc::MemCategorizationContext { typer: rcx }; + let mc = mc::MemCategorizationContext { typer: rcx }; let expr_cmt = ignore_err!(mc.cat_expr(expr)); let region_min = ty::ReScope(callee_scope); link_region(mc.typer, expr.span, region_min, ast::MutImmutable, expr_cmt); } -fn link_region_from_node_type(rcx: &mut Rcx, +fn link_region_from_node_type(rcx: &Rcx, span: Span, id: ast::NodeId, mutbl: ast::Mutability, @@ -1171,7 +1171,7 @@ fn link_region_from_node_type(rcx: &mut Rcx, } } -fn link_region(rcx: &mut Rcx, +fn link_region(rcx: &Rcx, span: Span, region_min: ty::Region, mutbl: ast::Mutability, @@ -1282,7 +1282,7 @@ fn link_region(rcx: &mut Rcx, } } -fn adjust_borrow_kind_for_assignment_lhs(rcx: &mut Rcx, +fn adjust_borrow_kind_for_assignment_lhs(rcx: &Rcx, lhs: &ast::Expr) { /*! * Adjusts the inferred borrow_kind as needed to account @@ -1290,12 +1290,12 @@ fn adjust_borrow_kind_for_assignment_lhs(rcx: &mut Rcx, * expression. */ - let mut mc = mc::MemCategorizationContext { typer: rcx }; + let mc = mc::MemCategorizationContext { typer: rcx }; let cmt = ignore_err!(mc.cat_expr(lhs)); adjust_upvar_borrow_kind_for_mut(mc.typer, cmt); } -fn adjust_upvar_borrow_kind_for_mut(rcx: &mut Rcx, +fn adjust_upvar_borrow_kind_for_mut(rcx: &Rcx, cmt: mc::cmt) { let mut cmt = cmt; loop { @@ -1350,8 +1350,7 @@ fn adjust_upvar_borrow_kind_for_mut(rcx: &mut Rcx, } } -fn adjust_upvar_borrow_kind_for_unique(rcx: &mut Rcx, - cmt: mc::cmt) { +fn adjust_upvar_borrow_kind_for_unique(rcx: &Rcx, cmt: mc::cmt) { let mut cmt = cmt; loop { debug!("adjust_upvar_borrow_kind_for_unique(cmt={})",