languages/rust
languages/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-09-15 22:50:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Mucho debug instrumentation.

Browse source
This commit is contained in:
Felix S. Klock II 2015-03-28 09:52:47 +01:00
parent b0fd67b3e7
commit aa1398176e
2 changed files with 91 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

124
src/librustc/middle/mem_categorization.rs
View file

@ -295,23 +295,29 @@ fn node_method_origin(&self, method_call: ty::MethodCall)
impl MutabilityCategory {
pub fn from_mutbl(m: ast::Mutability) -> MutabilityCategory {
match m {
let ret = match m {
MutImmutable => McImmutable,
MutMutable => McDeclared
}
};
debug!("MutabilityCategory::{}({:?}) => {:?}",
"from_mutbl", m, ret);
ret
}
pub fn from_borrow_kind(borrow_kind: ty::BorrowKind) -> MutabilityCategory {
match borrow_kind {
let ret = match borrow_kind {
ty::ImmBorrow => McImmutable,
ty::UniqueImmBorrow => McImmutable,
ty::MutBorrow => McDeclared,
}
};
debug!("MutabilityCategory::{}({:?}) => {:?}",
"from_borrow_kind", borrow_kind, ret);
ret
}
pub fn from_pointer_kind(base_mutbl: MutabilityCategory,
ptr: PointerKind) -> MutabilityCategory {
match ptr {
let ret = match ptr {
Unique => {
base_mutbl.inherit()
}
@ -321,11 +327,14 @@ pub fn from_pointer_kind(base_mutbl: MutabilityCategory,
UnsafePtr(m) => {
MutabilityCategory::from_mutbl(m)
}
}
};
debug!("MutabilityCategory::{}({:?}, {:?}) => {:?}",
"from_pointer_kind", base_mutbl, ptr, ret);
ret
}
fn from_local(tcx: &ty::ctxt, id: ast::NodeId) -> MutabilityCategory {
match tcx.map.get(id) {
let ret = match tcx.map.get(id) {
ast_map::NodeLocal(p) | ast_map::NodeArg(p) => match p.node {
ast::PatIdent(bind_mode, _, _) => {
if bind_mode == ast::BindByValue(ast::MutMutable) {
@ -337,30 +346,39 @@ fn from_local(tcx: &ty::ctxt, id: ast::NodeId) -> MutabilityCategory {
_ => tcx.sess.span_bug(p.span, "expected identifier pattern")
},
_ => tcx.sess.span_bug(tcx.map.span(id), "expected identifier pattern")
}
};
debug!("MutabilityCategory::{}(tcx, id={:?}) => {:?}",
"from_local", id, ret);
ret
}
pub fn inherit(&self) -> MutabilityCategory {
match *self {
let ret = match *self {
McImmutable => McImmutable,
McDeclared => McInherited,
McInherited => McInherited,
}
};
debug!("{:?}.inherit() => {:?}", self, ret);
ret
}
pub fn is_mutable(&self) -> bool {
match *self {
let ret = match *self {
McImmutable => false,
McInherited => true,
McDeclared => true,
}
};
debug!("{:?}.is_mutable() => {:?}", self, ret);
ret
}
pub fn is_immutable(&self) -> bool {
match *self {
let ret = match *self {
McImmutable => true,
McDeclared | McInherited => false
}
};
debug!("{:?}.is_immutable() => {:?}", self, ret);
ret
}
pub fn to_user_str(&self) -> &'static str {
@ -733,7 +751,9 @@ fn cat_upvar(&self,
}
};
Ok(Rc::new(cmt_result))
let ret = Rc::new(cmt_result);
debug!("cat_upvar ret={}", ret.repr(self.tcx()));
Ok(ret)
}
fn env_deref(&self,
@ -794,14 +814,18 @@ fn env_deref(&self,
McDeclared | McInherited => { }
}
cmt_ {
let ret = cmt_ {
id: id,
span: span,
cat: cat_deref(Rc::new(cmt_result), 0, env_ptr),
mutbl: deref_mutbl,
ty: var_ty,
note: NoteClosureEnv(upvar_id)
}
};
debug!("env_deref ret {}", ret.repr(self.tcx()));
ret
}
pub fn cat_rvalue_node(&self,
@ -831,7 +855,9 @@ pub fn cat_rvalue_node(&self,
}
}
};
self.cat_rvalue(id, span, re, expr_ty)
let ret = self.cat_rvalue(id, span, re, expr_ty);
debug!("cat_rvalue_node ret {}", ret.repr(self.tcx()));
ret
}
pub fn cat_rvalue(&self,
@ -839,14 +865,16 @@ pub fn cat_rvalue(&self,
span: Span,
temp_scope: ty::Region,
expr_ty: Ty<'tcx>) -> cmt<'tcx> {
Rc::new(cmt_ {
let ret = Rc::new(cmt_ {
id:cmt_id,
span:span,
cat:cat_rvalue(temp_scope),
mutbl:McDeclared,
ty:expr_ty,
note: NoteNone
})
});
debug!("cat_rvalue ret {}", ret.repr(self.tcx()));
ret
}
pub fn cat_field<N:ast_node>(&self,
@ -855,14 +883,16 @@ pub fn cat_field<N:ast_node>(&self,
f_name: ast::Name,
f_ty: Ty<'tcx>)
-> cmt<'tcx> {
Rc::new(cmt_ {
let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_interior(base_cmt, InteriorField(NamedField(f_name))),
ty: f_ty,
note: NoteNone
})
});
debug!("cat_field ret {}", ret.repr(self.tcx()));
ret
}
pub fn cat_tup_field<N:ast_node>(&self,
@ -871,14 +901,16 @@ pub fn cat_tup_field<N:ast_node>(&self,
f_idx: uint,
f_ty: Ty<'tcx>)
-> cmt<'tcx> {
Rc::new(cmt_ {
let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_interior(base_cmt, InteriorField(PositionalField(f_idx))),
ty: f_ty,
note: NoteNone
})
});
debug!("cat_tup_field ret {}", ret.repr(self.tcx()));
ret
}
fn cat_deref<N:ast_node>(&self,
@ -913,10 +945,14 @@ fn cat_deref<N:ast_node>(&self,
};
let base_cmt_ty = base_cmt.ty;
match ty::deref(base_cmt_ty, true) {
Some(mt) => self.cat_deref_common(node, base_cmt, deref_cnt,
Some(mt) => {
let ret = self.cat_deref_common(node, base_cmt, deref_cnt,
mt.ty,
deref_context,
/* implicit: */ false),
/* implicit: */ false);
debug!("cat_deref ret {}", ret.repr(self.tcx()));
ret
}
None => {
debug!("Explicit deref of non-derefable type: {}",
base_cmt_ty.repr(self.tcx()));
@ -954,14 +990,16 @@ fn cat_deref_common<N:ast_node>(&self,
(base_cmt.mutbl.inherit(), cat_interior(base_cmt, interior))
}
};
Ok(Rc::new(cmt_ {
let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
cat: cat,
mutbl: m,
ty: deref_ty,
note: NoteNone
}))
});
debug!("cat_deref_common ret {}", ret.repr(self.tcx()));
Ok(ret)
}
pub fn cat_index<N:ast_node>(&self,
@ -1009,8 +1047,10 @@ pub fn cat_index<N:ast_node>(&self,
};
let m = base_cmt.mutbl.inherit();
return Ok(interior(elt, base_cmt.clone(), base_cmt.ty,
m, context, element_ty));
let ret = interior(elt, base_cmt.clone(), base_cmt.ty,
m, context, element_ty);
debug!("cat_index ret {}", ret.repr(self.tcx()));
return Ok(ret);
fn interior<'tcx, N: ast_node>(elt: &N,
of_cmt: cmt<'tcx>,
@ -1039,14 +1079,14 @@ fn deref_vec<N:ast_node>(&self,
context: InteriorOffsetKind)
-> McResult<cmt<'tcx>>
{
match try!(deref_kind(base_cmt.ty, Some(context))) {
let ret = match try!(deref_kind(base_cmt.ty, Some(context))) {
deref_ptr(ptr) => {
// for unique ptrs, we inherit mutability from the
// owning reference.
let m = MutabilityCategory::from_pointer_kind(base_cmt.mutbl, ptr);
// the deref is explicit in the resulting cmt
Ok(Rc::new(cmt_ {
Rc::new(cmt_ {
id:elt.id(),
span:elt.span(),
cat:cat_deref(base_cmt.clone(), 0, ptr),
@ -1056,13 +1096,15 @@ fn deref_vec<N:ast_node>(&self,
None => self.tcx().sess.bug("Found non-derefable type")
},
note: NoteNone
}))
})
}
deref_interior(_) => {
Ok(base_cmt)
base_cmt
}
}
};
debug!("deref_vec ret {}", ret.repr(self.tcx()));
Ok(ret)
}
/// Given a pattern P like: `[_, ..Q, _]`, where `vec_cmt` is the cmt for `P`, `slice_pat` is
@ -1112,14 +1154,16 @@ pub fn cat_imm_interior<N:ast_node>(&self,
interior_ty: Ty<'tcx>,
interior: InteriorKind)
-> cmt<'tcx> {
Rc::new(cmt_ {
let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_interior(base_cmt, interior),
ty: interior_ty,
note: NoteNone
})
});
debug!("cat_imm_interior ret={}", ret.repr(self.tcx()));
ret
}
pub fn cat_downcast<N:ast_node>(&self,
@ -1128,14 +1172,16 @@ pub fn cat_downcast<N:ast_node>(&self,
downcast_ty: Ty<'tcx>,
variant_did: ast::DefId)
-> cmt<'tcx> {
Rc::new(cmt_ {
let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_downcast(base_cmt, variant_did),
ty: downcast_ty,
note: NoteNone
})
});
debug!("cat_downcast ret={}", ret.repr(self.tcx()));
ret
}
pub fn cat_pattern<F>(&self, cmt: cmt<'tcx>, pat: &ast::Pat, mut op: F) -> McResult<()>

10
src/librustc_borrowck/borrowck/gather_loans/mod.rs
View file

@ -151,10 +151,11 @@ fn mutate(&mut self,
assignee_cmt: mc::cmt<'tcx>,
mode: euv::MutateMode)
{
debug!("mutate(assignment_id={}, assignee_cmt={})",
assignment_id, assignee_cmt.repr(self.tcx()));
let opt_lp = opt_loan_path(&assignee_cmt);
debug!("mutate(assignment_id={}, assignee_cmt={}) opt_lp={:?}",
assignment_id, assignee_cmt.repr(self.tcx()), opt_lp);
match opt_loan_path(&assignee_cmt) {
match opt_lp {
Some(lp) => {
gather_moves::gather_assignment(self.bccx, &self.move_data,
assignment_id, assignment_span,
@ -376,7 +377,8 @@ fn check_mutability<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
req_kind: ty::BorrowKind)
-> Result<(),()> {
//! Implements the M-* rules in README.md.
debug!("check_mutability(cause={:?} cmt={} req_kind={:?}",
cause, cmt.repr(bccx.tcx), req_kind);
match req_kind {
ty::UniqueImmBorrow | ty::ImmBorrow => {
match cmt.mutbl {