user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rustc: use the TLS type context in Repr and UserString.

Browse source
This commit is contained in:
Eduard Burtescu 2015-06-17 01:39:06 +03:00
parent 1f70a2e370
commit a3727559c6
104 changed files with 1990 additions and 1932 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/middle/astconv_util.rs
View file

@ -63,7 +63,7 @@ pub fn ast_ty_to_prim_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ast_ty: &ast::Ty)
let def = match tcx.def_map.borrow().get(&ast_ty.id) {
None => {
tcx.sess.span_bug(ast_ty.span,
&format!("unbound path {}", path.repr(tcx)))
&format!("unbound path {}", path.repr()))
}
Some(d) => d.full_def()
};

2
src/librustc/middle/astencode.rs
View file

@ -1624,7 +1624,7 @@ fn decode_side_tables(dcx: &DecodeContext,
c::tag_table_node_type => {
let ty = val_dsr.read_ty(dcx);
debug!("inserting ty for node {}: {}",
id, ty.repr(dcx.tcx));
id, ty.repr());
dcx.tcx.node_type_insert(id, ty);
}
c::tag_table_item_subst => {

2
src/librustc/middle/check_const.rs
View file

@ -300,7 +300,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
debug!("visit_item(item={})", i.repr(self.tcx));
debug!("visit_item(item={})", i.repr());
match i.node {
ast::ItemStatic(_, ast::MutImmutable, ref expr) => {
self.check_static_type(&**expr);

6
src/librustc/middle/check_match.rs
View file

@ -210,7 +210,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) {
// We know the type is inhabited, so this must be wrong
span_err!(cx.tcx.sess, ex.span, E0002,
"non-exhaustive patterns: type {} is non-empty",
pat_ty.user_string(cx.tcx));
pat_ty.user_string());
}
// If the type *is* empty, it's vacuously exhaustive
return;
@ -243,11 +243,11 @@ fn check_for_bindings_named_the_same_as_variants(cx: &MatchCheckCtxt, pat: &Pat)
span_warn!(cx.tcx.sess, p.span, E0170,
"pattern binding `{}` is named the same as one \
of the variants of the type `{}`",
&token::get_ident(ident.node), pat_ty.user_string(cx.tcx));
&token::get_ident(ident.node), pat_ty.user_string());
fileline_help!(cx.tcx.sess, p.span,
"if you meant to match on a variant, \
consider making the path in the pattern qualified: `{}::{}`",
pat_ty.user_string(cx.tcx), &token::get_ident(ident.node));
pat_ty.user_string(), &token::get_ident(ident.node));
}
}
}

4
src/librustc/middle/check_rvalues.rs
View file

@ -59,11 +59,11 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for RvalueContextDelegate<'a, 'tcx> {
span: Span,
cmt: mc::cmt<'tcx>,
_: euv::ConsumeMode) {
debug!("consume; cmt: {:?}; type: {}", *cmt, cmt.ty.repr(self.tcx));
debug!("consume; cmt: {:?}; type: {}", *cmt, cmt.ty.repr());
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",
cmt.ty.user_string(self.tcx));
cmt.ty.user_string());
}
}

4
src/librustc/middle/const_eval.rs
View file

@ -1031,7 +1031,7 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>,
Vec::new()));
let trait_substs = tcx.mk_substs(trait_substs);
debug!("resolve_trait_associated_const: trait_substs={}",
trait_substs.repr(tcx));
trait_substs.repr());
let trait_ref = ty::Binder(ty::TraitRef { def_id: trait_id,
substs: trait_substs });
@ -1055,7 +1055,7 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>,
&format!("Encountered error `{}` when trying \
to select an implementation for \
constant trait item reference.",
e.repr(tcx)))
e.repr()))
}
};

8
src/librustc/middle/effect.rs
View file

@ -67,7 +67,7 @@ impl<'a, 'tcx> EffectCheckVisitor<'a, 'tcx> {
_ => return
};
debug!("effect: checking index with base type {}",
base_type.repr(self.tcx));
base_type.repr());
match base_type.sty {
ty::TyBox(ty) | ty::TyRef(_, ty::mt{ty, ..}) => if ty::TyStr == ty.sty {
span_err!(self.tcx.sess, e.span, E0134,
@ -143,7 +143,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
let method_call = MethodCall::expr(expr.id);
let base_type = self.tcx.method_map.borrow().get(&method_call).unwrap().ty;
debug!("effect: method call case, base type is {}",
base_type.repr(self.tcx));
base_type.repr());
if type_is_unsafe_function(base_type) {
self.require_unsafe(expr.span,
"invocation of unsafe method")
@ -152,7 +152,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
ast::ExprCall(ref base, _) => {
let base_type = ty::node_id_to_type(self.tcx, base.id);
debug!("effect: call case, base type is {}",
base_type.repr(self.tcx));
base_type.repr());
if type_is_unsafe_function(base_type) {
self.require_unsafe(expr.span, "call to unsafe function")
}
@ -160,7 +160,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EffectCheckVisitor<'a, 'tcx> {
ast::ExprUnary(ast::UnDeref, ref base) => {
let base_type = ty::node_id_to_type(self.tcx, base.id);
debug!("effect: unary case, base type is {}",
base_type.repr(self.tcx));
base_type.repr());
if let ty::TyRawPtr(_) = base_type.sty {
self.require_unsafe(expr.span, "dereference of raw pointer")
}

50
src/librustc/middle/expr_use_visitor.rs
View file

@ -363,7 +363,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
consume_span: Span,
cmt: mc::cmt<'tcx>) {
debug!("delegate_consume(consume_id={}, cmt={})",
consume_id, cmt.repr(self.tcx()));
consume_id, cmt.repr());
let mode = copy_or_move(self.typer, &cmt, DirectRefMove);
self.delegate.consume(consume_id, consume_span, cmt, mode);
@ -376,7 +376,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
}
pub fn consume_expr(&mut self, expr: &ast::Expr) {
debug!("consume_expr(expr={})", expr.repr(self.tcx()));
debug!("consume_expr(expr={})", expr.repr());
let cmt = return_if_err!(self.mc.cat_expr(expr));
self.delegate_consume(expr.id, expr.span, cmt);
@ -398,7 +398,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
bk: ty::BorrowKind,
cause: LoanCause) {
debug!("borrow_expr(expr={}, r={}, bk={})",
expr.repr(self.tcx()), r.repr(self.tcx()), bk.repr(self.tcx()));
expr.repr(), r.repr(), bk.repr());
let cmt = return_if_err!(self.mc.cat_expr(expr));
self.delegate.borrow(expr.id, expr.span, cmt, r, bk, cause);
@ -414,7 +414,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
}
pub fn walk_expr(&mut self, expr: &ast::Expr) {
debug!("walk_expr(expr={})", expr.repr(self.tcx()));
debug!("walk_expr(expr={})", expr.repr());
self.walk_adjustment(expr);
@ -619,7 +619,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
fn walk_callee(&mut self, call: &ast::Expr, callee: &ast::Expr) {
let callee_ty = return_if_err!(self.typer.expr_ty_adjusted(callee));
debug!("walk_callee: callee={} callee_ty={}",
callee.repr(self.tcx()), callee_ty.repr(self.tcx()));
callee.repr(), callee_ty.repr());
let call_scope = region::CodeExtent::from_node_id(call.id);
match callee_ty.sty {
ty::TyBareFn(..) => {
@ -637,7 +637,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
None => {
self.tcx().sess.span_bug(
callee.span,
&format!("unexpected callee type {}", callee_ty.repr(self.tcx())))
&format!("unexpected callee type {}", callee_ty.repr()))
}
};
match overloaded_call_type {
@ -811,7 +811,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
fn walk_autoderefs(&mut self,
expr: &ast::Expr,
autoderefs: usize) {
debug!("walk_autoderefs expr={} autoderefs={}", expr.repr(self.tcx()), autoderefs);
debug!("walk_autoderefs expr={} autoderefs={}", expr.repr(), autoderefs);
for i in 0..autoderefs {
let deref_id = ty::MethodCall::autoderef(expr.id, i as u32);
@ -829,7 +829,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
ty::TyRef(r, ref m) => (m.mutbl, r),
_ => self.tcx().sess.span_bug(expr.span,
&format!("bad overloaded deref type {}",
method_ty.repr(self.tcx())))
method_ty.repr()))
};
let bk = ty::BorrowKind::from_mutbl(m);
self.delegate.borrow(expr.id, expr.span, cmt,
@ -843,8 +843,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
expr: &ast::Expr,
adj: &ty::AutoDerefRef<'tcx>) {
debug!("walk_autoderefref expr={} adj={}",
expr.repr(self.tcx()),
adj.repr(self.tcx()));
expr.repr(),
adj.repr());
self.walk_autoderefs(expr, adj.autoderefs);
@ -877,7 +877,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
{
debug!("walk_autoref(expr.id={} cmt_derefd={} opt_autoref={:?})",
expr.id,
cmt_base.repr(self.tcx()),
cmt_base.repr(),
opt_autoref);
let cmt_base_ty = cmt_base.ty;
@ -903,7 +903,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
ty::AutoUnsafe(m) => {
debug!("walk_autoref: expr.id={} cmt_base={}",
expr.id,
cmt_base.repr(self.tcx()));
cmt_base.repr());
// Converting from a &T to *T (or &mut T to *mut T) is
// treated as borrowing it for the enclosing temporary
@ -1011,8 +1011,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
cmt_discr: mc::cmt<'tcx>,
pat: &ast::Pat,
mode: &mut TrackMatchMode) {
debug!("determine_pat_move_mode cmt_discr={} pat={}", cmt_discr.repr(self.tcx()),
pat.repr(self.tcx()));
debug!("determine_pat_move_mode cmt_discr={} pat={}", cmt_discr.repr(),
pat.repr());
return_if_err!(self.mc.cat_pattern(cmt_discr, pat, |_mc, cmt_pat, pat| {
let tcx = self.tcx();
let def_map = &self.tcx().def_map;
@ -1043,8 +1043,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
cmt_discr: mc::cmt<'tcx>,
pat: &ast::Pat,
match_mode: MatchMode) {
debug!("walk_pat cmt_discr={} pat={}", cmt_discr.repr(self.tcx()),
pat.repr(self.tcx()));
debug!("walk_pat cmt_discr={} pat={}", cmt_discr.repr(),
pat.repr());
let mc = &self.mc;
let typer = self.typer;
@ -1055,8 +1055,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
let tcx = typer.tcx();
debug!("binding cmt_pat={} pat={} match_mode={:?}",
cmt_pat.repr(tcx),
pat.repr(tcx),
cmt_pat.repr(),
pat.repr(),
match_mode);
// pat_ty: the type of the binding being produced.
@ -1161,8 +1161,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
};
debug!("variant downcast_cmt={} pat={}",
downcast_cmt.repr(tcx),
pat.repr(tcx));
downcast_cmt.repr(),
pat.repr());
delegate.matched_pat(pat, downcast_cmt, match_mode);
}
@ -1173,8 +1173,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
// e.g. patterns for unit structs).
debug!("struct cmt_pat={} pat={}",
cmt_pat.repr(tcx),
pat.repr(tcx));
cmt_pat.repr(),
pat.repr());
delegate.matched_pat(pat, cmt_pat, match_mode);
}
@ -1194,7 +1194,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
if !tcx.sess.has_errors() {
let msg = format!("Pattern has unexpected type: {:?} and type {}",
def,
cmt_pat.ty.repr(tcx));
cmt_pat.ty.repr());
tcx.sess.span_bug(pat.span, &msg)
}
}
@ -1211,7 +1211,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
if !tcx.sess.has_errors() {
let msg = format!("Pattern has unexpected def: {:?} and type {}",
def,
cmt_pat.ty.repr(tcx));
cmt_pat.ty.repr());
tcx.sess.span_bug(pat.span, &msg[..])
}
}
@ -1237,7 +1237,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
}
fn walk_captures(&mut self, closure_expr: &ast::Expr) {
debug!("walk_captures({})", closure_expr.repr(self.tcx()));
debug!("walk_captures({})", closure_expr.repr());
ty::with_freevars(self.tcx(), closure_expr.id, |freevars| {
for freevar in freevars {

8
src/librustc/middle/free_region.rs
View file

@ -33,7 +33,7 @@ impl FreeRegionMap {
implications: &[Implication<'tcx>])
{
for implication in implications {
debug!("implication: {}", implication.repr(tcx));
debug!("implication: {}", implication.repr());
match *implication {
Implication::RegionSubRegion(_, ty::ReFree(free_a), ty::ReFree(free_b)) => {
self.relate_free_regions(free_a, free_b);
@ -50,7 +50,7 @@ impl FreeRegionMap {
pub fn relate_free_regions_from_predicates<'tcx>(&mut self,
tcx: &ty::ctxt<'tcx>,
predicates: &[ty::Predicate<'tcx>]) {
debug!("relate_free_regions_from_predicates(predicates={})", predicates.repr(tcx));
debug!("relate_free_regions_from_predicates(predicates={})", predicates.repr());
for predicate in predicates {
match *predicate {
ty::Predicate::Projection(..) |
@ -69,8 +69,8 @@ impl FreeRegionMap {
// All named regions are instantiated with free regions.
tcx.sess.bug(
&format!("record_region_bounds: non free region: {} / {}",
r_a.repr(tcx),
r_b.repr(tcx)));
r_a.repr(),
r_b.repr()));
}
}
}

38
src/librustc/middle/implicator.rs
View file

@ -55,8 +55,8 @@ pub fn implications<'a,'tcx>(
{
debug!("implications(body_id={}, ty={}, outer_region={})",
body_id,
ty.repr(closure_typer.tcx()),
outer_region.repr(closure_typer.tcx()));
ty.repr(),
outer_region.repr());
let mut stack = Vec::new();
stack.push((outer_region, None));
@ -68,7 +68,7 @@ pub fn implications<'a,'tcx>(
out: Vec::new(),
visited: FnvHashSet() };
wf.accumulate_from_ty(ty);
debug!("implications: out={}", wf.out.repr(closure_typer.tcx()));
debug!("implications: out={}", wf.out.repr());
wf.out
}
@ -79,7 +79,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
fn accumulate_from_ty(&mut self, ty: Ty<'tcx>) {
debug!("accumulate_from_ty(ty={})",
ty.repr(self.tcx()));
ty.repr());
// When expanding out associated types, we can visit a cyclic
// set of types. Issue #23003.
@ -313,7 +313,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
data: &ty::PolyTraitPredicate<'tcx>)
{
debug!("accumulate_from_assoc_types_transitive({})",
data.repr(self.tcx()));
data.repr());
for poly_trait_ref in traits::supertraits(self.tcx(), data.to_poly_trait_ref()) {
match ty::no_late_bound_regions(self.tcx(), &poly_trait_ref) {
@ -327,7 +327,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
trait_ref: ty::TraitRef<'tcx>)
{
debug!("accumulate_from_assoc_types({})",
trait_ref.repr(self.tcx()));
trait_ref.repr());
let trait_def_id = trait_ref.def_id;
let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id);
@ -337,7 +337,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
.map(|&name| ty::mk_projection(self.tcx(), trait_ref.clone(), name))
.collect();
debug!("accumulate_from_assoc_types: assoc_type_projections={}",
assoc_type_projections.repr(self.tcx()));
assoc_type_projections.repr());
let tys = match self.fully_normalize(&assoc_type_projections) {
Ok(tys) => { tys }
Err(ErrorReported) => { return; }
@ -400,7 +400,7 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> {
}
fn fully_normalize<T>(&self, value: &T) -> Result<T,ErrorReported>
where T : TypeFoldable<'tcx> + ty::HasProjectionTypes + Clone + Repr<'tcx>
where T : TypeFoldable<'tcx> + ty::HasProjectionTypes + Clone + Repr
{
let value =
traits::fully_normalize(self.infcx,
@ -455,32 +455,32 @@ pub fn object_region_bounds<'tcx>(
ty::required_region_bounds(tcx, open_ty, predicates)
}
impl<'tcx> Repr<'tcx> for Implication<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for Implication<'tcx> {
fn repr(&self) -> String {
match *self {
Implication::RegionSubRegion(_, ref r_a, ref r_b) => {
format!("RegionSubRegion({}, {})",
r_a.repr(tcx),
r_b.repr(tcx))
r_a.repr(),
r_b.repr())
}
Implication::RegionSubGeneric(_, ref r, ref p) => {
format!("RegionSubGeneric({}, {})",
r.repr(tcx),
p.repr(tcx))
r.repr(),
p.repr())
}
Implication::RegionSubClosure(_, ref a, ref b, ref c) => {
format!("RegionSubClosure({}, {}, {})",
a.repr(tcx),
b.repr(tcx),
c.repr(tcx))
a.repr(),
b.repr(),
c.repr())
}
Implication::Predicate(ref def_id, ref p) => {
format!("Predicate({}, {})",
def_id.repr(tcx),
p.repr(tcx))
def_id.repr(),
p.repr())
}
}
}

2
src/librustc/middle/infer/bivariate.rs
View file

@ -74,7 +74,7 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Bivariate<'a, 'tcx> {
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
debug!("{}.tys({}, {})", self.tag(),
a.repr(self.fields.infcx.tcx), b.repr(self.fields.infcx.tcx));
a.repr(), b.repr());
if a == b { return Ok(a); }
let infcx = self.fields.infcx;

10
src/librustc/middle/infer/combine.rs
View file

@ -214,9 +214,9 @@ impl<'a, 'tcx> CombineFields<'a, 'tcx> {
};
debug!("instantiate(a_ty={} dir={:?} b_vid={})",
a_ty.repr(tcx),
a_ty.repr(),
dir,
b_vid.repr(tcx));
b_vid.repr());
// Check whether `vid` has been instantiated yet. If not,
// make a generalized form of `ty` and instantiate with
@ -232,8 +232,8 @@ impl<'a, 'tcx> CombineFields<'a, 'tcx> {
});
debug!("instantiate(a_ty={}, dir={:?}, \
b_vid={}, generalized_ty={})",
a_ty.repr(tcx), dir, b_vid.repr(tcx),
generalized_ty.repr(tcx));
a_ty.repr(), dir, b_vid.repr(),
generalized_ty.repr());
self.infcx.type_variables
.borrow_mut()
.instantiate_and_push(
@ -336,7 +336,7 @@ impl<'cx, 'tcx> ty_fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> {
self.tcx().sess.span_bug(
self.span,
&format!("Encountered early bound region when generalizing: {}",
r.repr(self.tcx())));
r.repr()));
}
// Always make a fresh region variable for skolemized regions;

6
src/librustc/middle/infer/equate.rs
View file

@ -46,7 +46,7 @@ impl<'a, 'tcx> TypeRelation<'a,'tcx> for Equate<'a, 'tcx> {
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
debug!("{}.tys({}, {})", self.tag(),
a.repr(self.fields.infcx.tcx), b.repr(self.fields.infcx.tcx));
a.repr(), b.repr());
if a == b { return Ok(a); }
let infcx = self.fields.infcx;
@ -77,8 +77,8 @@ impl<'a, 'tcx> TypeRelation<'a,'tcx> for Equate<'a, 'tcx> {
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
debug!("{}.regions({}, {})",
self.tag(),
a.repr(self.fields.infcx.tcx),
b.repr(self.fields.infcx.tcx));
a.repr(),
b.repr());
let origin = Subtype(self.fields.trace.clone());
self.fields.infcx.region_vars.make_eqregion(origin, a, b);
Ok(a)

24
src/librustc/middle/infer/error_reporting.rs
View file

@ -170,7 +170,7 @@ pub fn note_and_explain_region(tcx: &ty::ctxt,
ty::BrFresh(_) => "an anonymous lifetime defined on".to_owned(),
_ => {
format!("the lifetime {} as defined on",
fr.bound_region.user_string(tcx))
fr.bound_region.user_string())
}
};
@ -229,7 +229,7 @@ pub trait ErrorReporting<'tcx> {
fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<String>;
fn expected_found_str<T: UserString<'tcx> + Resolvable<'tcx>>(
fn expected_found_str<T: UserString + Resolvable<'tcx>>(
&self,
exp_found: &ty::expected_found<T>)
-> Option<String>;
@ -507,7 +507,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
}
}
fn expected_found_str<T: UserString<'tcx> + Resolvable<'tcx>>(
fn expected_found_str<T: UserString + Resolvable<'tcx>>(
&self,
exp_found: &ty::expected_found<T>)
-> Option<String>
@ -523,8 +523,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
}
Some(format!("expected `{}`, found `{}`",
expected.user_string(self.tcx),
found.user_string(self.tcx)))
expected.user_string(),
found.user_string()))
}
fn report_generic_bound_failure(&self,
@ -540,9 +540,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
let labeled_user_string = match bound_kind {
GenericKind::Param(ref p) =>
format!("the parameter type `{}`", p.user_string(self.tcx)),
format!("the parameter type `{}`", p.user_string()),
GenericKind::Projection(ref p) =>
format!("the associated type `{}`", p.user_string(self.tcx)),
format!("the associated type `{}`", p.user_string()),
};
match sub {
@ -554,8 +554,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
origin.span(),
&format!(
"consider adding an explicit lifetime bound `{}: {}`...",
bound_kind.user_string(self.tcx),
sub.user_string(self.tcx)));
bound_kind.user_string(),
sub.user_string()));
}
ty::ReStatic => {
@ -566,7 +566,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
origin.span(),
&format!(
"consider adding an explicit lifetime bound `{}: 'static`...",
bound_kind.user_string(self.tcx)));
bound_kind.user_string()));
}
_ => {
@ -578,7 +578,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
origin.span(),
&format!(
"consider adding an explicit lifetime bound for `{}`",
bound_kind.user_string(self.tcx)));
bound_kind.user_string()));
note_and_explain_region(
self.tcx,
&format!("{} must be valid for ", labeled_user_string),
@ -1561,7 +1561,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
fn report_inference_failure(&self,
var_origin: RegionVariableOrigin) {
let br_string = |br: ty::BoundRegion| {
let mut s = br.user_string(self.tcx);
let mut s = br.user_string();
if !s.is_empty() {
s.push_str(" ");
}

4
src/librustc/middle/infer/glb.rs
View file

@ -57,8 +57,8 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Glb<'a, 'tcx> {
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
debug!("{}.regions({}, {})",
self.tag(),
a.repr(self.fields.infcx.tcx),
b.repr(self.fields.infcx.tcx));
a.repr(),
b.repr());
let origin = Subtype(self.fields.trace.clone());
Ok(self.fields.infcx.region_vars.glb_regions(origin, a, b))

56
src/librustc/middle/infer/higher_ranked/mod.rs
View file

@ -49,7 +49,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
let tcx = self.infcx.tcx;
debug!("higher_ranked_sub(a={}, b={})",
a.repr(tcx), b.repr(tcx));
a.repr(), b.repr());
// Rather than checking the subtype relationship between `a` and `b`
// as-is, we need to do some extra work here in order to make sure
@ -75,8 +75,8 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
let (b_prime, skol_map) =
self.infcx.skolemize_late_bound_regions(b, snapshot);
debug!("a_prime={}", a_prime.repr(tcx));
debug!("b_prime={}", b_prime.repr(tcx));
debug!("a_prime={}", a_prime.repr());
debug!("b_prime={}", b_prime.repr());
// Compare types now that bound regions have been replaced.
let result = try!(self.sub().relate(&a_prime, &b_prime));
@ -99,7 +99,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
}
debug!("higher_ranked_sub: OK result={}",
result.repr(tcx));
result.repr());
Ok(ty::Binder(result))
});
@ -125,7 +125,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
try!(self.lub().relate(&a_with_fresh, &b_with_fresh));
let result0 =
self.infcx.resolve_type_vars_if_possible(&result0);
debug!("lub result0 = {}", result0.repr(self.tcx()));
debug!("lub result0 = {}", result0.repr());
// Generalize the regions appearing in result0 if possible
let new_vars = self.infcx.region_vars_confined_to_snapshot(snapshot);
@ -138,9 +138,9 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
&new_vars, &a_map, r));
debug!("lub({},{}) = {}",
a.repr(self.tcx()),
b.repr(self.tcx()),
result1.repr(self.tcx()));
a.repr(),
b.repr(),
result1.repr());
Ok(ty::Binder(result1))
});
@ -199,7 +199,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
where T: Relate<'a,'tcx>
{
debug!("higher_ranked_glb({}, {})",
a.repr(self.tcx()), b.repr(self.tcx()));
a.repr(), b.repr());
// Make a snapshot so we can examine "all bindings that were
// created as part of this type comparison".
@ -219,7 +219,7 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
try!(self.glb().relate(&a_with_fresh, &b_with_fresh));
let result0 =
self.infcx.resolve_type_vars_if_possible(&result0);
debug!("glb result0 = {}", result0.repr(self.tcx()));
debug!("glb result0 = {}", result0.repr());
// Generalize the regions appearing in result0 if possible
let new_vars = self.infcx.region_vars_confined_to_snapshot(snapshot);
@ -234,9 +234,9 @@ impl<'a,'tcx> HigherRankedRelations<'a,'tcx> for CombineFields<'a,'tcx> {
r));
debug!("glb({},{}) = {}",
a.repr(self.tcx()),
b.repr(self.tcx()),
result1.repr(self.tcx()));
a.repr(),
b.repr(),
result1.repr());
Ok(ty::Binder(result1))
});
@ -452,8 +452,8 @@ impl<'a,'tcx> InferCtxtExt for InferCtxt<'a,'tcx> {
});
debug!("region_vars_confined_to_snapshot: region_vars={} escaping_types={}",
region_vars.repr(self.tcx),
escaping_types.repr(self.tcx));
region_vars.repr(),
escaping_types.repr());
region_vars
}
@ -520,7 +520,7 @@ pub fn skolemize_late_bound_regions<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
binder: &ty::Binder<T>,
snapshot: &CombinedSnapshot)
-> (T, SkolemizationMap)
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
/*!
* Replace all regions bound by `binder` with skolemized regions and
@ -535,9 +535,9 @@ pub fn skolemize_late_bound_regions<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
});
debug!("skolemize_bound_regions(binder={}, result={}, map={})",
binder.repr(infcx.tcx),
result.repr(infcx.tcx),
map.repr(infcx.tcx));
binder.repr(),
result.repr(),
map.repr());
(result, map)
}
@ -556,7 +556,7 @@ pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
*/
debug!("leak_check: skol_map={}",
skol_map.repr(infcx.tcx));
skol_map.repr());
let new_vars = infcx.region_vars_confined_to_snapshot(snapshot);
for (&skol_br, &skol) in skol_map {
@ -574,9 +574,9 @@ pub fn leak_check<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
};
debug!("{} (which replaced {}) is tainted by {}",
skol.repr(infcx.tcx),
skol_br.repr(infcx.tcx),
tainted_region.repr(infcx.tcx));
skol.repr(),
skol_br.repr(),
tainted_region.repr());
// A is not as polymorphic as B:
return Err((skol_br, tainted_region));
@ -618,13 +618,13 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
snapshot: &CombinedSnapshot,
value: &T)
-> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
debug_assert!(leak_check(infcx, &skol_map, snapshot).is_ok());
debug!("plug_leaks(skol_map={}, value={})",
skol_map.repr(infcx.tcx),
value.repr(infcx.tcx));
skol_map.repr(),
value.repr());
// Compute a mapping from the "taint set" of each skolemized
// region back to the `ty::BoundRegion` that it originally
@ -641,7 +641,7 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
.collect();
debug!("plug_leaks: inv_skol_map={}",
inv_skol_map.repr(infcx.tcx));
inv_skol_map.repr());
// Remove any instantiated type variables from `value`; those can hide
// references to regions from the `fold_regions` code below.
@ -670,7 +670,7 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
});
debug!("plug_leaks: result={}",
result.repr(infcx.tcx));
result.repr());
result
}

4
src/librustc/middle/infer/lattice.rs
View file

@ -53,8 +53,8 @@ pub fn super_lattice_tys<'a,'tcx,L:LatticeDir<'a,'tcx>>(this: &mut L,
{
debug!("{}.lattice_tys({}, {})",
this.tag(),
a.repr(this.tcx()),
b.repr(this.tcx()));
a.repr(),
b.repr());
if a == b {
return Ok(a);

4
src/librustc/middle/infer/lub.rs
View file

@ -57,8 +57,8 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Lub<'a, 'tcx> {
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
debug!("{}.regions({}, {})",
self.tag(),
a.repr(self.tcx()),
b.repr(self.tcx()));
a.repr(),
b.repr());
let origin = Subtype(self.fields.trace.clone());
Ok(self.fields.infcx.region_vars.lub_regions(origin, a, b))

150
src/librustc/middle/infer/mod.rs
View file

@ -331,7 +331,7 @@ pub fn common_supertype<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
-> Ty<'tcx>
{
debug!("common_supertype({}, {})",
a.repr(cx.tcx), b.repr(cx.tcx));
a.repr(), b.repr());
let trace = TypeTrace {
origin: origin,
@ -355,7 +355,7 @@ pub fn mk_subty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
b: Ty<'tcx>)
-> UnitResult<'tcx>
{
debug!("mk_subty({} <: {})", a.repr(cx.tcx), b.repr(cx.tcx));
debug!("mk_subty({} <: {})", a.repr(), b.repr());
cx.sub_types(a_is_expected, origin, a, b)
}
@ -363,7 +363,7 @@ pub fn can_mk_subty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
a: Ty<'tcx>,
b: Ty<'tcx>)
-> UnitResult<'tcx> {
debug!("can_mk_subty({} <: {})", a.repr(cx.tcx), b.repr(cx.tcx));
debug!("can_mk_subty({} <: {})", a.repr(), b.repr());
cx.probe(|_| {
let trace = TypeTrace {
origin: Misc(codemap::DUMMY_SP),
@ -383,7 +383,7 @@ pub fn mk_subr<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
origin: SubregionOrigin<'tcx>,
a: ty::Region,
b: ty::Region) {
debug!("mk_subr({} <: {})", a.repr(cx.tcx), b.repr(cx.tcx));
debug!("mk_subr({} <: {})", a.repr(), b.repr());
let snapshot = cx.region_vars.start_snapshot();
cx.region_vars.make_subregion(origin, a, b);
cx.region_vars.commit(snapshot);
@ -396,7 +396,7 @@ pub fn mk_eqty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
b: Ty<'tcx>)
-> UnitResult<'tcx>
{
debug!("mk_eqty({} <: {})", a.repr(cx.tcx), b.repr(cx.tcx));
debug!("mk_eqty({} <: {})", a.repr(), b.repr());
cx.commit_if_ok(|_| cx.eq_types(a_is_expected, origin, a, b))
}
@ -408,7 +408,7 @@ pub fn mk_sub_poly_trait_refs<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
-> UnitResult<'tcx>
{
debug!("mk_sub_trait_refs({} <: {})",
a.repr(cx.tcx), b.repr(cx.tcx));
a.repr(), b.repr());
cx.commit_if_ok(|_| cx.sub_poly_trait_refs(a_is_expected, origin, a.clone(), b.clone()))
}
@ -637,7 +637,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
b: Ty<'tcx>)
-> UnitResult<'tcx>
{
debug!("sub_types({} <: {})", a.repr(self.tcx), b.repr(self.tcx));
debug!("sub_types({} <: {})", a.repr(), b.repr());
self.commit_if_ok(|_| {
let trace = TypeTrace::types(origin, a_is_expected, a, b);
self.sub(a_is_expected, trace).relate(&a, &b).map(|_| ())
@ -665,8 +665,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
-> UnitResult<'tcx>
{
debug!("sub_trait_refs({} <: {})",
a.repr(self.tcx),
b.repr(self.tcx));
a.repr(),
b.repr());
self.commit_if_ok(|_| {
let trace = TypeTrace {
origin: origin,
@ -684,8 +684,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
-> UnitResult<'tcx>
{
debug!("sub_poly_trait_refs({} <: {})",
a.repr(self.tcx),
b.repr(self.tcx));
a.repr(),
b.repr());
self.commit_if_ok(|_| {
let trace = TypeTrace {
origin: origin,
@ -708,7 +708,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
value: &ty::Binder<T>,
snapshot: &CombinedSnapshot)
-> (T, SkolemizationMap)
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
/*! See `higher_ranked::skolemize_late_bound_regions` */
@ -733,7 +733,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
snapshot: &CombinedSnapshot,
value: &T)
-> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
/*! See `higher_ranked::plug_leaks` */
@ -861,7 +861,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
}
pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
self.resolve_type_vars_if_possible(&t).user_string(self.tcx)
self.resolve_type_vars_if_possible(&t).user_string()
}
pub fn tys_to_string(&self, ts: &[Ty<'tcx>]) -> String {
@ -871,7 +871,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
pub fn trait_ref_to_string(&self, t: &ty::TraitRef<'tcx>) -> String {
let t = self.resolve_type_vars_if_possible(t);
t.user_string(self.tcx)
t.user_string()
}
pub fn shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx> {
@ -1033,7 +1033,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
lbrct: LateBoundRegionConversionTime,
value: &ty::Binder<T>)
-> (T, FnvHashMap<ty::BoundRegion,ty::Region>)
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
ty_fold::replace_late_bound_regions(
self.tcx,
@ -1048,17 +1048,17 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
a: ty::Region,
bs: Vec<ty::Region>) {
debug!("verify_generic_bound({}, {} <: {})",
kind.repr(self.tcx),
a.repr(self.tcx),
bs.repr(self.tcx));
kind.repr(),
a.repr(),
bs.repr());
self.region_vars.verify_generic_bound(origin, kind, a, bs);
}
pub fn can_equate<'b,T>(&'b self, a: &T, b: &T) -> UnitResult<'tcx>
where T: Relate<'b,'tcx> + Repr<'tcx>
where T: Relate<'b,'tcx> + Repr
{
debug!("can_equate({}, {})", a.repr(self.tcx), b.repr(self.tcx));
debug!("can_equate({}, {})", a.repr(), b.repr());
self.probe(|_| {
// Gin up a dummy trace, since this won't be committed
// anyhow. We should make this typetrace stuff more
@ -1099,9 +1099,9 @@ impl<'tcx> TypeTrace<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for TypeTrace<'tcx> {
fn repr(&self, tcx: &ty::ctxt) -> String {
format!("TypeTrace({})", self.origin.repr(tcx))
impl<'tcx> Repr for TypeTrace<'tcx> {
fn repr(&self) -> String {
format!("TypeTrace({})", self.origin.repr())
}
}
@ -1123,39 +1123,39 @@ impl TypeOrigin {
}
}
impl<'tcx> Repr<'tcx> for TypeOrigin {
fn repr(&self, tcx: &ty::ctxt) -> String {
impl<'tcx> Repr for TypeOrigin {
fn repr(&self) -> String {
match *self {
MethodCompatCheck(a) => {
format!("MethodCompatCheck({})", a.repr(tcx))
format!("MethodCompatCheck({})", a.repr())
}
ExprAssignable(a) => {
format!("ExprAssignable({})", a.repr(tcx))
format!("ExprAssignable({})", a.repr())
}
Misc(a) => format!("Misc({})", a.repr(tcx)),
Misc(a) => format!("Misc({})", a.repr()),
RelateTraitRefs(a) => {
format!("RelateTraitRefs({})", a.repr(tcx))
format!("RelateTraitRefs({})", a.repr())
}
RelateSelfType(a) => {
format!("RelateSelfType({})", a.repr(tcx))
format!("RelateSelfType({})", a.repr())
}
RelateOutputImplTypes(a) => {
format!("RelateOutputImplTypes({})", a.repr(tcx))
format!("RelateOutputImplTypes({})", a.repr())
}
MatchExpressionArm(a, b) => {
format!("MatchExpressionArm({}, {})", a.repr(tcx), b.repr(tcx))
format!("MatchExpressionArm({}, {})", a.repr(), b.repr())
}
IfExpression(a) => {
format!("IfExpression({})", a.repr(tcx))
format!("IfExpression({})", a.repr())
}
IfExpressionWithNoElse(a) => {
format!("IfExpressionWithNoElse({})", a.repr(tcx))
format!("IfExpressionWithNoElse({})", a.repr())
}
RangeExpression(a) => {
format!("RangeExpression({})", a.repr(tcx))
format!("RangeExpression({})", a.repr())
}
EquatePredicate(a) => {
format!("EquatePredicate({})", a.repr(tcx))
format!("EquatePredicate({})", a.repr())
}
}
}
@ -1190,66 +1190,66 @@ impl<'tcx> SubregionOrigin<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for SubregionOrigin<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for SubregionOrigin<'tcx> {
fn repr(&self) -> String {
match *self {
Subtype(ref a) => {
format!("Subtype({})", a.repr(tcx))
format!("Subtype({})", a.repr())
}
InfStackClosure(a) => {
format!("InfStackClosure({})", a.repr(tcx))
format!("InfStackClosure({})", a.repr())
}
InvokeClosure(a) => {
format!("InvokeClosure({})", a.repr(tcx))
format!("InvokeClosure({})", a.repr())
}
DerefPointer(a) => {
format!("DerefPointer({})", a.repr(tcx))
format!("DerefPointer({})", a.repr())
}
FreeVariable(a, b) => {
format!("FreeVariable({}, {})", a.repr(tcx), b)
format!("FreeVariable({}, {})", a.repr(), b)
}
IndexSlice(a) => {
format!("IndexSlice({})", a.repr(tcx))
format!("IndexSlice({})", a.repr())
}
RelateObjectBound(a) => {
format!("RelateObjectBound({})", a.repr(tcx))
format!("RelateObjectBound({})", a.repr())
}
RelateParamBound(a, b) => {
format!("RelateParamBound({},{})",
a.repr(tcx),
b.repr(tcx))
a.repr(),
b.repr())
}
RelateRegionParamBound(a) => {
format!("RelateRegionParamBound({})",
a.repr(tcx))
a.repr())
}
RelateDefaultParamBound(a, b) => {
format!("RelateDefaultParamBound({},{})",
a.repr(tcx),
b.repr(tcx))
a.repr(),
b.repr())
}
Reborrow(a) => format!("Reborrow({})", a.repr(tcx)),
Reborrow(a) => format!("Reborrow({})", a.repr()),
ReborrowUpvar(a, b) => {
format!("ReborrowUpvar({},{:?})", a.repr(tcx), b)
format!("ReborrowUpvar({},{:?})", a.repr(), b)
}
ReferenceOutlivesReferent(_, a) => {
format!("ReferenceOutlivesReferent({})", a.repr(tcx))
format!("ReferenceOutlivesReferent({})", a.repr())
}
ExprTypeIsNotInScope(a, b) => {
format!("ExprTypeIsNotInScope({}, {})",
a.repr(tcx),
b.repr(tcx))
a.repr(),
b.repr())
}
BindingTypeIsNotValidAtDecl(a) => {
format!("BindingTypeIsNotValidAtDecl({})", a.repr(tcx))
format!("BindingTypeIsNotValidAtDecl({})", a.repr())
}
CallRcvr(a) => format!("CallRcvr({})", a.repr(tcx)),
CallArg(a) => format!("CallArg({})", a.repr(tcx)),
CallReturn(a) => format!("CallReturn({})", a.repr(tcx)),
Operand(a) => format!("Operand({})", a.repr(tcx)),
AddrOf(a) => format!("AddrOf({})", a.repr(tcx)),
AutoBorrow(a) => format!("AutoBorrow({})", a.repr(tcx)),
SafeDestructor(a) => format!("SafeDestructor({})", a.repr(tcx)),
CallRcvr(a) => format!("CallRcvr({})", a.repr()),
CallArg(a) => format!("CallArg({})", a.repr()),
CallReturn(a) => format!("CallReturn({})", a.repr()),
Operand(a) => format!("Operand({})", a.repr()),
AddrOf(a) => format!("AddrOf({})", a.repr()),
AutoBorrow(a) => format!("AutoBorrow({})", a.repr()),
SafeDestructor(a) => format!("SafeDestructor({})", a.repr()),
}
}
}
@ -1270,31 +1270,31 @@ impl RegionVariableOrigin {
}
}
impl<'tcx> Repr<'tcx> for RegionVariableOrigin {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for RegionVariableOrigin {
fn repr(&self) -> String {
match *self {
MiscVariable(a) => {
format!("MiscVariable({})", a.repr(tcx))
format!("MiscVariable({})", a.repr())
}
PatternRegion(a) => {
format!("PatternRegion({})", a.repr(tcx))
format!("PatternRegion({})", a.repr())
}
AddrOfRegion(a) => {
format!("AddrOfRegion({})", a.repr(tcx))
format!("AddrOfRegion({})", a.repr())
}
Autoref(a) => format!("Autoref({})", a.repr(tcx)),
Coercion(a) => format!("Coercion({})", a.repr(tcx)),
Autoref(a) => format!("Autoref({})", a.repr()),
Coercion(a) => format!("Coercion({})", a.repr()),
EarlyBoundRegion(a, b) => {
format!("EarlyBoundRegion({},{})", a.repr(tcx), b.repr(tcx))
format!("EarlyBoundRegion({},{})", a.repr(), b.repr())
}
LateBoundRegion(a, b, c) => {
format!("LateBoundRegion({},{},{:?})", a.repr(tcx), b.repr(tcx), c)
format!("LateBoundRegion({},{},{:?})", a.repr(), b.repr(), c)
}
BoundRegionInCoherence(a) => {
format!("bound_regionInCoherence({})", a.repr(tcx))
format!("bound_regionInCoherence({})", a.repr())
}
UpvarRegion(a, b) => {
format!("UpvarRegion({}, {})", a.repr(tcx), b.repr(tcx))
format!("UpvarRegion({}, {})", a.repr(), b.repr())
}
}
}

4
src/librustc/middle/infer/region_inference/graphviz.rs
View file

@ -191,13 +191,13 @@ impl<'a, 'tcx> dot::Labeller<'a, Node, Edge> for ConstraintGraph<'a, 'tcx> {
Node::RegionVid(n_vid) =>
dot::LabelText::label(format!("{:?}", n_vid)),
Node::Region(n_rgn) =>
dot::LabelText::label(format!("{}", n_rgn.repr(self.tcx))),
dot::LabelText::label(format!("{}", n_rgn.repr())),
}
}
fn edge_label(&self, e: &Edge) -> dot::LabelText {
match *e {
Edge::Constraint(ref c) =>
dot::LabelText::label(format!("{}", self.map.get(c).unwrap().repr(self.tcx))),
dot::LabelText::label(format!("{}", self.map.get(c).unwrap().repr())),
Edge::EnclScope(..) =>
dot::LabelText::label(format!("(enclosed)")),
}

134
src/librustc/middle/infer/region_inference/mod.rs
View file

@ -324,7 +324,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
self.undo_log.borrow_mut().push(AddVar(vid));
}
debug!("created new region variable {:?} with origin {}",
vid, origin.repr(self.tcx));
vid, origin.repr());
return vid;
}
@ -392,7 +392,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
assert!(self.values_are_none());
debug!("RegionVarBindings: add_constraint({})",
constraint.repr(self.tcx));
constraint.repr());
if self.constraints.borrow_mut().insert(constraint, origin).is_none() {
if self.in_snapshot() {
@ -407,7 +407,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
assert!(self.values_are_none());
debug!("RegionVarBindings: add_verify({})",
verify.repr(self.tcx));
verify.repr());
let mut verifys = self.verifys.borrow_mut();
let index = verifys.len();
@ -426,7 +426,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
let mut givens = self.givens.borrow_mut();
if givens.insert((sub, sup)) {
debug!("add_given({} <= {:?})",
sub.repr(self.tcx),
sub.repr(),
sup);
self.undo_log.borrow_mut().push(AddGiven(sub, sup));
@ -453,9 +453,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
assert!(self.values_are_none());
debug!("RegionVarBindings: make_subregion({}, {}) due to {}",
sub.repr(self.tcx),
sup.repr(self.tcx),
origin.repr(self.tcx));
sub.repr(),
sup.repr(),
origin.repr());
match (sub, sup) {
(ReEarlyBound(..), ReEarlyBound(..)) => {
@ -472,8 +472,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
self.tcx.sess.span_bug(
origin.span(),
&format!("cannot relate bound region: {} <= {}",
sub.repr(self.tcx),
sup.repr(self.tcx)));
sub.repr(),
sup.repr()));
}
(_, ReStatic) => {
// all regions are subregions of static, so we can ignore this
@ -511,8 +511,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
assert!(self.values_are_none());
debug!("RegionVarBindings: lub_regions({}, {})",
a.repr(self.tcx),
b.repr(self.tcx));
a.repr(),
b.repr());
match (a, b) {
(ReStatic, _) | (_, ReStatic) => {
ReStatic // nothing lives longer than static
@ -536,8 +536,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
assert!(self.values_are_none());
debug!("RegionVarBindings: glb_regions({}, {})",
a.repr(self.tcx),
b.repr(self.tcx));
a.repr(),
b.repr());
match (a, b) {
(ReStatic, r) | (r, ReStatic) => {
// static lives longer than everything else
@ -563,7 +563,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
}
Some(ref values) => {
let r = lookup(values, rid);
debug!("resolve_var({:?}) = {}", rid, r.repr(self.tcx));
debug!("resolve_var({:?}) = {}", rid, r.repr());
r
}
}
@ -620,7 +620,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
/// made---`r0` itself will be the first entry. This is used when checking whether skolemized
/// regions are being improperly related to other regions.
pub fn tainted(&self, mark: &RegionSnapshot, r0: Region) -> Vec<Region> {
debug!("tainted(mark={:?}, r0={})", mark, r0.repr(self.tcx));
debug!("tainted(mark={:?}, r0={})", mark, r0.repr());
let _indenter = indenter();
// `result_set` acts as a worklist: we explore all outgoing
@ -732,8 +732,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
(_, ReEarlyBound(..)) => {
self.tcx.sess.bug(
&format!("cannot relate bound region: LUB({}, {})",
a.repr(self.tcx),
b.repr(self.tcx)));
a.repr(),
b.repr()));
}
(ReStatic, _) | (_, ReStatic) => {
@ -837,8 +837,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
(_, ReEarlyBound(..)) => {
self.tcx.sess.bug(
&format!("cannot relate bound region: GLB({}, {})",
a.repr(self.tcx),
b.repr(self.tcx)));
a.repr(),
b.repr()));
}
(ReStatic, r) | (r, ReStatic) => {
@ -1013,18 +1013,18 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
fn dump_constraints(&self) {
debug!("----() Start constraint listing ()----");
for (idx, (constraint, _)) in self.constraints.borrow().iter().enumerate() {
debug!("Constraint {} => {}", idx, constraint.repr(self.tcx));
debug!("Constraint {} => {}", idx, constraint.repr());
}
}
fn expansion(&self, free_regions: &FreeRegionMap, var_data: &mut [VarData]) {
self.iterate_until_fixed_point("Expansion", |constraint| {
debug!("expansion: constraint={} origin={}",
constraint.repr(self.tcx),
constraint.repr(),
self.constraints.borrow()
.get(constraint)
.unwrap()
.repr(self.tcx));
.repr());
match *constraint {
ConstrainRegSubVar(a_region, b_vid) => {
let b_data = &mut var_data[b_vid.index as usize];
@ -1055,9 +1055,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
-> bool
{
debug!("expand_node({}, {:?} == {})",
a_region.repr(self.tcx),
a_region.repr(),
b_vid,
b_data.value.repr(self.tcx));
b_data.value.repr());
// Check if this relationship is implied by a given.
match a_region {
@ -1074,7 +1074,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
match b_data.value {
NoValue => {
debug!("Setting initial value of {:?} to {}",
b_vid, a_region.repr(self.tcx));
b_vid, a_region.repr());
b_data.value = Value(a_region);
return true;
@ -1088,8 +1088,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
debug!("Expanding value of {:?} from {} to {}",
b_vid,
cur_region.repr(self.tcx),
lub.repr(self.tcx));
cur_region.repr(),
lub.repr());
b_data.value = Value(lub);
return true;
@ -1106,11 +1106,11 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
var_data: &mut [VarData]) {
self.iterate_until_fixed_point("Contraction", |constraint| {
debug!("contraction: constraint={} origin={}",
constraint.repr(self.tcx),
constraint.repr(),
self.constraints.borrow()
.get(constraint)
.unwrap()
.repr(self.tcx));
.repr());
match *constraint {
ConstrainRegSubVar(..) => {
// This is an expansion constraint. Ignore.
@ -1140,8 +1140,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
b_region: Region)
-> bool {
debug!("contract_node({:?} == {}/{:?}, {})",
a_vid, a_data.value.repr(self.tcx),
a_data.classification, b_region.repr(self.tcx));
a_vid, a_data.value.repr(),
a_data.classification, b_region.repr());
return match a_data.value {
NoValue => {
@ -1173,8 +1173,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
if !free_regions.is_subregion_of(this.tcx, a_region, b_region) {
debug!("Setting {:?} to ErrorValue: {} not subregion of {}",
a_vid,
a_region.repr(this.tcx),
b_region.repr(this.tcx));
a_region.repr(),
b_region.repr());
a_data.value = ErrorValue;
}
false
@ -1194,8 +1194,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
} else {
debug!("Contracting value of {:?} from {} to {}",
a_vid,
a_region.repr(this.tcx),
glb.repr(this.tcx));
a_region.repr(),
glb.repr());
a_data.value = Value(glb);
true
}
@ -1203,8 +1203,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
Err(_) => {
debug!("Setting {:?} to ErrorValue: no glb of {}, {}",
a_vid,
a_region.repr(this.tcx),
b_region.repr(this.tcx));
a_region.repr(),
b_region.repr());
a_data.value = ErrorValue;
false
}
@ -1230,8 +1230,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
}
debug!("ConcreteFailure: !(sub <= sup): sub={}, sup={}",
sub.repr(self.tcx),
sup.repr(self.tcx));
sub.repr(),
sup.repr());
errors.push(ConcreteFailure((*origin).clone(), sub, sup));
}
@ -1433,8 +1433,8 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
&format!("collect_error_for_expanding_node() could not find error \
for var {:?}, lower_bounds={}, upper_bounds={}",
node_idx,
lower_bounds.repr(self.tcx),
upper_bounds.repr(self.tcx)));
lower_bounds.repr(),
upper_bounds.repr()));
}
fn collect_error_for_contracting_node(
@ -1480,7 +1480,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
&format!("collect_error_for_contracting_node() could not find error \
for var {:?}, upper_bounds={}",
node_idx,
upper_bounds.repr(self.tcx)));
upper_bounds.repr()));
}
fn collect_concrete_regions(&self,
@ -1579,7 +1579,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
let edge_changed = body(constraint);
if edge_changed {
debug!("Updated due to constraint {}",
constraint.repr(self.tcx));
constraint.repr());
changed = true;
}
}
@ -1589,31 +1589,31 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
}
impl<'tcx> Repr<'tcx> for Constraint {
fn repr(&self, tcx: &ty::ctxt) -> String {
impl Repr for Constraint {
fn repr(&self) -> String {
match *self {
ConstrainVarSubVar(a, b) => {
format!("ConstrainVarSubVar({}, {})", a.repr(tcx), b.repr(tcx))
format!("ConstrainVarSubVar({}, {})", a.repr(), b.repr())
}
ConstrainRegSubVar(a, b) => {
format!("ConstrainRegSubVar({}, {})", a.repr(tcx), b.repr(tcx))
format!("ConstrainRegSubVar({}, {})", a.repr(), b.repr())
}
ConstrainVarSubReg(a, b) => {
format!("ConstrainVarSubReg({}, {})", a.repr(tcx), b.repr(tcx))
format!("ConstrainVarSubReg({}, {})", a.repr(), b.repr())
}
}
}
}
impl<'tcx> Repr<'tcx> for Verify<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for Verify<'tcx> {
fn repr(&self) -> String {
match *self {
VerifyRegSubReg(_, ref a, ref b) => {
format!("VerifyRegSubReg({}, {})", a.repr(tcx), b.repr(tcx))
format!("VerifyRegSubReg({}, {})", a.repr(), b.repr())
}
VerifyGenericBound(_, ref p, ref a, ref bs) => {
format!("VerifyGenericBound({}, {}, {})",
p.repr(tcx), a.repr(tcx), bs.repr(tcx))
p.repr(), a.repr(), bs.repr())
}
}
}
@ -1634,38 +1634,38 @@ fn lookup(values: &Vec<VarValue>, rid: ty::RegionVid) -> ty::Region {
}
}
impl<'tcx> Repr<'tcx> for VarValue {
fn repr(&self, tcx: &ty::ctxt) -> String {
impl Repr for VarValue {
fn repr(&self) -> String {
match *self {
NoValue => format!("NoValue"),
Value(r) => format!("Value({})", r.repr(tcx)),
Value(r) => format!("Value({})", r.repr()),
ErrorValue => format!("ErrorValue"),
}
}
}
impl<'tcx> Repr<'tcx> for RegionAndOrigin<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for RegionAndOrigin<'tcx> {
fn repr(&self) -> String {
format!("RegionAndOrigin({},{})",
self.region.repr(tcx),
self.origin.repr(tcx))
self.region.repr(),
self.origin.repr())
}
}
impl<'tcx> Repr<'tcx> for GenericKind<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for GenericKind<'tcx> {
fn repr(&self) -> String {
match *self {
GenericKind::Param(ref p) => p.repr(tcx),
GenericKind::Projection(ref p) => p.repr(tcx),
GenericKind::Param(ref p) => p.repr(),
GenericKind::Projection(ref p) => p.repr(),
}
}
}
impl<'tcx> UserString<'tcx> for GenericKind<'tcx> {
fn user_string(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> UserString for GenericKind<'tcx> {
fn user_string(&self) -> String {
match *self {
GenericKind::Param(ref p) => p.user_string(tcx),
GenericKind::Projection(ref p) => p.user_string(tcx),
GenericKind::Param(ref p) => p.user_string(),
GenericKind::Projection(ref p) => p.user_string(),
}
}
}

2
src/librustc/middle/infer/resolve.rs
View file

@ -96,7 +96,7 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
ty::TyInfer(_) => {
self.infcx.tcx.sess.bug(
&format!("Unexpected type in full type resolver: {}",
t.repr(self.infcx.tcx)));
t.repr()));
}
_ => {
ty_fold::super_fold_ty(self, t)

6
src/librustc/middle/infer/sub.rs
View file

@ -49,7 +49,7 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Sub<'a, 'tcx> {
}
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
debug!("{}.tys({}, {})", self.tag(), a.repr(self.tcx()), b.repr(self.tcx()));
debug!("{}.tys({}, {})", self.tag(), a.repr(), b.repr());
if a == b { return Ok(a); }
@ -87,8 +87,8 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Sub<'a, 'tcx> {
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
debug!("{}.regions({}, {})",
self.tag(),
a.repr(self.tcx()),
b.repr(self.tcx()));
a.repr(),
b.repr());
let origin = Subtype(self.fields.trace.clone());
self.fields.infcx.region_vars.make_subregion(origin, a, b);
Ok(a)

18
src/librustc/middle/intrinsicck.rs
View file

@ -203,14 +203,14 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> {
match types_in_scope.next() {
None => {
debug!("with_each_combination(substs={})",
substs.repr(self.tcx));
substs.repr());
callback(substs);
}
Some((space, index, &param_ty)) => {
debug!("with_each_combination: space={:?}, index={}, param_ty={}",
space, index, param_ty.repr(self.tcx));
space, index, param_ty.repr());
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");
@ -228,7 +228,7 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> {
}
fn push_transmute_restriction(&self, restriction: TransmuteRestriction<'tcx>) {
debug!("Pushing transmute restriction: {}", restriction.repr(self.tcx));
debug!("Pushing transmute restriction: {}", restriction.repr());
self.tcx.transmute_restrictions.borrow_mut().push(restriction);
}
}
@ -277,13 +277,13 @@ impl<'a, 'tcx, 'v> Visitor<'v> for IntrinsicCheckingVisitor<'a, 'tcx> {
}
}
impl<'tcx> Repr<'tcx> for TransmuteRestriction<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for TransmuteRestriction<'tcx> {
fn repr(&self) -> String {
format!("TransmuteRestriction(id={}, original=({},{}), substituted=({},{}))",
self.id,
self.original_from.repr(tcx),
self.original_to.repr(tcx),
self.substituted_from.repr(tcx),
self.substituted_to.repr(tcx))
self.original_from.repr(),
self.original_to.repr(),
self.substituted_from.repr(),
self.substituted_to.repr())
}
}

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

@ -437,7 +437,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
_ => base_ty,
};
debug!("pat_ty(pat={}) base_ty={} ret_ty={}",
pat.repr(tcx), base_ty.repr(tcx), ret_ty.repr(tcx));
pat.repr(), base_ty.repr(), ret_ty.repr());
Ok(ret_ty)
}
@ -461,8 +461,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty::AdjustUnsafeFnPointer |
ty::AdjustDerefRef(_) => {
debug!("cat_expr({}): {}",
adjustment.repr(self.tcx()),
expr.repr(self.tcx()));
adjustment.repr(),
expr.repr());
// Result is an rvalue.
let expr_ty = try!(self.expr_ty_adjusted(expr));
Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
@ -479,7 +479,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
let mut cmt = try!(self.cat_expr_unadjusted(expr));
debug!("cat_expr_autoderefd: autoderefs={}, cmt={}",
autoderefs,
cmt.repr(self.tcx()));
cmt.repr());
for deref in 1..autoderefs + 1 {
cmt = try!(self.cat_deref(expr, cmt, deref, None));
}
@ -487,7 +487,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
}
pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
debug!("cat_expr: id={} expr={}", expr.id, expr.repr(self.tcx()));
debug!("cat_expr: id={} expr={}", expr.id, expr.repr());
let expr_ty = try!(self.expr_ty(expr));
match expr.node {
@ -500,8 +500,8 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
let base_cmt = try!(self.cat_expr(&**base));
debug!("cat_expr(cat_field): id={} expr={} base={}",
expr.id,
expr.repr(self.tcx()),
base_cmt.repr(self.tcx()));
expr.repr(),
base_cmt.repr());
Ok(self.cat_field(expr, base_cmt, f_name.node.name, expr_ty))
}
@ -525,7 +525,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty::TyRef(_, mt) => mt.ty,
_ => {
debug!("cat_expr_unadjusted: return type of overloaded index is {}?",
ret_ty.repr(self.tcx()));
ret_ty.repr());
return Err(());
}
};
@ -584,7 +584,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
def: def::Def)
-> McResult<cmt<'tcx>> {
debug!("cat_def: id={} expr={} def={:?}",
id, expr_ty.repr(self.tcx()), def);
id, expr_ty.repr(), def);
match def {
def::DefStruct(..) | def::DefVariant(..) | def::DefConst(..) |
@ -637,7 +637,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
span,
&format!("Upvar of non-closure {} - {}",
fn_node_id,
ty.repr(self.tcx())));
ty.repr()));
}
}
}
@ -746,7 +746,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
};
let ret = Rc::new(cmt_result);
debug!("cat_upvar ret={}", ret.repr(self.tcx()));
debug!("cat_upvar ret={}", ret.repr());
Ok(ret)
}
@ -817,7 +817,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
note: NoteClosureEnv(upvar_id)
};
debug!("env_deref ret {}", ret.repr(self.tcx()));
debug!("env_deref ret {}", ret.repr());
ret
}
@ -855,7 +855,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty::ReStatic
};
let ret = self.cat_rvalue(id, span, re, expr_ty);
debug!("cat_rvalue_node ret {}", ret.repr(self.tcx()));
debug!("cat_rvalue_node ret {}", ret.repr());
ret
}
@ -872,7 +872,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty:expr_ty,
note: NoteNone
});
debug!("cat_rvalue ret {}", ret.repr(self.tcx()));
debug!("cat_rvalue ret {}", ret.repr());
ret
}
@ -890,7 +890,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty: f_ty,
note: NoteNone
});
debug!("cat_field ret {}", ret.repr(self.tcx()));
debug!("cat_field ret {}", ret.repr());
ret
}
@ -908,7 +908,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty: f_ty,
note: NoteNone
});
debug!("cat_tup_field ret {}", ret.repr(self.tcx()));
debug!("cat_tup_field ret {}", ret.repr());
ret
}
@ -925,7 +925,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
let method_ty = self.typer.node_method_ty(method_call);
debug!("cat_deref: method_call={:?} method_ty={:?}",
method_call, method_ty.map(|ty| ty.repr(self.tcx())));
method_call, method_ty.map(|ty| ty.repr()));
let base_cmt = match method_ty {
Some(method_ty) => {
@ -943,12 +943,12 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
mt.ty,
deref_context,
/* implicit: */ false);
debug!("cat_deref ret {}", ret.repr(self.tcx()));
debug!("cat_deref ret {}", ret.repr());
ret
}
None => {
debug!("Explicit deref of non-derefable type: {}",
base_cmt_ty.repr(self.tcx()));
base_cmt_ty.repr());
return Err(());
}
}
@ -991,7 +991,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty: deref_ty,
note: NoteNone
});
debug!("cat_deref_common ret {}", ret.repr(self.tcx()));
debug!("cat_deref_common ret {}", ret.repr());
Ok(ret)
}
@ -1042,7 +1042,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
let m = base_cmt.mutbl.inherit();
let ret = interior(elt, base_cmt.clone(), base_cmt.ty,
m, context, element_ty);
debug!("cat_index ret {}", ret.repr(self.tcx()));
debug!("cat_index ret {}", ret.repr());
return Ok(ret);
fn interior<'tcx, N: ast_node>(elt: &N,
@ -1096,7 +1096,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
base_cmt
}
};
debug!("deref_vec ret {}", ret.repr(self.tcx()));
debug!("deref_vec ret {}", ret.repr());
Ok(ret)
}
@ -1155,7 +1155,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty: interior_ty,
note: NoteNone
});
debug!("cat_imm_interior ret={}", ret.repr(self.tcx()));
debug!("cat_imm_interior ret={}", ret.repr());
ret
}
@ -1173,7 +1173,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
ty: downcast_ty,
note: NoteNone
});
debug!("cat_downcast ret={}", ret.repr(self.tcx()));
debug!("cat_downcast ret={}", ret.repr());
ret
}
@ -1235,7 +1235,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
debug!("cat_pattern: id={} pat={} cmt={}",
pat.id, pprust::pat_to_string(pat),
cmt.repr(self.tcx()));
cmt.repr());
(*op)(self, cmt.clone(), pat);
@ -1521,7 +1521,7 @@ impl<'tcx> cmt_<'tcx> {
let upvar = self.upvar();
match upvar.as_ref().map(|i| &i.cat) {
Some(&cat_upvar(ref var)) => {
var.user_string(tcx)
var.user_string()
}
Some(_) => unreachable!(),
None => {
@ -1561,7 +1561,7 @@ impl<'tcx> cmt_<'tcx> {
"pattern-bound indexed content".to_string()
}
cat_upvar(ref var) => {
var.user_string(tcx)
var.user_string()
}
cat_downcast(ref cmt, _) => {
cmt.descriptive_string(tcx)
@ -1570,18 +1570,18 @@ impl<'tcx> cmt_<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for cmt_<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for cmt_<'tcx> {
fn repr(&self) -> String {
format!("{{{} id:{} m:{:?} ty:{}}}",
self.cat.repr(tcx),
self.cat.repr(),
self.id,
self.mutbl,
self.ty.repr(tcx))
self.ty.repr())
}
}
impl<'tcx> Repr<'tcx> for categorization<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for categorization<'tcx> {
fn repr(&self) -> String {
match *self {
cat_static_item |
cat_rvalue(..) |
@ -1590,13 +1590,13 @@ impl<'tcx> Repr<'tcx> for categorization<'tcx> {
format!("{:?}", *self)
}
cat_deref(ref cmt, derefs, ptr) => {
format!("{}-{}{}->", cmt.cat.repr(tcx), ptr.repr(tcx), derefs)
format!("{}-{}{}->", cmt.cat.repr(), ptr.repr(), derefs)
}
cat_interior(ref cmt, interior) => {
format!("{}.{}", cmt.cat.repr(tcx), interior.repr(tcx))
format!("{}.{}", cmt.cat.repr(), interior.repr())
}
cat_downcast(ref cmt, _) => {
format!("{}->(enum)", cmt.cat.repr(tcx))
format!("{}->(enum)", cmt.cat.repr())
}
}
}
@ -1615,23 +1615,23 @@ pub fn ptr_sigil(ptr: PointerKind) -> &'static str {
}
}
impl<'tcx> Repr<'tcx> for PointerKind {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl Repr for PointerKind {
fn repr(&self) -> String {
match *self {
Unique => {
format!("Box")
}
BorrowedPtr(ty::ImmBorrow, ref r) |
Implicit(ty::ImmBorrow, ref r) => {
format!("&{}", r.repr(tcx))
format!("&{}", r.repr())
}
BorrowedPtr(ty::MutBorrow, ref r) |
Implicit(ty::MutBorrow, ref r) => {
format!("&{} mut", r.repr(tcx))
format!("&{} mut", r.repr())
}
BorrowedPtr(ty::UniqueImmBorrow, ref r) |
Implicit(ty::UniqueImmBorrow, ref r) => {
format!("&{} uniq", r.repr(tcx))
format!("&{} uniq", r.repr())
}
UnsafePtr(_) => {
format!("*")
@ -1640,8 +1640,8 @@ impl<'tcx> Repr<'tcx> for PointerKind {
}
}
impl<'tcx> Repr<'tcx> for InteriorKind {
fn repr(&self, _tcx: &ty::ctxt) -> String {
impl Repr for InteriorKind {
fn repr(&self) -> String {
match *self {
InteriorField(NamedField(fld)) => {
token::get_name(fld).to_string()
@ -1664,20 +1664,20 @@ fn element_kind(t: Ty) -> ElementKind {
}
}
impl<'tcx> Repr<'tcx> for ty::ClosureKind {
fn repr(&self, _: &ty::ctxt) -> String {
impl Repr for ty::ClosureKind {
fn repr(&self) -> String {
format!("Upvar({:?})", self)
}
}
impl<'tcx> Repr<'tcx> for Upvar {
fn repr(&self, tcx: &ty::ctxt) -> String {
format!("Upvar({})", self.kind.repr(tcx))
impl Repr for Upvar {
fn repr(&self) -> String {
format!("Upvar({})", self.kind.repr())
}
}
impl<'tcx> UserString<'tcx> for Upvar {
fn user_string(&self, _: &ty::ctxt) -> String {
impl UserString for Upvar {
fn user_string(&self) -> String {
let kind = match self.kind {
ty::FnClosureKind => "Fn",
ty::FnMutClosureKind => "FnMut",

4
src/librustc/middle/stability.rs
View file

@ -450,7 +450,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &ast::Expr,
tcx.sess.span_bug(e.span,
&format!("stability::check_expr: struct construction \
of non-struct, type {:?}",
type_.repr(tcx)));
type_.repr()));
}
}
}
@ -551,7 +551,7 @@ pub fn lookup<'tcx>(tcx: &ty::ctxt<'tcx>, id: DefId) -> Option<&'tcx Stability>
}
fn lookup_uncached<'tcx>(tcx: &ty::ctxt<'tcx>, id: DefId) -> Option<&'tcx Stability> {
debug!("lookup(id={})", id.repr(tcx));
debug!("lookup(id={})", id.repr());
// is this definition the implementation of a trait method?
match ty::trait_item_of_item(tcx, id) {

14
src/librustc/middle/subst.rs
View file

@ -623,7 +623,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
when substituting in region {} (root type={}) \
(space={:?}, index={})",
data.name.as_str(),
self.root_ty.repr(self.tcx()),
self.root_ty.repr(),
data.space,
data.index));
}
@ -677,12 +677,12 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> {
span,
&format!("Type parameter `{}` ({}/{:?}/{}) out of range \
when substituting (root type={}) substs={}",
p.repr(self.tcx()),
source_ty.repr(self.tcx()),
p.repr(),
source_ty.repr(),
p.space,
p.idx,
self.root_ty.repr(self.tcx()),
self.substs.repr(self.tcx())));
self.root_ty.repr(),
self.substs.repr()));
}
};
@ -733,14 +733,14 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> {
/// is that only in the second case have we passed through a fn binder.
fn shift_regions_through_binders(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
debug!("shift_regions(ty={:?}, region_binders_passed={:?}, type_has_escaping_regions={:?})",
ty.repr(self.tcx()), self.region_binders_passed, ty::type_has_escaping_regions(ty));
ty.repr(), self.region_binders_passed, ty::type_has_escaping_regions(ty));
if self.region_binders_passed == 0 || !ty::type_has_escaping_regions(ty) {
return ty;
}
let result = ty_fold::shift_regions(self.tcx(), self.region_binders_passed, &ty);
debug!("shift_regions: shifted result = {:?}", result.repr(self.tcx()));
debug!("shift_regions: shifted result = {:?}", result.repr());
result
}

34
src/librustc/middle/traits/coherence.rs
View file

@ -36,8 +36,8 @@ pub fn overlapping_impls(infcx: &InferCtxt,
debug!("impl_can_satisfy(\
impl1_def_id={}, \
impl2_def_id={})",
impl1_def_id.repr(infcx.tcx),
impl2_def_id.repr(infcx.tcx));
impl1_def_id.repr(),
impl2_def_id.repr());
let param_env = &ty::empty_parameter_environment(infcx.tcx);
let selcx = &mut SelectionContext::intercrate(infcx, param_env);
@ -54,8 +54,8 @@ fn overlap(selcx: &mut SelectionContext,
-> bool
{
debug!("overlap(a_def_id={}, b_def_id={})",
a_def_id.repr(selcx.tcx()),
b_def_id.repr(selcx.tcx()));
a_def_id.repr(),
b_def_id.repr());
let (a_trait_ref, a_obligations) = impl_trait_ref_and_oblig(selcx,
a_def_id,
@ -65,9 +65,9 @@ fn overlap(selcx: &mut SelectionContext,
b_def_id,
util::fresh_type_vars_for_impl);
debug!("overlap: a_trait_ref={}", a_trait_ref.repr(selcx.tcx()));
debug!("overlap: a_trait_ref={}", a_trait_ref.repr());
debug!("overlap: b_trait_ref={}", b_trait_ref.repr(selcx.tcx()));
debug!("overlap: b_trait_ref={}", b_trait_ref.repr());
// Does `a <: b` hold? If not, no overlap.
if let Err(_) = infer::mk_sub_poly_trait_refs(selcx.infcx(),
@ -90,7 +90,7 @@ fn overlap(selcx: &mut SelectionContext,
.find(|o| !selcx.evaluate_obligation(o));
if let Some(failing_obligation) = opt_failing_obligation {
debug!("overlap: obligation unsatisfiable {}", failing_obligation.repr(tcx));
debug!("overlap: obligation unsatisfiable {}", failing_obligation.repr());
return false
}
@ -99,7 +99,7 @@ fn overlap(selcx: &mut SelectionContext,
pub fn trait_ref_is_knowable<'tcx>(tcx: &ty::ctxt<'tcx>, trait_ref: &ty::TraitRef<'tcx>) -> bool
{
debug!("trait_ref_is_knowable(trait_ref={})", trait_ref.repr(tcx));
debug!("trait_ref_is_knowable(trait_ref={})", trait_ref.repr());
// if the orphan rules pass, that means that no ancestor crate can
// impl this, so it's up to us.
@ -181,17 +181,17 @@ pub fn orphan_check<'tcx>(tcx: &ty::ctxt<'tcx>,
impl_def_id: ast::DefId)
-> Result<(), OrphanCheckErr<'tcx>>
{
debug!("orphan_check({})", impl_def_id.repr(tcx));
debug!("orphan_check({})", impl_def_id.repr());
// We only except this routine to be invoked on implementations
// of a trait, not inherent implementations.
let trait_ref = ty::impl_trait_ref(tcx, impl_def_id).unwrap();
debug!("orphan_check: trait_ref={}", trait_ref.repr(tcx));
debug!("orphan_check: trait_ref={}", trait_ref.repr());
// If the *trait* is local to the crate, ok.
if trait_ref.def_id.krate == ast::LOCAL_CRATE {
debug!("trait {} is local to current crate",
trait_ref.def_id.repr(tcx));
trait_ref.def_id.repr());
return Ok(());
}
@ -204,7 +204,7 @@ fn orphan_check_trait_ref<'tcx>(tcx: &ty::ctxt<'tcx>,
-> Result<(), OrphanCheckErr<'tcx>>
{
debug!("orphan_check_trait_ref(trait_ref={}, infer_is_local={})",
trait_ref.repr(tcx), infer_is_local.0);
trait_ref.repr(), infer_is_local.0);
// First, create an ordered iterator over all the type parameters to the trait, with the self
// type appearing first.
@ -215,14 +215,14 @@ fn orphan_check_trait_ref<'tcx>(tcx: &ty::ctxt<'tcx>,
// some local type.
for input_ty in input_tys {
if ty_is_local(tcx, input_ty, infer_is_local) {
debug!("orphan_check_trait_ref: ty_is_local `{}`", input_ty.repr(tcx));
debug!("orphan_check_trait_ref: ty_is_local `{}`", input_ty.repr());
// First local input type. Check that there are no
// uncovered type parameters.
let uncovered_tys = uncovered_tys(tcx, input_ty, infer_is_local);
for uncovered_ty in uncovered_tys {
if let Some(param) = uncovered_ty.walk().find(|t| is_type_parameter(t)) {
debug!("orphan_check_trait_ref: uncovered type `{}`", param.repr(tcx));
debug!("orphan_check_trait_ref: uncovered type `{}`", param.repr());
return Err(OrphanCheckErr::UncoveredTy(param));
}
}
@ -235,7 +235,7 @@ fn orphan_check_trait_ref<'tcx>(tcx: &ty::ctxt<'tcx>,
// parameters reachable.
if !infer_is_local.0 {
if let Some(param) = input_ty.walk().find(|t| is_type_parameter(t)) {
debug!("orphan_check_trait_ref: uncovered type `{}`", param.repr(tcx));
debug!("orphan_check_trait_ref: uncovered type `{}`", param.repr());
return Err(OrphanCheckErr::UncoveredTy(param));
}
}
@ -295,7 +295,7 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>,
infer_is_local: InferIsLocal)
-> bool
{
debug!("ty_is_local_constructor({})", ty.repr(tcx));
debug!("ty_is_local_constructor({})", ty.repr());
match ty.sty {
ty::TyBool |
@ -337,7 +337,7 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>,
ty::TyError => {
tcx.sess.bug(
&format!("ty_is_local invoked on unexpected type: {}",
ty.repr(tcx)))
ty.repr()))
}
}
}

62
src/librustc/middle/traits/error_reporting.rs
View file

@ -68,7 +68,7 @@ pub fn report_projection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
if !infcx.tcx.sess.has_errors() || !predicate.references_error() {
span_err!(infcx.tcx.sess, obligation.cause.span, E0271,
"type mismatch resolving `{}`: {}",
predicate.user_string(infcx.tcx),
predicate.user_string(),
ty::type_err_to_str(infcx.tcx, &error.err));
note_obligation_cause(infcx, obligation);
}
@ -87,16 +87,16 @@ fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
item.meta().span
};
let def = ty::lookup_trait_def(infcx.tcx, def_id);
let trait_str = def.trait_ref.user_string(infcx.tcx);
let trait_str = def.trait_ref.user_string();
if let Some(ref istring) = item.value_str() {
let mut generic_map = def.generics.types.iter_enumerated()
.map(|(param, i, gen)| {
(gen.name.as_str().to_string(),
trait_ref.substs.types.get(param, i)
.user_string(infcx.tcx))
.user_string())
}).collect::<HashMap<String, String>>();
generic_map.insert("Self".to_string(),
trait_ref.self_ty().user_string(infcx.tcx));
trait_ref.self_ty().user_string());
let parser = Parser::new(&istring);
let mut errored = false;
let err: String = parser.filter_map(|p| {
@ -157,13 +157,13 @@ fn report_on_unimplemented<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
pub fn report_overflow_error<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
obligation: &Obligation<'tcx, T>)
-> !
where T: UserString<'tcx> + TypeFoldable<'tcx>
where T: UserString + TypeFoldable<'tcx>
{
let predicate =
infcx.resolve_type_vars_if_possible(&obligation.predicate);
span_err!(infcx.tcx.sess, obligation.cause.span, E0275,
"overflow evaluating the requirement `{}`",
predicate.user_string(infcx.tcx));
predicate.user_string());
suggest_new_overflow_limit(infcx.tcx, obligation.cause.span);
@ -184,7 +184,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
span_err!(infcx.tcx.sess, obligation.cause.span, E0276,
"the requirement `{}` appears on the impl \
method but not on the corresponding trait method",
obligation.predicate.user_string(infcx.tcx));;
obligation.predicate.user_string());;
}
_ => {
match obligation.predicate {
@ -197,8 +197,8 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
let trait_ref = trait_predicate.to_poly_trait_ref();
span_err!(infcx.tcx.sess, obligation.cause.span, E0277,
"the trait `{}` is not implemented for the type `{}`",
trait_ref.user_string(infcx.tcx),
trait_ref.self_ty().user_string(infcx.tcx));
trait_ref.user_string(),
trait_ref.self_ty().user_string());
// Check if it has a custom "#[rustc_on_unimplemented]"
// error message, report with that message if it does
let custom_note = report_on_unimplemented(infcx, &trait_ref.0,
@ -216,7 +216,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
&predicate).err().unwrap();
span_err!(infcx.tcx.sess, obligation.cause.span, E0278,
"the requirement `{}` is not satisfied (`{}`)",
predicate.user_string(infcx.tcx),
predicate.user_string(),
ty::type_err_to_str(infcx.tcx, &err));
}
@ -226,7 +226,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
&predicate).err().unwrap();
span_err!(infcx.tcx.sess, obligation.cause.span, E0279,
"the requirement `{}` is not satisfied (`{}`)",
predicate.user_string(infcx.tcx),
predicate.user_string(),
ty::type_err_to_str(infcx.tcx, &err));
}
@ -235,7 +235,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
infcx.resolve_type_vars_if_possible(&obligation.predicate);
span_err!(infcx.tcx.sess, obligation.cause.span, E0280,
"the requirement `{}` is not satisfied",
predicate.user_string(infcx.tcx));
predicate.user_string());
}
}
}
@ -249,9 +249,9 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
span_err!(infcx.tcx.sess, obligation.cause.span, E0281,
"type mismatch: the type `{}` implements the trait `{}`, \
but the trait `{}` is required ({})",
expected_trait_ref.self_ty().user_string(infcx.tcx),
expected_trait_ref.user_string(infcx.tcx),
actual_trait_ref.user_string(infcx.tcx),
expected_trait_ref.self_ty().user_string(),
expected_trait_ref.user_string(),
actual_trait_ref.user_string(),
ty::type_err_to_str(infcx.tcx, e));
note_obligation_cause(infcx, obligation);
}
@ -282,7 +282,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
infcx.tcx.sess.span_note(
obligation.cause.span,
&format!("method `{}` has no receiver",
method.name.user_string(infcx.tcx)));
method.name.user_string()));
}
ObjectSafetyViolation::Method(method,
@ -291,7 +291,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
obligation.cause.span,
&format!("method `{}` references the `Self` type \
in its arguments or return type",
method.name.user_string(infcx.tcx)));
method.name.user_string()));
}
ObjectSafetyViolation::Method(method,
@ -299,7 +299,7 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
infcx.tcx.sess.span_note(
obligation.cause.span,
&format!("method `{}` has generic type parameters",
method.name.user_string(infcx.tcx)));
method.name.user_string()));
}
}
}
@ -317,8 +317,8 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
let predicate = infcx.resolve_type_vars_if_possible(&obligation.predicate);
debug!("maybe_report_ambiguity(predicate={}, obligation={})",
predicate.repr(infcx.tcx),
obligation.repr(infcx.tcx));
predicate.repr(),
obligation.repr());
match predicate {
ty::Predicate::Trait(ref data) => {
@ -349,11 +349,11 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
span_err!(infcx.tcx.sess, obligation.cause.span, E0282,
"unable to infer enough type information about `{}`; \
type annotations or generic parameter binding required",
self_ty.user_string(infcx.tcx));
self_ty.user_string());
} else {
span_err!(infcx.tcx.sess, obligation.cause.span, E0283,
"type annotations required: cannot resolve `{}`",
predicate.user_string(infcx.tcx));;
predicate.user_string());;
note_obligation_cause(infcx, obligation);
}
}
@ -365,8 +365,8 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
"coherence failed to report ambiguity: \
cannot locate the impl of the trait `{}` for \
the type `{}`",
trait_ref.user_string(infcx.tcx),
self_ty.user_string(infcx.tcx)));
trait_ref.user_string(),
self_ty.user_string()));
}
}
@ -374,7 +374,7 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
if !infcx.tcx.sess.has_errors() {
span_err!(infcx.tcx.sess, obligation.cause.span, E0284,
"type annotations required: cannot resolve `{}`",
predicate.user_string(infcx.tcx));;
predicate.user_string());;
note_obligation_cause(infcx, obligation);
}
}
@ -383,7 +383,7 @@ pub fn maybe_report_ambiguity<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
fn note_obligation_cause<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
obligation: &Obligation<'tcx, T>)
where T: UserString<'tcx>
where T: UserString
{
note_obligation_cause_code(infcx,
&obligation.predicate,
@ -395,7 +395,7 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
predicate: &T,
cause_span: Span,
cause_code: &ObligationCauseCode<'tcx>)
where T: UserString<'tcx>
where T: UserString
{
let tcx = infcx.tcx;
match *cause_code {
@ -463,7 +463,7 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
let parent_trait_ref = infcx.resolve_type_vars_if_possible(&data.parent_trait_ref);
span_note!(tcx.sess, cause_span,
"required because it appears within the type `{}`",
parent_trait_ref.0.self_ty().user_string(infcx.tcx));
parent_trait_ref.0.self_ty().user_string());
let parent_predicate = parent_trait_ref.as_predicate();
note_obligation_cause_code(infcx, &parent_predicate, cause_span, &*data.parent_code);
}
@ -471,8 +471,8 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
let parent_trait_ref = infcx.resolve_type_vars_if_possible(&data.parent_trait_ref);
span_note!(tcx.sess, cause_span,
"required because of the requirements on the impl of `{}` for `{}`",
parent_trait_ref.user_string(infcx.tcx),
parent_trait_ref.0.self_ty().user_string(infcx.tcx));
parent_trait_ref.user_string(),
parent_trait_ref.0.self_ty().user_string());
let parent_predicate = parent_trait_ref.as_predicate();
note_obligation_cause_code(infcx, &parent_predicate, cause_span, &*data.parent_code);
}
@ -480,7 +480,7 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
span_note!(tcx.sess, cause_span,
"the requirement `{}` appears on the impl method \
but not on the corresponding trait method",
predicate.user_string(infcx.tcx));
predicate.user_string());
}
}
}

26
src/librustc/middle/traits/fulfill.rs
View file

@ -138,7 +138,7 @@ impl<'tcx> FulfillmentContext<'tcx> {
-> Ty<'tcx>
{
debug!("normalize_associated_type(projection_ty={})",
projection_ty.repr(infcx.tcx));
projection_ty.repr());
assert!(!projection_ty.has_escaping_regions());
@ -151,7 +151,7 @@ impl<'tcx> FulfillmentContext<'tcx> {
self.register_predicate_obligation(infcx, obligation);
}
debug!("normalize_associated_type: result={}", normalized.value.repr(infcx.tcx));
debug!("normalize_associated_type: result={}", normalized.value.repr());
normalized.value
}
@ -190,11 +190,11 @@ impl<'tcx> FulfillmentContext<'tcx> {
assert!(!obligation.has_escaping_regions());
if self.is_duplicate_or_add(infcx.tcx, &obligation.predicate) {
debug!("register_predicate({}) -- already seen, skip", obligation.repr(infcx.tcx));
debug!("register_predicate({}) -- already seen, skip", obligation.repr());
return;
}
debug!("register_predicate({})", obligation.repr(infcx.tcx));
debug!("register_predicate({})", obligation.repr());
self.predicates.push(obligation);
}
@ -380,8 +380,8 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
}
Err(selection_err) => {
debug!("predicate: {} error: {}",
obligation.repr(tcx),
selection_err.repr(tcx));
obligation.repr(),
selection_err.repr());
errors.push(
FulfillmentError::new(
obligation.clone(),
@ -441,8 +441,8 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
let project_obligation = obligation.with(data.clone());
let result = project::poly_project_and_unify_type(selcx, &project_obligation);
debug!("process_predicate: poly_project_and_unify_type({}) returned {}",
project_obligation.repr(tcx),
result.repr(tcx));
project_obligation.repr(),
result.repr());
match result {
Ok(Some(obligations)) => {
new_obligations.extend(obligations);
@ -463,11 +463,11 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
}
}
impl<'tcx> Repr<'tcx> for RegionObligation<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for RegionObligation<'tcx> {
fn repr(&self) -> String {
format!("RegionObligation(sub_region={}, sup_type={})",
self.sub_region.repr(tcx),
self.sup_type.repr(tcx))
self.sub_region.repr(),
self.sup_type.repr())
}
}
@ -482,7 +482,7 @@ fn register_region_obligation<'tcx>(tcx: &ty::ctxt<'tcx>,
cause: cause };
debug!("register_region_obligation({})",
region_obligation.repr(tcx));
region_obligation.repr());
region_obligations.entry(region_obligation.cause.body_id).or_insert(vec![])
.push(region_obligation);

22
src/librustc/middle/traits/mod.rs
View file

@ -321,7 +321,7 @@ pub fn type_known_to_meet_builtin_bound<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
-> bool
{
debug!("type_known_to_meet_builtin_bound(ty={}, bound={:?})",
ty.repr(infcx.tcx),
ty.repr(),
bound);
let mut fulfill_cx = FulfillmentContext::new(false);
@ -339,15 +339,15 @@ pub fn type_known_to_meet_builtin_bound<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
match fulfill_cx.select_all_or_error(infcx, typer) {
Ok(()) => {
debug!("type_known_to_meet_builtin_bound: ty={} bound={:?} success",
ty.repr(infcx.tcx),
ty.repr(),
bound);
true
}
Err(e) => {
debug!("type_known_to_meet_builtin_bound: ty={} bound={:?} errors={}",
ty.repr(infcx.tcx),
ty.repr(),
bound,
e.repr(infcx.tcx));
e.repr());
false
}
}
@ -378,7 +378,7 @@ pub fn normalize_param_env_or_error<'a,'tcx>(unnormalized_env: ty::ParameterEnvi
let body_id = cause.body_id;
debug!("normalize_param_env_or_error(unnormalized_env={})",
unnormalized_env.repr(tcx));
unnormalized_env.repr());
let predicates: Vec<_> =
util::elaborate_predicates(tcx, unnormalized_env.caller_bounds.clone())
@ -394,7 +394,7 @@ pub fn normalize_param_env_or_error<'a,'tcx>(unnormalized_env: ty::ParameterEnvi
// -nmatsakis
debug!("normalize_param_env_or_error: elaborated-predicates={}",
predicates.repr(tcx));
predicates.repr());
let elaborated_env = unnormalized_env.with_caller_bounds(predicates);
@ -434,25 +434,25 @@ pub fn fully_normalize<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
cause: ObligationCause<'tcx>,
value: &T)
-> Result<T, Vec<FulfillmentError<'tcx>>>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr<'tcx>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr
{
let tcx = closure_typer.tcx();
debug!("normalize_param_env(value={})", value.repr(tcx));
debug!("normalize_param_env(value={})", value.repr());
let mut selcx = &mut SelectionContext::new(infcx, closure_typer);
let mut fulfill_cx = FulfillmentContext::new(false);
let Normalized { value: normalized_value, obligations } =
project::normalize(selcx, cause, value);
debug!("normalize_param_env: normalized_value={} obligations={}",
normalized_value.repr(tcx),
obligations.repr(tcx));
normalized_value.repr(),
obligations.repr());
for obligation in obligations {
fulfill_cx.register_predicate_obligation(selcx.infcx(), obligation);
}
try!(fulfill_cx.select_all_or_error(infcx, closure_typer));
let resolved_value = infcx.resolve_type_vars_if_possible(&normalized_value);
debug!("normalize_param_env: resolved_value={}", resolved_value.repr(tcx));
debug!("normalize_param_env: resolved_value={}", resolved_value.repr());
Ok(resolved_value)
}

12
src/librustc/middle/traits/object_safety.rs
View file

@ -70,7 +70,7 @@ pub fn is_object_safe<'tcx>(tcx: &ty::ctxt<'tcx>,
result
});
debug!("is_object_safe({}) = {}", trait_def_id.repr(tcx), result);
debug!("is_object_safe({}) = {}", trait_def_id.repr(), result);
result
}
@ -112,8 +112,8 @@ fn object_safety_violations_for_trait<'tcx>(tcx: &ty::ctxt<'tcx>,
}
debug!("object_safety_violations_for_trait(trait_def_id={}) = {}",
trait_def_id.repr(tcx),
violations.repr(tcx));
trait_def_id.repr(),
violations.repr());
violations
}
@ -352,15 +352,15 @@ fn contains_illegal_self_type_reference<'tcx>(tcx: &ty::ctxt<'tcx>,
error
}
impl<'tcx> Repr<'tcx> for ObjectSafetyViolation<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for ObjectSafetyViolation<'tcx> {
fn repr(&self) -> String {
match *self {
ObjectSafetyViolation::SizedSelf =>
format!("SizedSelf"),
ObjectSafetyViolation::SupertraitSelf =>
format!("SupertraitSelf"),
ObjectSafetyViolation::Method(ref m, code) =>
format!("Method({},{:?})", m.repr(tcx), code),
format!("Method({},{:?})", m.repr(), code),
}
}
}

86
src/librustc/middle/traits/project.rs
View file

@ -77,7 +77,7 @@ pub fn poly_project_and_unify_type<'cx,'tcx>(
-> Result<Option<Vec<PredicateObligation<'tcx>>>, MismatchedProjectionTypes<'tcx>>
{
debug!("poly_project_and_unify_type(obligation={})",
obligation.repr(selcx.tcx()));
obligation.repr());
let infcx = selcx.infcx();
infcx.commit_if_ok(|snapshot| {
@ -110,7 +110,7 @@ fn project_and_unify_type<'cx,'tcx>(
-> Result<Option<Vec<PredicateObligation<'tcx>>>, MismatchedProjectionTypes<'tcx>>
{
debug!("project_and_unify_type(obligation={})",
obligation.repr(selcx.tcx()));
obligation.repr());
let Normalized { value: normalized_ty, obligations } =
match opt_normalize_projection_type(selcx,
@ -125,8 +125,8 @@ fn project_and_unify_type<'cx,'tcx>(
};
debug!("project_and_unify_type: normalized_ty={} obligations={}",
normalized_ty.repr(selcx.tcx()),
obligations.repr(selcx.tcx()));
normalized_ty.repr(),
obligations.repr());
let infcx = selcx.infcx();
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
@ -139,7 +139,7 @@ fn project_and_unify_type<'cx,'tcx>(
fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext<'cx,'tcx>,
obligation: &ProjectionObligation<'tcx>) {
debug!("consider_unification_despite_ambiguity(obligation={})",
obligation.repr(selcx.tcx()));
obligation.repr());
let def_id = obligation.predicate.projection_ty.trait_ref.def_id;
match selcx.tcx().lang_items.fn_trait_kind(def_id) {
@ -173,7 +173,7 @@ fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext
&ty::Binder(ret_type));
debug!("consider_unification_despite_ambiguity: ret_type={:?}",
ret_type.repr(selcx.tcx()));
ret_type.repr());
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
let obligation_ty = obligation.predicate.ty;
match infer::mk_eqty(infcx, true, origin, obligation_ty, ret_type) {
@ -193,7 +193,7 @@ pub fn normalize<'a,'b,'tcx,T>(selcx: &'a mut SelectionContext<'b,'tcx>,
cause: ObligationCause<'tcx>,
value: &T)
-> Normalized<'tcx, T>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr<'tcx>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr
{
normalize_with_depth(selcx, cause, 0, value)
}
@ -204,7 +204,7 @@ pub fn normalize_with_depth<'a,'b,'tcx,T>(selcx: &'a mut SelectionContext<'b,'tc
depth: usize,
value: &T)
-> Normalized<'tcx, T>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr<'tcx>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr
{
let mut normalizer = AssociatedTypeNormalizer::new(selcx, cause, depth);
let result = normalizer.fold(value);
@ -356,7 +356,7 @@ fn opt_normalize_projection_type<'a,'b,'tcx>(
debug!("normalize_projection_type(\
projection_ty={}, \
depth={})",
projection_ty.repr(selcx.tcx()),
projection_ty.repr(),
depth);
let obligation = Obligation::with_depth(cause.clone(), depth, projection_ty.clone());
@ -368,9 +368,9 @@ fn opt_normalize_projection_type<'a,'b,'tcx>(
// re-normalize it
debug!("normalize_projection_type: projected_ty={} depth={} obligations={}",
projected_ty.repr(selcx.tcx()),
projected_ty.repr(),
depth,
obligations.repr(selcx.tcx()));
obligations.repr());
if ty::type_has_projection(projected_ty) {
let tcx = selcx.tcx();
@ -378,7 +378,7 @@ fn opt_normalize_projection_type<'a,'b,'tcx>(
let normalized_ty = normalizer.fold(&projected_ty);
debug!("normalize_projection_type: normalized_ty={} depth={}",
normalized_ty.repr(tcx),
normalized_ty.repr(),
depth);
obligations.extend(normalizer.obligations);
@ -395,7 +395,7 @@ fn opt_normalize_projection_type<'a,'b,'tcx>(
}
Ok(ProjectedTy::NoProgress(projected_ty)) => {
debug!("normalize_projection_type: projected_ty={} no progress",
projected_ty.repr(selcx.tcx()));
projected_ty.repr());
Some(Normalized {
value: projected_ty,
obligations: vec!()
@ -450,7 +450,7 @@ fn project_type<'cx,'tcx>(
-> Result<ProjectedTy<'tcx>, ProjectionTyError<'tcx>>
{
debug!("project(obligation={})",
obligation.repr(selcx.tcx()));
obligation.repr());
let recursion_limit = selcx.tcx().sess.recursion_limit.get();
if obligation.recursion_depth >= recursion_limit {
@ -461,7 +461,7 @@ fn project_type<'cx,'tcx>(
let obligation_trait_ref =
selcx.infcx().resolve_type_vars_if_possible(&obligation.predicate.trait_ref);
debug!("project: obligation_trait_ref={}", obligation_trait_ref.repr(selcx.tcx()));
debug!("project: obligation_trait_ref={}", obligation_trait_ref.repr());
if obligation_trait_ref.references_error() {
return Ok(ProjectedTy::Progress(selcx.tcx().types.err, vec!()));
@ -590,11 +590,11 @@ fn assemble_candidates_from_predicates<'cx,'tcx,I>(
where I: Iterator<Item=ty::Predicate<'tcx>>
{
debug!("assemble_candidates_from_predicates(obligation={})",
obligation.repr(selcx.tcx()));
obligation.repr());
let infcx = selcx.infcx();
for predicate in env_predicates {
debug!("assemble_candidates_from_predicates: predicate={}",
predicate.repr(selcx.tcx()));
predicate.repr());
match predicate {
ty::Predicate::Projection(ref data) => {
let same_name = data.item_name() == obligation.predicate.item_name;
@ -612,7 +612,7 @@ fn assemble_candidates_from_predicates<'cx,'tcx,I>(
});
debug!("assemble_candidates_from_predicates: candidate {} is_match {} same_name {}",
data.repr(selcx.tcx()),
data.repr(),
is_match,
same_name);
@ -635,14 +635,14 @@ fn assemble_candidates_from_object_type<'cx,'tcx>(
{
let infcx = selcx.infcx();
debug!("assemble_candidates_from_object_type(object_ty={})",
object_ty.repr(infcx.tcx));
object_ty.repr());
let data = match object_ty.sty {
ty::TyTrait(ref data) => data,
_ => {
selcx.tcx().sess.span_bug(
obligation.cause.span,
&format!("assemble_candidates_from_object_type called with non-object: {}",
object_ty.repr(selcx.tcx())));
object_ty.repr()));
}
};
let projection_bounds = data.projection_bounds_with_self_ty(selcx.tcx(), object_ty);
@ -673,7 +673,7 @@ fn assemble_candidates_from_impls<'cx,'tcx>(
}
Err(e) => {
debug!("assemble_candidates_from_impls: selection error {}",
e.repr(selcx.tcx()));
e.repr());
return Err(e);
}
};
@ -681,7 +681,7 @@ fn assemble_candidates_from_impls<'cx,'tcx>(
match vtable {
super::VtableImpl(data) => {
debug!("assemble_candidates_from_impls: impl candidate {}",
data.repr(selcx.tcx()));
data.repr());
candidate_set.vec.push(
ProjectionTyCandidate::Impl(data));
@ -732,7 +732,7 @@ fn assemble_candidates_from_impls<'cx,'tcx>(
selcx.tcx().sess.span_bug(
obligation.cause.span,
&format!("Cannot project an associated type from `{}`",
vtable.repr(selcx.tcx())));
vtable.repr()));
}
}
@ -748,8 +748,8 @@ fn confirm_candidate<'cx,'tcx>(
let infcx = selcx.infcx();
debug!("confirm_candidate(candidate={}, obligation={})",
candidate.repr(infcx.tcx),
obligation.repr(infcx.tcx));
candidate.repr(),
obligation.repr());
match candidate {
ProjectionTyCandidate::ParamEnv(poly_projection) => {
@ -814,8 +814,8 @@ fn confirm_callable_candidate<'cx,'tcx>(
let tcx = selcx.tcx();
debug!("confirm_callable_candidate({},{})",
obligation.repr(tcx),
fn_sig.repr(tcx));
obligation.repr(),
fn_sig.repr());
// the `Output` associated type is declared on `FnOnce`
let fn_once_def_id = tcx.lang_items.fn_once_trait().unwrap();
@ -866,8 +866,8 @@ fn confirm_param_env_candidate<'cx,'tcx>(
selcx.tcx().sess.span_bug(
obligation.cause.span,
&format!("Failed to unify `{}` and `{}` in projection: {}",
obligation.repr(selcx.tcx()),
projection.repr(selcx.tcx()),
obligation.repr(),
projection.repr(),
ty::type_err_to_str(selcx.tcx(), &e)));
}
}
@ -916,31 +916,31 @@ fn confirm_impl_candidate<'cx,'tcx>(
selcx.tcx().sess.span_bug(obligation.cause.span,
&format!("No associated type for {}",
trait_ref.repr(selcx.tcx())));
trait_ref.repr()));
}
impl<'tcx> Repr<'tcx> for ProjectionTyError<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for ProjectionTyError<'tcx> {
fn repr(&self) -> String {
match *self {
ProjectionTyError::TooManyCandidates =>
format!("NoCandidate"),
ProjectionTyError::TraitSelectionError(ref e) =>
format!("TraitSelectionError({})", e.repr(tcx)),
format!("TraitSelectionError({})", e.repr()),
}
}
}
impl<'tcx> Repr<'tcx> for ProjectionTyCandidate<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for ProjectionTyCandidate<'tcx> {
fn repr(&self) -> String {
match *self {
ProjectionTyCandidate::ParamEnv(ref data) =>
format!("ParamEnv({})", data.repr(tcx)),
format!("ParamEnv({})", data.repr()),
ProjectionTyCandidate::Impl(ref data) =>
format!("Impl({})", data.repr(tcx)),
format!("Impl({})", data.repr()),
ProjectionTyCandidate::Closure(ref data) =>
format!("Closure({})", data.repr(tcx)),
format!("Closure({})", data.repr()),
ProjectionTyCandidate::FnPointer(a) =>
format!("FnPointer(({}))", a.repr(tcx)),
format!("FnPointer(({}))", a.repr()),
}
}
}
@ -954,10 +954,10 @@ impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Normalized<'tcx, T> {
}
}
impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for Normalized<'tcx, T> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx, T:Repr> Repr for Normalized<'tcx, T> {
fn repr(&self) -> String {
format!("Normalized({},{})",
self.value.repr(tcx),
self.obligations.repr(tcx))
self.value.repr(),
self.obligations.repr())
}
}

194
src/librustc/middle/traits/select.rs
View file

@ -298,7 +298,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
/// type environment by performing unification.
pub fn select(&mut self, obligation: &TraitObligation<'tcx>)
-> SelectionResult<'tcx, Selection<'tcx>> {
debug!("select({})", obligation.repr(self.tcx()));
debug!("select({})", obligation.repr());
assert!(!obligation.predicate.has_escaping_regions());
let stack = self.push_stack(TraitObligationStackList::empty(), obligation);
@ -388,7 +388,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> bool
{
debug!("evaluate_obligation({})",
obligation.repr(self.tcx()));
obligation.repr());
self.evaluate_predicate_recursively(TraitObligationStackList::empty(), obligation)
.may_apply()
@ -441,7 +441,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> EvaluationResult<'tcx>
{
debug!("evaluate_predicate_recursively({})",
obligation.repr(self.tcx()));
obligation.repr());
// Check the cache from the tcx of predicates that we know
// have been proven elsewhere. This cache only contains
@ -500,7 +500,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> EvaluationResult<'tcx>
{
debug!("evaluate_obligation_recursively({})",
obligation.repr(self.tcx()));
obligation.repr());
let stack = self.push_stack(previous_stack, obligation);
@ -548,7 +548,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
&prev.fresh_trait_ref)))
{
debug!("evaluate_stack({}) --> unbound argument, recursion --> ambiguous",
stack.fresh_trait_ref.repr(self.tcx()));
stack.fresh_trait_ref.repr());
return EvaluatedToAmbig;
}
@ -577,7 +577,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
.any(|prev| stack.fresh_trait_ref == prev.fresh_trait_ref)
{
debug!("evaluate_stack({}) --> recursive",
stack.fresh_trait_ref.repr(self.tcx()));
stack.fresh_trait_ref.repr());
return EvaluatedToOk;
}
@ -596,8 +596,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> bool
{
debug!("evaluate_impl(impl_def_id={}, obligation={})",
impl_def_id.repr(self.tcx()),
obligation.repr(self.tcx()));
impl_def_id.repr(),
obligation.repr());
self.infcx.probe(|snapshot| {
match self.match_impl(impl_def_id, obligation, snapshot) {
@ -644,15 +644,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let cache_fresh_trait_pred =
self.infcx.freshen(stack.obligation.predicate.clone());
debug!("candidate_from_obligation(cache_fresh_trait_pred={}, obligation={})",
cache_fresh_trait_pred.repr(self.tcx()),
stack.repr(self.tcx()));
cache_fresh_trait_pred.repr(),
stack.repr());
assert!(!stack.obligation.predicate.has_escaping_regions());
match self.check_candidate_cache(&cache_fresh_trait_pred) {
Some(c) => {
debug!("CACHE HIT: cache_fresh_trait_pred={}, candidate={}",
cache_fresh_trait_pred.repr(self.tcx()),
c.repr(self.tcx()));
cache_fresh_trait_pred.repr(),
c.repr());
return c;
}
None => { }
@ -663,7 +663,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
if self.should_update_candidate_cache(&cache_fresh_trait_pred, &candidate) {
debug!("CACHE MISS: cache_fresh_trait_pred={}, candidate={}",
cache_fresh_trait_pred.repr(self.tcx()), candidate.repr(self.tcx()));
cache_fresh_trait_pred.repr(), candidate.repr());
self.insert_candidate_cache(cache_fresh_trait_pred, candidate.clone());
}
@ -694,8 +694,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
debug!("assembled {} candidates for {}: {}",
candidates.len(),
stack.repr(self.tcx()),
candidates.repr(self.tcx()));
stack.repr(),
candidates.repr());
// At this point, we know that each of the entries in the
// candidate set is *individually* applicable. Now we have to
@ -736,11 +736,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
&candidates[j]));
if is_dup {
debug!("Dropping candidate #{}/{}: {}",
i, candidates.len(), candidates[i].repr(self.tcx()));
i, candidates.len(), candidates[i].repr());
candidates.swap_remove(i);
} else {
debug!("Retaining candidate #{}/{}: {}",
i, candidates.len(), candidates[i].repr(self.tcx()));
i, candidates.len(), candidates[i].repr());
i += 1;
}
}
@ -907,7 +907,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
match self.tcx().lang_items.to_builtin_kind(obligation.predicate.def_id()) {
Some(ty::BoundCopy) => {
debug!("obligation self ty is {}",
obligation.predicate.0.self_ty().repr(self.tcx()));
obligation.predicate.0.self_ty().repr());
// User-defined copy impls are permitted, but only for
// structs and enums.
@ -958,8 +958,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.infcx().resolve_type_vars_if_possible(&obligation.predicate);
debug!("assemble_candidates_for_projected_tys({},{})",
obligation.repr(self.tcx()),
poly_trait_predicate.repr(self.tcx()));
obligation.repr(),
poly_trait_predicate.repr());
// FIXME(#20297) -- just examining the self-type is very simplistic
@ -982,7 +982,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
};
debug!("assemble_candidates_for_projected_tys: trait_def_id={}",
trait_def_id.repr(self.tcx()));
trait_def_id.repr());
let result = self.infcx.probe(|snapshot| {
self.match_projection_obligation_against_bounds_from_trait(obligation,
@ -1006,8 +1006,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.infcx().skolemize_late_bound_regions(&poly_trait_predicate, snapshot);
debug!("match_projection_obligation_against_bounds_from_trait: \
skol_trait_predicate={} skol_map={}",
skol_trait_predicate.repr(self.tcx()),
skol_map.repr(self.tcx()));
skol_trait_predicate.repr(),
skol_map.repr());
let projection_trait_ref = match skol_trait_predicate.trait_ref.self_ty().sty {
ty::TyProjection(ref data) => &data.trait_ref,
@ -1016,18 +1016,18 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
obligation.cause.span,
&format!("match_projection_obligation_against_bounds_from_trait() called \
but self-ty not a projection: {}",
skol_trait_predicate.trait_ref.self_ty().repr(self.tcx())));
skol_trait_predicate.trait_ref.self_ty().repr()));
}
};
debug!("match_projection_obligation_against_bounds_from_trait: \
projection_trait_ref={}",
projection_trait_ref.repr(self.tcx()));
projection_trait_ref.repr());
let trait_predicates = ty::lookup_predicates(self.tcx(), projection_trait_ref.def_id);
let bounds = trait_predicates.instantiate(self.tcx(), projection_trait_ref.substs);
debug!("match_projection_obligation_against_bounds_from_trait: \
bounds={}",
bounds.repr(self.tcx()));
bounds.repr());
let matching_bound =
util::elaborate_predicates(self.tcx(), bounds.predicates.into_vec())
@ -1042,7 +1042,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
debug!("match_projection_obligation_against_bounds_from_trait: \
matching_bound={}",
matching_bound.repr(self.tcx()));
matching_bound.repr());
match matching_bound {
None => false,
Some(bound) => {
@ -1089,7 +1089,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> Result<(),SelectionError<'tcx>>
{
debug!("assemble_candidates_from_caller_bounds({})",
stack.obligation.repr(self.tcx()));
stack.obligation.repr());
let all_bounds =
self.param_env().caller_bounds
@ -1156,9 +1156,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
};
debug!("assemble_unboxed_candidates: self_ty={} kind={:?} obligation={}",
self_ty.repr(self.tcx()),
self_ty.repr(),
kind,
obligation.repr(self.tcx()));
obligation.repr());
match self.closure_typer.closure_kind(closure_def_id) {
Some(closure_kind) => {
@ -1221,7 +1221,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
candidates: &mut SelectionCandidateSet<'tcx>)
-> Result<(), SelectionError<'tcx>>
{
debug!("assemble_candidates_from_impls(obligation={})", obligation.repr(self.tcx()));
debug!("assemble_candidates_from_impls(obligation={})", obligation.repr());
let def = ty::lookup_trait_def(self.tcx(), obligation.predicate.def_id());
@ -1247,7 +1247,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
{
// OK to skip binder here because the tests we do below do not involve bound regions
let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
debug!("assemble_candidates_from_default_impls(self_ty={})", self_ty.repr(self.tcx()));
debug!("assemble_candidates_from_default_impls(self_ty={})", self_ty.repr());
let def_id = obligation.predicate.def_id();
@ -1317,7 +1317,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
candidates: &mut SelectionCandidateSet<'tcx>)
{
debug!("assemble_candidates_from_object_ty(self_ty={})",
self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()).repr(self.tcx()));
self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()).repr());
// Object-safety candidates are only applicable to object-safe
// traits. Including this check is useful because it helps
@ -1363,7 +1363,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
};
debug!("assemble_candidates_from_object_ty: poly_trait_ref={}",
poly_trait_ref.repr(self.tcx()));
poly_trait_ref.repr());
// see whether the object trait can be upcast to the trait we are looking for
let upcast_trait_refs = self.upcast(poly_trait_ref, obligation);
@ -1407,7 +1407,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let target = self.infcx.shallow_resolve(obligation.predicate.0.input_types()[0]);
debug!("assemble_candidates_for_unsizing(source={}, target={})",
source.repr(self.tcx()), target.repr(self.tcx()));
source.repr(), target.repr());
let may_apply = match (&source.sty, &target.sty) {
// Trait+Kx+'a -> Trait+Ky+'b (upcasts).
@ -1473,7 +1473,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
candidate: &SelectionCandidate<'tcx>)
-> EvaluationResult<'tcx>
{
debug!("winnow_candidate: candidate={}", candidate.repr(self.tcx()));
debug!("winnow_candidate: candidate={}", candidate.repr());
let result = self.infcx.probe(|_| {
let candidate = (*candidate).clone();
match self.confirm_candidate(stack.obligation, candidate) {
@ -1566,7 +1566,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
match self.builtin_bound(bound, stack.obligation) {
Ok(If(..)) => {
debug!("builtin_bound: bound={}",
bound.repr(self.tcx()));
bound.repr());
candidates.vec.push(BuiltinCandidate(bound));
Ok(())
}
@ -1775,7 +1775,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.tcx().sess.bug(
&format!(
"asked to assemble builtin bounds of unexpected type: {}",
self_ty.repr(self.tcx())));
self_ty.repr()));
}
};
@ -1838,7 +1838,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.tcx().sess.bug(
&format!(
"asked to assemble constituent types of unexpected type: {}",
t.repr(self.tcx())));
t.repr()));
}
ty::TyBox(referent_ty) => { // Box<T>
@ -1973,8 +1973,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> Result<Selection<'tcx>,SelectionError<'tcx>>
{
debug!("confirm_candidate({}, {})",
obligation.repr(self.tcx()),
candidate.repr(self.tcx()));
obligation.repr(),
candidate.repr());
match candidate {
BuiltinCandidate(builtin_bound) => {
@ -2065,8 +2065,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> Vec<PredicateObligation<'tcx>>
{
debug!("confirm_param_candidate({},{})",
obligation.repr(self.tcx()),
param.repr(self.tcx()));
obligation.repr(),
param.repr());
// During evaluation, we already checked that this
// where-clause trait-ref could be unified with the obligation
@ -2077,8 +2077,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
Err(()) => {
self.tcx().sess.bug(
&format!("Where clause `{}` was applicable to `{}` but now is not",
param.repr(self.tcx()),
obligation.repr(self.tcx())));
param.repr(),
obligation.repr()));
}
}
}
@ -2090,7 +2090,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
SelectionError<'tcx>>
{
debug!("confirm_builtin_candidate({})",
obligation.repr(self.tcx()));
obligation.repr());
match try!(self.builtin_bound(bound, obligation)) {
If(nested) => Ok(self.vtable_builtin_data(obligation, bound, nested)),
@ -2098,7 +2098,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.tcx().sess.span_bug(
obligation.cause.span,
&format!("builtin bound for {} was ambig",
obligation.repr(self.tcx())));
obligation.repr()));
}
}
}
@ -2119,7 +2119,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let obligations = self.collect_predicates_for_types(obligation, trait_def, nested);
debug!("vtable_builtin_data: obligations={}",
obligations.repr(self.tcx()));
obligations.repr());
VtableBuiltinData { nested: obligations }
}
@ -2135,8 +2135,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> VtableDefaultImplData<PredicateObligation<'tcx>>
{
debug!("confirm_default_impl_candidate({}, {})",
obligation.repr(self.tcx()),
trait_def_id.repr(self.tcx()));
obligation.repr(),
trait_def_id.repr());
// binder is moved below
let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
@ -2146,7 +2146,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.tcx().sess.bug(
&format!(
"asked to confirm default implementation for ambiguous type: {}",
self_ty.repr(self.tcx())));
self_ty.repr()));
}
}
}
@ -2157,8 +2157,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> VtableDefaultImplData<PredicateObligation<'tcx>>
{
debug!("confirm_default_impl_object_candidate({}, {})",
obligation.repr(self.tcx()),
trait_def_id.repr(self.tcx()));
obligation.repr(),
trait_def_id.repr());
assert!(ty::has_attr(self.tcx(), trait_def_id, "rustc_reflect_like"));
@ -2185,7 +2185,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.tcx().sess.bug(
&format!(
"asked to confirm default object implementation for non-object type: {}",
self_ty.repr(self.tcx())));
self_ty.repr()));
}
}
}
@ -2197,7 +2197,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
nested: ty::Binder<Vec<Ty<'tcx>>>)
-> VtableDefaultImplData<PredicateObligation<'tcx>>
{
debug!("vtable_default_impl_data: nested={}", nested.repr(self.tcx()));
debug!("vtable_default_impl_data: nested={}", nested.repr());
let mut obligations = self.collect_predicates_for_types(obligation,
trait_def_id,
@ -2218,7 +2218,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// no Errors in that code above
obligations.append(&mut trait_obligations.unwrap());
debug!("vtable_default_impl_data: obligations={}", obligations.repr(self.tcx()));
debug!("vtable_default_impl_data: obligations={}", obligations.repr());
VtableDefaultImplData {
trait_def_id: trait_def_id,
@ -2233,8 +2233,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
SelectionError<'tcx>>
{
debug!("confirm_impl_candidate({},{})",
obligation.repr(self.tcx()),
impl_def_id.repr(self.tcx()));
obligation.repr(),
impl_def_id.repr());
// First, create the substitutions by matching the impl again,
// this time not in a probe.
@ -2242,7 +2242,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let (substs, skol_map) =
self.rematch_impl(impl_def_id, obligation,
snapshot);
debug!("confirm_impl_candidate substs={}", substs.repr(self.tcx()));
debug!("confirm_impl_candidate substs={}", substs.repr());
Ok(self.vtable_impl(impl_def_id, substs, obligation.cause.clone(),
obligation.recursion_depth + 1, skol_map, snapshot))
})
@ -2258,10 +2258,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> VtableImplData<'tcx, PredicateObligation<'tcx>>
{
debug!("vtable_impl(impl_def_id={}, substs={}, recursion_depth={}, skol_map={})",
impl_def_id.repr(self.tcx()),
substs.repr(self.tcx()),
impl_def_id.repr(),
substs.repr(),
recursion_depth,
skol_map.repr(self.tcx()));
skol_map.repr());
let mut impl_obligations =
self.impl_or_trait_obligations(cause,
@ -2272,8 +2272,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
snapshot);
debug!("vtable_impl: impl_def_id={} impl_obligations={}",
impl_def_id.repr(self.tcx()),
impl_obligations.repr(self.tcx()));
impl_def_id.repr(),
impl_obligations.repr());
impl_obligations.append(&mut substs.obligations);
@ -2287,7 +2287,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> VtableObjectData<'tcx>
{
debug!("confirm_object_candidate({})",
obligation.repr(self.tcx()));
obligation.repr());
// FIXME skipping binder here seems wrong -- we should
// probably flatten the binder from the obligation and the
@ -2329,7 +2329,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> Result<ty::Ty<'tcx>,SelectionError<'tcx>>
{
debug!("confirm_fn_pointer_candidate({})",
obligation.repr(self.tcx()));
obligation.repr());
// ok to skip binder; it is reintroduced below
let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
@ -2356,9 +2356,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
SelectionError<'tcx>>
{
debug!("confirm_closure_candidate({},{},{})",
obligation.repr(self.tcx()),
closure_def_id.repr(self.tcx()),
substs.repr(self.tcx()));
obligation.repr(),
closure_def_id.repr(),
substs.repr());
let Normalized {
value: trait_ref,
@ -2366,9 +2366,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
} = self.closure_trait_ref(obligation, closure_def_id, substs);
debug!("confirm_closure_candidate(closure_def_id={}, trait_ref={}, obligations={})",
closure_def_id.repr(self.tcx()),
trait_ref.repr(self.tcx()),
obligations.repr(self.tcx()));
closure_def_id.repr(),
trait_ref.repr(),
obligations.repr());
try!(self.confirm_poly_trait_refs(obligation.cause.clone(),
obligation.predicate.to_poly_trait_ref(),
@ -2437,7 +2437,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let target = self.infcx.shallow_resolve(obligation.predicate.0.input_types()[0]);
debug!("confirm_builtin_unsize_candidate(source={}, target={})",
source.repr(tcx), target.repr(tcx));
source.repr(), target.repr());
let mut nested = vec![];
match (&source.sty, &target.sty) {
@ -2614,8 +2614,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
Err(()) => {
self.tcx().sess.bug(
&format!("Impl {} was matchable against {} but now is not",
impl_def_id.repr(self.tcx()),
obligation.repr(self.tcx())));
impl_def_id.repr(),
obligation.repr()));
}
}
}
@ -2656,10 +2656,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
debug!("match_impl(impl_def_id={}, obligation={}, \
impl_trait_ref={}, skol_obligation_trait_ref={})",
impl_def_id.repr(self.tcx()),
obligation.repr(self.tcx()),
impl_trait_ref.repr(self.tcx()),
skol_obligation_trait_ref.repr(self.tcx()));
impl_def_id.repr(),
obligation.repr(),
impl_trait_ref.repr(),
skol_obligation_trait_ref.repr());
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
if let Err(e) = self.infcx.sub_trait_refs(false,
@ -2677,7 +2677,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
return Err(());
}
debug!("match_impl: success impl_substs={}", impl_substs.repr(self.tcx()));
debug!("match_impl: success impl_substs={}", impl_substs.repr());
Ok((Normalized {
value: impl_substs,
obligations: impl_trait_ref.obligations
@ -2729,8 +2729,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> Result<(),()>
{
debug!("match_poly_trait_ref: obligation={} poly_trait_ref={}",
obligation.repr(self.tcx()),
poly_trait_ref.repr(self.tcx()));
obligation.repr(),
poly_trait_ref.repr());
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
match self.infcx.sub_poly_trait_refs(false,
@ -2770,14 +2770,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let impl_self_ty = impl_self_ty.subst(self.tcx(), &impl_substs);
debug!("match_impl_self_types(obligation_self_ty={}, impl_self_ty={})",
obligation_self_ty.repr(self.tcx()),
impl_self_ty.repr(self.tcx()));
obligation_self_ty.repr(),
impl_self_ty.repr());
match self.match_self_types(obligation_cause,
impl_self_ty,
obligation_self_ty) {
Ok(()) => {
debug!("Matched impl_substs={}", impl_substs.repr(self.tcx()));
debug!("Matched impl_substs={}", impl_substs.repr());
Ok(impl_substs)
}
Err(()) => {
@ -2889,7 +2889,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
snapshot: &infer::CombinedSnapshot)
-> Vec<PredicateObligation<'tcx>>
{
debug!("impl_or_trait_obligations(def_id={})", def_id.repr(self.tcx()));
debug!("impl_or_trait_obligations(def_id={})", def_id.repr());
let predicates = ty::lookup_predicates(self.tcx(), def_id);
let predicates = predicates.instantiate(self.tcx(), substs);
@ -2941,8 +2941,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-> Vec<ty::PolyTraitRef<'tcx>>
{
debug!("upcast(obj_trait_ref={}, obligation={})",
obj_trait_ref.repr(self.tcx()),
obligation.repr(self.tcx()));
obj_trait_ref.repr(),
obligation.repr());
let obligation_def_id = obligation.predicate.def_id();
let mut upcast_trait_refs = util::upcast(self.tcx(), obj_trait_ref, obligation_def_id);
@ -2958,28 +2958,28 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.infcx.probe(|_| self.match_poly_trait_ref(obligation, upcast_trait_ref)).is_ok()
});
debug!("upcast: upcast_trait_refs={}", upcast_trait_refs.repr(self.tcx()));
debug!("upcast: upcast_trait_refs={}", upcast_trait_refs.repr());
upcast_trait_refs
}
}
impl<'tcx> Repr<'tcx> for SelectionCandidate<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for SelectionCandidate<'tcx> {
fn repr(&self) -> String {
match *self {
PhantomFnCandidate => format!("PhantomFnCandidate"),
ErrorCandidate => format!("ErrorCandidate"),
BuiltinCandidate(b) => format!("BuiltinCandidate({:?})", b),
BuiltinObjectCandidate => format!("BuiltinObjectCandidate"),
BuiltinUnsizeCandidate => format!("BuiltinUnsizeCandidate"),
ParamCandidate(ref a) => format!("ParamCandidate({})", a.repr(tcx)),
ImplCandidate(a) => format!("ImplCandidate({})", a.repr(tcx)),
ParamCandidate(ref a) => format!("ParamCandidate({})", a.repr()),
ImplCandidate(a) => format!("ImplCandidate({})", a.repr()),
DefaultImplCandidate(t) => format!("DefaultImplCandidate({:?})", t),
DefaultImplObjectCandidate(t) => format!("DefaultImplObjectCandidate({:?})", t),
ProjectionCandidate => format!("ProjectionCandidate"),
FnPointerCandidate => format!("FnPointerCandidate"),
ObjectCandidate => format!("ObjectCandidate"),
ClosureCandidate(c, ref s) => {
format!("ClosureCandidate({:?},{})", c, s.repr(tcx))
format!("ClosureCandidate({:?},{})", c, s.repr())
}
}
}
@ -3032,10 +3032,10 @@ impl<'o,'tcx> Iterator for TraitObligationStackList<'o,'tcx>{
}
}
impl<'o,'tcx> Repr<'tcx> for TraitObligationStack<'o,'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'o,'tcx> Repr for TraitObligationStack<'o,'tcx> {
fn repr(&self) -> String {
format!("TraitObligationStack({})",
self.obligation.repr(tcx))
self.obligation.repr())
}
}

102
src/librustc/middle/traits/util.rs
View file

@ -126,7 +126,7 @@ impl<'cx, 'tcx> Elaborator<'cx, 'tcx> {
.collect();
debug!("super_predicates: data={} predicates={}",
data.repr(self.tcx), predicates.repr(self.tcx));
data.repr(), predicates.repr());
// Only keep those bounds that we haven't already
// seen. This is necessary to prevent infinite
@ -328,7 +328,7 @@ pub fn predicates_for_generics<'tcx>(tcx: &ty::ctxt<'tcx>,
-> Vec<PredicateObligation<'tcx>>
{
debug!("predicates_for_generics(generic_bounds={})",
generic_bounds.repr(tcx));
generic_bounds.repr());
generic_bounds.predicates.iter().map(|predicate| {
Obligation { cause: cause.clone(),
@ -486,116 +486,116 @@ pub fn closure_trait_ref_and_return_type<'tcx>(
ty::Binder((trait_ref, sig.0.output.unwrap_or(ty::mk_nil(tcx))))
}
impl<'tcx,O:Repr<'tcx>> Repr<'tcx> for super::Obligation<'tcx, O> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx,O:Repr> Repr for super::Obligation<'tcx, O> {
fn repr(&self) -> String {
format!("Obligation(predicate={},depth={})",
self.predicate.repr(tcx),
self.predicate.repr(),
self.recursion_depth)
}
}
impl<'tcx, N:Repr<'tcx>> Repr<'tcx> for super::Vtable<'tcx, N> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx, N:Repr> Repr for super::Vtable<'tcx, N> {
fn repr(&self) -> String {
match *self {
super::VtableImpl(ref v) =>
v.repr(tcx),
v.repr(),
super::VtableDefaultImpl(ref t) =>
t.repr(tcx),
t.repr(),
super::VtableClosure(ref d) =>
d.repr(tcx),
d.repr(),
super::VtableFnPointer(ref d) =>
format!("VtableFnPointer({})",
d.repr(tcx)),
d.repr()),
super::VtableObject(ref d) =>
format!("VtableObject({})",
d.repr(tcx)),
d.repr()),
super::VtableParam(ref n) =>
format!("VtableParam({})",
n.repr(tcx)),
n.repr()),
super::VtableBuiltin(ref d) =>
d.repr(tcx)
d.repr()
}
}
}
impl<'tcx, N:Repr<'tcx>> Repr<'tcx> for super::VtableImplData<'tcx, N> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx, N:Repr> Repr for super::VtableImplData<'tcx, N> {
fn repr(&self) -> String {
format!("VtableImpl(impl_def_id={}, substs={}, nested={})",
self.impl_def_id.repr(tcx),
self.substs.repr(tcx),
self.nested.repr(tcx))
self.impl_def_id.repr(),
self.substs.repr(),
self.nested.repr())
}
}
impl<'tcx, N:Repr<'tcx>> Repr<'tcx> for super::VtableClosureData<'tcx, N> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx, N:Repr> Repr for super::VtableClosureData<'tcx, N> {
fn repr(&self) -> String {
format!("VtableClosure(closure_def_id={}, substs={}, nested={})",
self.closure_def_id.repr(tcx),
self.substs.repr(tcx),
self.nested.repr(tcx))
self.closure_def_id.repr(),
self.substs.repr(),
self.nested.repr())
}
}
impl<'tcx, N:Repr<'tcx>> Repr<'tcx> for super::VtableBuiltinData<N> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx, N:Repr> Repr for super::VtableBuiltinData<N> {
fn repr(&self) -> String {
format!("VtableBuiltin(nested={})",
self.nested.repr(tcx))
self.nested.repr())
}
}
impl<'tcx, N:Repr<'tcx>> Repr<'tcx> for super::VtableDefaultImplData<N> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx, N:Repr> Repr for super::VtableDefaultImplData<N> {
fn repr(&self) -> String {
format!("VtableDefaultImplData(trait_def_id={}, nested={})",
self.trait_def_id.repr(tcx),
self.nested.repr(tcx))
self.trait_def_id.repr(),
self.nested.repr())
}
}
impl<'tcx> Repr<'tcx> for super::VtableObjectData<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for super::VtableObjectData<'tcx> {
fn repr(&self) -> String {
format!("VtableObject(object_ty={})",
self.object_ty.repr(tcx))
self.object_ty.repr())
}
}
impl<'tcx> Repr<'tcx> for super::SelectionError<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for super::SelectionError<'tcx> {
fn repr(&self) -> String {
match *self {
super::Unimplemented =>
format!("Unimplemented"),
super::OutputTypeParameterMismatch(ref a, ref b, ref c) =>
format!("OutputTypeParameterMismatch({},{},{})",
a.repr(tcx),
b.repr(tcx),
c.repr(tcx)),
a.repr(),
b.repr(),
c.repr()),
super::TraitNotObjectSafe(ref tr) =>
format!("TraitNotObjectSafe({})",
tr.repr(tcx))
tr.repr())
}
}
}
impl<'tcx> Repr<'tcx> for super::FulfillmentError<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for super::FulfillmentError<'tcx> {
fn repr(&self) -> String {
format!("FulfillmentError({},{})",
self.obligation.repr(tcx),
self.code.repr(tcx))
self.obligation.repr(),
self.code.repr())
}
}
impl<'tcx> Repr<'tcx> for super::FulfillmentErrorCode<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for super::FulfillmentErrorCode<'tcx> {
fn repr(&self) -> String {
match *self {
super::CodeSelectionError(ref o) => o.repr(tcx),
super::CodeProjectionError(ref o) => o.repr(tcx),
super::CodeSelectionError(ref o) => o.repr(),
super::CodeProjectionError(ref o) => o.repr(),
super::CodeAmbiguity => format!("Ambiguity")
}
}
@ -611,9 +611,9 @@ impl<'tcx> fmt::Debug for super::FulfillmentErrorCode<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for super::MismatchedProjectionTypes<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
self.err.repr(tcx)
impl<'tcx> Repr for super::MismatchedProjectionTypes<'tcx> {
fn repr(&self) -> String {
self.err.repr()
}
}

172
src/librustc/middle/ty.rs
View file

@ -2786,7 +2786,7 @@ impl<'tcx> TraitDef<'tcx> {
impl_def_id: DefId,
impl_trait_ref: TraitRef<'tcx>) {
debug!("TraitDef::record_impl for {}, from {}",
self.repr(tcx), impl_trait_ref.repr(tcx));
self.repr(), impl_trait_ref.repr());
// We don't want to borrow_mut after we already populated all impls,
// so check if an impl is present with an immutable borrow first.
@ -3710,7 +3710,7 @@ pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
TyArray(ty, _) | TySlice(ty) => ty,
TyStr => mk_mach_uint(cx, ast::TyU8),
_ => cx.sess.bug(&format!("sequence_element_type called on non-sequence value: {}",
ty.user_string(cx))),
ty.user_string())),
}
}
@ -4180,7 +4180,7 @@ fn type_impls_bound<'a,'tcx>(param_env: Option<&ParameterEnvironment<'a,'tcx>>,
let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, ty, bound, span);
debug!("type_impls_bound({}, {:?}) = {:?}",
ty.repr(tcx),
ty.repr(),
bound,
is_impld);
@ -4282,19 +4282,19 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool {
fn type_requires<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec<DefId>,
r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool {
debug!("type_requires({}, {})?",
r_ty.repr(cx), ty.repr(cx));
r_ty.repr(), ty.repr());
let r = r_ty == ty || subtypes_require(cx, seen, r_ty, ty);
debug!("type_requires({}, {})? {:?}",
r_ty.repr(cx), ty.repr(cx), r);
r_ty.repr(), ty.repr(), r);
return r;
}
fn subtypes_require<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec<DefId>,
r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool {
debug!("subtypes_require({}, {})?",
r_ty.repr(cx), ty.repr(cx));
r_ty.repr(), ty.repr());
let r = match ty.sty {
// fixed length vectors need special treatment compared to
@ -4373,7 +4373,7 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool {
};
debug!("subtypes_require({}, {})? {:?}",
r_ty.repr(cx), ty.repr(cx), r);
r_ty.repr(), ty.repr(), r);
return r;
}
@ -4479,7 +4479,7 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
fn is_type_structurally_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span,
seen: &mut Vec<Ty<'tcx>>,
ty: Ty<'tcx>) -> Representability {
debug!("is_type_structurally_recursive: {}", ty.repr(cx));
debug!("is_type_structurally_recursive: {}", ty.repr());
match ty.sty {
TyStruct(did, _) | TyEnum(did, _) => {
@ -4499,8 +4499,8 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
Some(&seen_type) => {
if same_struct_or_enum_def_id(seen_type, did) {
debug!("SelfRecursive: {} contains {}",
seen_type.repr(cx),
ty.repr(cx));
seen_type.repr(),
ty.repr());
return SelfRecursive;
}
}
@ -4519,8 +4519,8 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
for &seen_type in iter {
if same_type(ty, seen_type) {
debug!("ContainsRecursive: {} contains {}",
seen_type.repr(cx),
ty.repr(cx));
seen_type.repr(),
ty.repr());
return ContainsRecursive;
}
}
@ -4540,14 +4540,14 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
}
}
debug!("is_type_representable: {}", ty.repr(cx));
debug!("is_type_representable: {}", ty.repr());
// To avoid a stack overflow when checking an enum variant or struct that
// contains a different, structurally recursive type, maintain a stack
// of seen types and check recursion for each of them (issues #3008, #3779).
let mut seen: Vec<Ty> = Vec::new();
let r = is_type_structurally_recursive(cx, sp, &mut seen, ty);
debug!("is_type_representable: {} is {:?}", ty.repr(cx), r);
debug!("is_type_representable: {} is {:?}", ty.repr(), r);
r
}
@ -4949,7 +4949,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>,
_ => {
cx.sess.bug(
&format!("AdjustReifyFnPointer adjustment on non-fn-item: \
{}", unadjusted_ty.repr(cx)));
{}", unadjusted_ty.repr()));
}
}
}
@ -4990,7 +4990,7 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>,
span,
&format!("the {}th autoderef failed: {}",
i,
adjusted_ty.user_string(cx))
adjusted_ty.user_string())
);
}
}
@ -5232,11 +5232,11 @@ pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem])
trait_items.iter().position(|m| m.name() == id)
}
pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String {
pub fn ty_sort_string(cx: &ctxt, ty: Ty) -> String {
match ty.sty {
TyBool | TyChar | TyInt(_) |
TyUint(_) | TyFloat(_) | TyStr => ty.user_string(cx),
TyTuple(ref tys) if tys.is_empty() => ty.user_string(cx),
TyUint(_) | TyFloat(_) | TyStr => ty.user_string(),
TyTuple(ref tys) if tys.is_empty() => ty.user_string(),
TyEnum(id, _) => format!("enum `{}`", item_path_str(cx, id)),
TyBox(_) => "box".to_string(),
@ -5272,9 +5272,9 @@ pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String {
}
}
impl<'tcx> Repr<'tcx> for ty::type_err<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
ty::type_err_to_str(tcx, self)
impl<'tcx> Repr for ty::type_err<'tcx> {
fn repr(&self) -> String {
tls::with(|tcx| ty::type_err_to_str(tcx, self))
}
}
@ -5282,7 +5282,7 @@ impl<'tcx> Repr<'tcx> for ty::type_err<'tcx> {
/// in parentheses after some larger message. You should also invoke `note_and_explain_type_err()`
/// afterwards to present additional details, particularly when it comes to lifetime-related
/// errors.
pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String {
pub fn type_err_to_str(cx: &ctxt, err: &type_err) -> String {
match *err {
terr_cyclic_ty => "cyclic type of infinite size".to_string(),
terr_mismatch => "types differ".to_string(),
@ -5336,12 +5336,12 @@ pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String {
terr_regions_insufficiently_polymorphic(br, _) => {
format!("expected bound lifetime parameter {}, \
found concrete lifetime",
br.user_string(cx))
br.user_string())
}
terr_regions_overly_polymorphic(br, _) => {
format!("expected concrete lifetime, \
found bound lifetime parameter {}",
br.user_string(cx))
br.user_string())
}
terr_sorts(values) => {
// A naive approach to making sure that we're not reporting silly errors such as:
@ -5362,14 +5362,14 @@ pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String {
terr_builtin_bounds(values) => {
if values.expected.is_empty() {
format!("expected no bounds, found `{}`",
values.found.user_string(cx))
values.found.user_string())
} else if values.found.is_empty() {
format!("expected bounds `{}`, found no bounds",
values.expected.user_string(cx))
values.expected.user_string())
} else {
format!("expected bounds `{}`, found bounds `{}`",
values.expected.user_string(cx),
values.found.user_string(cx))
values.expected.user_string(),
values.found.user_string())
}
}
terr_integer_as_char => {
@ -6010,7 +6010,7 @@ fn report_discrim_overflow(cx: &ctxt,
let computed_value = repr_type.disr_wrap_incr(Some(prev_val));
let computed_value = repr_type.disr_string(computed_value);
let prev_val = repr_type.disr_string(prev_val);
let repr_type = repr_type.to_ty(cx).user_string(cx);
let repr_type = repr_type.to_ty(cx).user_string();
span_err!(cx.sess, variant_span, E0370,
"enum discriminant overflowed on value after {}: {}; \
set explicitly via {} = {} if that is desired outcome",
@ -6503,8 +6503,8 @@ pub fn required_region_bounds<'tcx>(tcx: &ctxt<'tcx>,
-> Vec<ty::Region>
{
debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})",
erased_self_ty.repr(tcx),
predicates.repr(tcx));
erased_self_ty.repr(),
predicates.repr());
assert!(!erased_self_ty.has_escaping_regions());
@ -6622,7 +6622,7 @@ pub fn populate_implementations_for_trait_if_necessary(tcx: &ctxt, trait_id: ast
return;
}
debug!("populate_implementations_for_trait_if_necessary: searching for {}", def.repr(tcx));
debug!("populate_implementations_for_trait_if_necessary: searching for {}", def.repr());
if csearch::is_defaulted_trait(&tcx.sess.cstore, trait_id) {
record_trait_has_default_impl(tcx, trait_id);
@ -6931,7 +6931,7 @@ pub fn construct_free_substs<'a,'tcx>(
defs: &[TypeParameterDef<'tcx>]) {
for def in defs {
debug!("construct_parameter_environment(): push_types_from_defs: def={:?}",
def.repr(tcx));
def.repr());
let ty = ty::mk_param_from_def(tcx, def);
types.push(def.space, ty);
}
@ -6964,8 +6964,8 @@ pub fn construct_parameter_environment<'a,'tcx>(
debug!("construct_parameter_environment: free_id={:?} free_subst={:?} predicates={:?}",
free_id,
free_substs.repr(tcx),
predicates.repr(tcx));
free_substs.repr(),
predicates.repr());
//
// Finally, we have to normalize the bounds in the environment, in
@ -7221,7 +7221,7 @@ pub fn liberate_late_bound_regions<'tcx, T>(
all_outlive_scope: region::DestructionScopeData,
value: &Binder<T>)
-> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
ty_fold::replace_late_bound_regions(
tcx, value,
@ -7232,7 +7232,7 @@ pub fn count_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
value: &Binder<T>)
-> usize
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
let (_, skol_map) = ty_fold::replace_late_bound_regions(tcx, value, |_| ty::ReStatic);
skol_map.len()
@ -7242,7 +7242,7 @@ pub fn binds_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
value: &Binder<T>)
-> bool
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
count_late_bound_regions(tcx, value) > 0
}
@ -7253,7 +7253,7 @@ pub fn flatten_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
bound2_value: &Binder<Binder<T>>)
-> Binder<T>
where T: TypeFoldable<'tcx> + Repr<'tcx>
where T: TypeFoldable<'tcx> + Repr
{
let bound0_value = bound2_value.skip_binder().skip_binder();
let value = ty_fold::fold_regions(tcx, bound0_value, |region, current_depth| {
@ -7275,7 +7275,7 @@ pub fn no_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
value: &Binder<T>)
-> Option<T>
where T : TypeFoldable<'tcx> + Repr<'tcx> + Clone
where T : TypeFoldable<'tcx> + Repr + Clone
{
if binds_late_bound_regions(tcx, value) {
None
@ -7290,7 +7290,7 @@ pub fn erase_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
value: &Binder<T>)
-> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
ty_fold::replace_late_bound_regions(tcx, value, |_| ty::ReStatic).0
}
@ -7307,7 +7307,7 @@ pub fn anonymize_late_bound_regions<'tcx, T>(
tcx: &ctxt<'tcx>,
sig: &Binder<T>)
-> Binder<T>
where T : TypeFoldable<'tcx> + Repr<'tcx>,
where T : TypeFoldable<'tcx> + Repr,
{
let mut counter = 0;
ty::Binder(ty_fold::replace_late_bound_regions(tcx, sig, |_| {
@ -7327,8 +7327,8 @@ impl DebruijnIndex {
}
}
impl<'tcx> Repr<'tcx> for AutoAdjustment<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for AutoAdjustment<'tcx> {
fn repr(&self) -> String {
match *self {
AdjustReifyFnPointer => {
format!("AdjustReifyFnPointer")
@ -7337,24 +7337,24 @@ impl<'tcx> Repr<'tcx> for AutoAdjustment<'tcx> {
format!("AdjustUnsafeFnPointer")
}
AdjustDerefRef(ref data) => {
data.repr(tcx)
data.repr()
}
}
}
}
impl<'tcx> Repr<'tcx> for AutoDerefRef<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for AutoDerefRef<'tcx> {
fn repr(&self) -> String {
format!("AutoDerefRef({}, unsize={}, {})",
self.autoderefs, self.unsize.repr(tcx), self.autoref.repr(tcx))
self.autoderefs, self.unsize.repr(), self.autoref.repr())
}
}
impl<'tcx> Repr<'tcx> for AutoRef<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for AutoRef<'tcx> {
fn repr(&self) -> String {
match *self {
AutoPtr(a, b) => {
format!("AutoPtr({},{:?})", a.repr(tcx), b)
format!("AutoPtr({},{:?})", a.repr(), b)
}
AutoUnsafe(ref a) => {
format!("AutoUnsafe({:?})", a)
@ -7363,22 +7363,22 @@ impl<'tcx> Repr<'tcx> for AutoRef<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for TraitTy<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for TraitTy<'tcx> {
fn repr(&self) -> String {
format!("TraitTy({},{})",
self.principal.repr(tcx),
self.bounds.repr(tcx))
self.principal.repr(),
self.bounds.repr())
}
}
impl<'tcx> Repr<'tcx> for ty::Predicate<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for ty::Predicate<'tcx> {
fn repr(&self) -> String {
match *self {
Predicate::Trait(ref a) => a.repr(tcx),
Predicate::Equate(ref pair) => pair.repr(tcx),
Predicate::RegionOutlives(ref pair) => pair.repr(tcx),
Predicate::TypeOutlives(ref pair) => pair.repr(tcx),
Predicate::Projection(ref pair) => pair.repr(tcx),
Predicate::Trait(ref a) => a.repr(),
Predicate::Equate(ref pair) => pair.repr(),
Predicate::RegionOutlives(ref pair) => pair.repr(),
Predicate::TypeOutlives(ref pair) => pair.repr(),
Predicate::Projection(ref pair) => pair.repr(),
}
}
}
@ -7584,11 +7584,11 @@ impl<'tcx> RegionEscape for ProjectionTy<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for ty::ProjectionPredicate<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for ty::ProjectionPredicate<'tcx> {
fn repr(&self) -> String {
format!("ProjectionPredicate({}, {})",
self.projection_ty.repr(tcx),
self.ty.repr(tcx))
self.projection_ty.repr(),
self.ty.repr())
}
}
@ -7826,48 +7826,48 @@ impl ReferencesError for Region
}
}
impl<'tcx> Repr<'tcx> for ClosureTy<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for ClosureTy<'tcx> {
fn repr(&self) -> String {
format!("ClosureTy({},{},{})",
self.unsafety,
self.sig.repr(tcx),
self.sig.repr(),
self.abi)
}
}
impl<'tcx> Repr<'tcx> for ClosureUpvar<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for ClosureUpvar<'tcx> {
fn repr(&self) -> String {
format!("ClosureUpvar({},{})",
self.def.repr(tcx),
self.ty.repr(tcx))
self.def.repr(),
self.ty.repr())
}
}
impl<'tcx> Repr<'tcx> for field<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for field<'tcx> {
fn repr(&self) -> String {
format!("field({},{})",
self.name.repr(tcx),
self.mt.repr(tcx))
self.name.repr(),
self.mt.repr())
}
}
impl<'a, 'tcx> Repr<'tcx> for ParameterEnvironment<'a, 'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'a, 'tcx> Repr for ParameterEnvironment<'a, 'tcx> {
fn repr(&self) -> String {
format!("ParameterEnvironment(\
free_substs={}, \
implicit_region_bound={}, \
caller_bounds={})",
self.free_substs.repr(tcx),
self.implicit_region_bound.repr(tcx),
self.caller_bounds.repr(tcx))
self.free_substs.repr(),
self.implicit_region_bound.repr(),
self.caller_bounds.repr())
}
}
impl<'tcx> Repr<'tcx> for ObjectLifetimeDefault {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
impl<'tcx> Repr for ObjectLifetimeDefault {
fn repr(&self) -> String {
match *self {
ObjectLifetimeDefault::Ambiguous => format!("Ambiguous"),
ObjectLifetimeDefault::Specific(ref r) => r.repr(tcx),
ObjectLifetimeDefault::Specific(ref r) => r.repr(),
}
}
}

20
src/librustc/middle/ty_fold.rs
View file

@ -50,7 +50,7 @@ use util::ppaux::Repr;
/// The TypeFoldable trait is implemented for every type that can be folded.
/// Basically, every type that has a corresponding method in TypeFolder.
pub trait TypeFoldable<'tcx>: Repr<'tcx> + Clone {
pub trait TypeFoldable<'tcx>: Repr + Clone {
fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self;
}
@ -74,7 +74,7 @@ pub trait TypeFolder<'tcx> : Sized {
fn exit_region_binder(&mut self) { }
fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T>
where T : TypeFoldable<'tcx> + Repr<'tcx> + Clone
where T : TypeFoldable<'tcx> + Repr + Clone
{
// FIXME(#20526) this should replace `enter_region_binder`/`exit_region_binder`.
super_fold_binder(self, t)
@ -197,7 +197,7 @@ impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Vec<T> {
}
}
impl<'tcx, T:TypeFoldable<'tcx>+Repr<'tcx>+Clone> TypeFoldable<'tcx> for ty::Binder<T> {
impl<'tcx, T:TypeFoldable<'tcx>+Repr+Clone> TypeFoldable<'tcx> for ty::Binder<T> {
fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::Binder<T> {
folder.fold_binder(self)
}
@ -843,12 +843,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionFolder<'a, 'tcx>
match r {
ty::ReLateBound(debruijn, _) if debruijn.depth < self.current_depth => {
debug!("RegionFolder.fold_region({}) skipped bound region (current depth={})",
r.repr(self.tcx()), self.current_depth);
r.repr(), self.current_depth);
r
}
_ => {
debug!("RegionFolder.fold_region({}) folding free region (current_depth={})",
r.repr(self.tcx()), self.current_depth);
r.repr(), self.current_depth);
(self.fld_r)(r, self.current_depth)
}
}
@ -885,9 +885,9 @@ pub fn replace_late_bound_regions<'tcx,T,F>(tcx: &ty::ctxt<'tcx>,
mut f: F)
-> (T, FnvHashMap<ty::BoundRegion, ty::Region>)
where F : FnMut(ty::BoundRegion) -> ty::Region,
T : TypeFoldable<'tcx> + Repr<'tcx>,
T : TypeFoldable<'tcx> + Repr,
{
debug!("replace_late_bound_regions({})", value.repr(tcx));
debug!("replace_late_bound_regions({})", value.repr());
let mut replacer = RegionReplacer::new(tcx, &mut f);
let result = value.skip_binder().fold_with(&mut replacer);
(result, replacer.map)
@ -917,7 +917,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionReplacer<'a, 'tcx>
match r {
ty::ReLateBound(debruijn, br) if debruijn.depth == self.current_depth => {
debug!("RegionReplacer.fold_region({}) folding region (current_depth={})",
r.repr(self.tcx()), self.current_depth);
r.repr(), self.current_depth);
let fld_r = &mut self.fld_r;
let region = *self.map.entry(br).or_insert_with(|| fld_r(br));
if let ty::ReLateBound(debruijn1, br) = region {
@ -994,10 +994,10 @@ pub fn shift_region(region: ty::Region, amount: u32) -> ty::Region {
}
}
pub fn shift_regions<'tcx, T:TypeFoldable<'tcx>+Repr<'tcx>>(tcx: &ty::ctxt<'tcx>,
pub fn shift_regions<'tcx, T:TypeFoldable<'tcx>+Repr>(tcx: &ty::ctxt<'tcx>,
amount: u32, value: &T) -> T {
debug!("shift_regions(value={}, amount={})",
value.repr(tcx), amount);
value.repr(), amount);
value.fold_with(&mut RegionFolder::new(tcx, &mut |region, _current_depth| {
shift_region(region, amount)

6
src/librustc/middle/ty_match.rs
View file

@ -55,14 +55,14 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Match<'a, 'tcx> {
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
debug!("{}.regions({}, {})",
self.tag(),
a.repr(self.tcx()),
b.repr(self.tcx()));
a.repr(),
b.repr());
Ok(a)
}
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
debug!("{}.tys({}, {})", self.tag(),
a.repr(self.tcx()), b.repr(self.tcx()));
a.repr(), b.repr());
if a == b { return Ok(a); }
match (&a.sty, &b.sty) {

16
src/librustc/middle/ty_relate/mod.rs
View file

@ -81,8 +81,8 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::mt<'tcx> {
{
debug!("{}.mts({}, {})",
relation.tag(),
a.repr(relation.tcx()),
b.repr(relation.tcx()));
a.repr(),
b.repr());
if a.mutbl != b.mutbl {
Err(ty::terr_mutability)
} else {
@ -108,9 +108,9 @@ fn relate_item_substs<'a,'tcx:'a,R>(relation: &mut R,
where R: TypeRelation<'a,'tcx>
{
debug!("substs: item_def_id={} a_subst={} b_subst={}",
item_def_id.repr(relation.tcx()),
a_subst.repr(relation.tcx()),
b_subst.repr(relation.tcx()));
item_def_id.repr(),
a_subst.repr(),
b_subst.repr());
let variances;
let opt_variances = if relation.tcx().variance_computed.get() {
@ -196,9 +196,9 @@ fn relate_region_params<'a,'tcx:'a,R>(relation: &mut R,
debug!("relate_region_params(a_rs={}, \
b_rs={}, variances={})",
a_rs.repr(tcx),
b_rs.repr(tcx),
variances.repr(tcx));
a_rs.repr(),
b_rs.repr(),
variances.repr());
assert_eq!(num_region_params,
variances.map_or(num_region_params,

1082
src/librustc/util/ppaux.rs
View file

File diff suppressed because it is too large Load diff

28
src/librustc_borrowck/borrowck/check_loans.rs
View file

@ -98,7 +98,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> {
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
debug!("consume(consume_id={}, cmt={}, mode={:?})",
consume_id, cmt.repr(self.tcx()), mode);
consume_id, cmt.repr(), mode);
self.consume_common(consume_id, consume_span, cmt, mode);
}
@ -113,8 +113,8 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> {
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})",
consume_pat.repr(self.tcx()),
cmt.repr(self.tcx()),
consume_pat.repr(),
cmt.repr(),
mode);
self.consume_common(consume_pat.id, consume_pat.span, cmt, mode);
@ -130,7 +130,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> {
{
debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \
bk={:?}, loan_cause={:?})",
borrow_id, cmt.repr(self.tcx()), loan_region,
borrow_id, cmt.repr(), loan_region,
bk, loan_cause);
match opt_loan_path(&cmt) {
@ -154,7 +154,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> {
mode: euv::MutateMode)
{
debug!("mutate(assignment_id={}, assignee_cmt={})",
assignment_id, assignee_cmt.repr(self.tcx()));
assignment_id, assignee_cmt.repr());
match opt_loan_path(&assignee_cmt) {
Some(lp) => {
@ -385,8 +385,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
//! simultaneously.
debug!("report_error_if_loans_conflict(old_loan={}, new_loan={})",
old_loan.repr(self.tcx()),
new_loan.repr(self.tcx()));
old_loan.repr(),
new_loan.repr());
// Should only be called for loans that are in scope at the same time.
assert!(self.tcx().region_maps.scopes_intersect(old_loan.kill_scope,
@ -409,8 +409,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
debug!("report_error_if_loan_conflicts_with_restriction(\
loan1={}, loan2={})",
loan1.repr(self.tcx()),
loan2.repr(self.tcx()));
loan1.repr(),
loan2.repr());
if compatible_borrow_kinds(loan1.kind, loan2.kind) {
return true;
@ -674,7 +674,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
-> UseError<'tcx> {
debug!("analyze_restrictions_on_use(expr_id={}, use_path={})",
self.tcx().map.node_to_string(expr_id),
use_path.repr(self.tcx()));
use_path.repr());
let mut ret = UseOk;
@ -699,7 +699,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
use_kind: MovedValueUseKind,
lp: &Rc<LoanPath<'tcx>>) {
debug!("check_if_path_is_moved(id={}, use_kind={:?}, lp={})",
id, use_kind, lp.repr(self.bccx.tcx));
id, use_kind, lp.repr());
// FIXME (22079): if you find yourself tempted to cut and paste
// the body below and then specializing the error reporting,
@ -792,7 +792,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
assignment_span: Span,
assignee_cmt: mc::cmt<'tcx>,
mode: euv::MutateMode) {
debug!("check_assignment(assignee_cmt={})", assignee_cmt.repr(self.tcx()));
debug!("check_assignment(assignee_cmt={})", assignee_cmt.repr());
// Mutable values can be assigned, as long as they obey loans
// and aliasing restrictions:
@ -884,7 +884,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
//! `used_mut_nodes` table here.
loop {
debug!("mark_variable_as_used_mut(cmt={})", cmt.repr(this.tcx()));
debug!("mark_variable_as_used_mut(cmt={})", cmt.repr());
match cmt.cat.clone() {
mc::cat_upvar(mc::Upvar { id: ty::UpvarId { var_id: id, .. }, .. }) |
mc::cat_local(id) => {
@ -930,7 +930,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
let guarantor = cmt.guarantor();
debug!("check_for_aliasable_mutable_writes(cmt={}, guarantor={})",
cmt.repr(this.tcx()), guarantor.repr(this.tcx()));
cmt.repr(), guarantor.repr());
if let mc::cat_deref(ref b, _, mc::BorrowedPtr(ty::MutBorrow, _)) = guarantor.cat {
// Statically prohibit writes to `&mut` when aliasable
check_for_aliasability_violation(this, span, b.clone());

14
src/librustc_borrowck/borrowck/fragments.rs
View file

@ -43,7 +43,7 @@ enum Fragment {
impl Fragment {
fn loan_path_repr<'tcx>(&self, move_data: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) -> String {
let repr = |mpi| move_data.path_loan_path(mpi).repr(tcx);
let repr = |mpi| move_data.path_loan_path(mpi).repr();
match *self {
Just(mpi) => repr(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", repr(mpi)),
@ -53,7 +53,7 @@ impl Fragment {
fn loan_path_user_string<'tcx>(&self,
move_data: &MoveData<'tcx>,
tcx: &ty::ctxt<'tcx>) -> String {
let user_string = |mpi| move_data.path_loan_path(mpi).user_string(tcx);
let user_string = |mpi| move_data.path_loan_path(mpi).user_string();
match *self {
Just(mpi) => user_string(mpi),
AllButOneFrom(mpi) => format!("$(allbutone {})", user_string(mpi)),
@ -126,7 +126,7 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>,
let instrument_all_paths = |kind, vec_rc: &Vec<MovePathIndex>| {
for (i, mpi) in vec_rc.iter().enumerate() {
let render = || this.path_loan_path(*mpi).user_string(tcx);
let render = || this.path_loan_path(*mpi).user_string();
if span_err {
tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
}
@ -172,7 +172,7 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
let mut assigned = mem::replace(&mut fragments.assigned_leaf_paths, vec![]);
let path_lps = |mpis: &[MovePathIndex]| -> Vec<String> {
mpis.iter().map(|mpi| this.path_loan_path(*mpi).repr(tcx)).collect()
mpis.iter().map(|mpi| this.path_loan_path(*mpi).repr()).collect()
};
let frag_lps = |fs: &[Fragment]| -> Vec<String> {
@ -344,7 +344,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>,
mc::PositionalField(tuple_idx) => tuple_idx,
mc::NamedField(_) =>
panic!("tuple type {} should not have named fields.",
parent_ty.repr(tcx)),
parent_ty.repr()),
};
let tuple_len = v.len();
for i in 0..tuple_len {
@ -419,7 +419,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>,
ref sty_and_variant_info => {
let msg = format!("type {} ({:?}) is not fragmentable",
parent_ty.repr(tcx), sty_and_variant_info);
parent_ty.repr(), sty_and_variant_info);
let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id));
tcx.sess.opt_span_bug(opt_span, &msg[..])
}
@ -451,7 +451,7 @@ fn add_fragment_sibling_core<'tcx>(this: &MoveData<'tcx>,
let new_lp_variant = LpExtend(parent, mc, loan_path_elem);
let new_lp = LoanPath::new(new_lp_variant, new_lp_type.unwrap());
debug!("add_fragment_sibling_core(new_lp={}, origin_lp={})",
new_lp.repr(tcx), origin_lp.repr(tcx));
new_lp.repr(), origin_lp.repr());
let mp = this.move_path(tcx, Rc::new(new_lp));
// Do not worry about checking for duplicates here; we will sort

6
src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs
View file

@ -67,7 +67,7 @@ pub fn gather_match_variant<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
mode: euv::MatchMode) {
let tcx = bccx.tcx;
debug!("gather_match_variant(move_pat={}, cmt={}, mode={:?})",
move_pat.id, cmt.repr(tcx), mode);
move_pat.id, cmt.repr(), mode);
let opt_lp = opt_loan_path(&cmt);
match opt_lp {
@ -116,13 +116,13 @@ fn gather_move<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
move_error_collector: &MoveErrorCollector<'tcx>,
move_info: GatherMoveInfo<'tcx>) {
debug!("gather_move(move_id={}, cmt={})",
move_info.id, move_info.cmt.repr(bccx.tcx));
move_info.id, move_info.cmt.repr());
let potentially_illegal_move =
check_and_get_illegal_move_origin(bccx, &move_info.cmt);
match potentially_illegal_move {
Some(illegal_move_origin) => {
debug!("illegal_move_origin={}", illegal_move_origin.repr(bccx.tcx));
debug!("illegal_move_origin={}", illegal_move_origin.repr());
let error = MoveError::with_move_info(illegal_move_origin,
move_info.span_path_opt);
move_error_collector.add_error(error);

6
src/librustc_borrowck/borrowck/gather_loans/lifetime.rs
View file

@ -34,7 +34,7 @@ pub fn guarantee_lifetime<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
//! where S is `item_scope` if `cmt` is an upvar,
//! and is scope of `cmt` otherwise.
debug!("guarantee_lifetime(cmt={}, loan_region={})",
cmt.repr(bccx.tcx), loan_region.repr(bccx.tcx));
cmt.repr(), loan_region.repr());
let ctxt = GuaranteeLifetimeContext {bccx: bccx,
item_scope: item_scope,
span: span,
@ -66,8 +66,8 @@ impl<'a, 'tcx> GuaranteeLifetimeContext<'a, 'tcx> {
//! "guarantor". Reports an error if `self.loan_region` is
//! larger than scope of `cmt`.
debug!("guarantee_lifetime.check(cmt={}, loan_region={})",
cmt.repr(self.bccx.tcx),
self.loan_region.repr(self.bccx.tcx));
cmt.repr(),
self.loan_region.repr());
match cmt.cat {
mc::cat_rvalue(..) |

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

@ -77,7 +77,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> {
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
debug!("consume(consume_id={}, cmt={}, mode={:?})",
consume_id, cmt.repr(self.tcx()), mode);
consume_id, cmt.repr(), mode);
match mode {
euv::Move(move_reason) => {
@ -94,8 +94,8 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> {
cmt: mc::cmt<'tcx>,
mode: euv::MatchMode) {
debug!("matched_pat(matched_pat={}, cmt={}, mode={:?})",
matched_pat.repr(self.tcx()),
cmt.repr(self.tcx()),
matched_pat.repr(),
cmt.repr(),
mode);
if let mc::cat_downcast(..) = cmt.cat {
@ -110,8 +110,8 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> {
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})",
consume_pat.repr(self.tcx()),
cmt.repr(self.tcx()),
consume_pat.repr(),
cmt.repr(),
mode);
match mode {
@ -134,7 +134,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> {
{
debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \
bk={:?}, loan_cause={:?})",
borrow_id, cmt.repr(self.tcx()), loan_region,
borrow_id, cmt.repr(), loan_region,
bk, loan_cause);
self.guarantee_valid(borrow_id,
@ -153,7 +153,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, '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);
assignment_id, assignee_cmt.repr(), opt_lp);
match opt_lp {
Some(lp) => {
@ -237,7 +237,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
debug!("guarantee_valid(borrow_id={}, cmt={}, \
req_mutbl={:?}, loan_region={:?})",
borrow_id,
cmt.repr(self.tcx()),
cmt.repr(),
req_kind,
loan_region);
@ -337,7 +337,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
};
debug!("guarantee_valid(borrow_id={}), loan={}",
borrow_id, loan.repr(self.tcx()));
borrow_id, loan.repr());
// let loan_path = loan.loan_path;
// let loan_gen_scope = loan.gen_scope;
@ -377,7 +377,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
-> Result<(),()> {
//! Implements the M-* rules in README.md.
debug!("check_mutability(cause={:?} cmt={} req_kind={:?}",
cause, cmt.repr(bccx.tcx), req_kind);
cause, cmt.repr(), req_kind);
match req_kind {
ty::UniqueImmBorrow | ty::ImmBorrow => {
match cmt.mutbl {
@ -507,7 +507,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for StaticInitializerCtxt<'a, 'tcx> {
pub fn gather_loans_in_static_initializer(bccx: &mut BorrowckCtxt, expr: &ast::Expr) {
debug!("gather_loans_in_static_initializer(expr={})", expr.repr(bccx.tcx));
debug!("gather_loans_in_static_initializer(expr={})", expr.repr());
let mut sicx = StaticInitializerCtxt {
bccx: bccx

4
src/librustc_borrowck/borrowck/gather_loans/move_error.rs
View file

@ -130,7 +130,7 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
bccx.span_err(move_from.span,
&format!("cannot move out of type `{}`, \
a non-copy fixed-size array",
b.ty.user_string(bccx.tcx)));
b.ty.user_string()));
}
}
@ -143,7 +143,7 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
move_from.span,
&format!("cannot move out of type `{}`, \
which defines the `Drop` trait",
b.ty.user_string(bccx.tcx)));
b.ty.user_string()));
},
_ => {
bccx.span_bug(move_from.span, "this path should not cause illegal move")

2
src/librustc_borrowck/borrowck/gather_loans/restrictions.rs
View file

@ -58,7 +58,7 @@ struct RestrictionsContext<'a, 'tcx: 'a> {
impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> {
fn restrict(&self,
cmt: mc::cmt<'tcx>) -> RestrictionResult<'tcx> {
debug!("restrict(cmt={})", cmt.repr(self.bccx.tcx));
debug!("restrict(cmt={})", cmt.repr());
let new_lp = |v: LoanPathKind<'tcx>| Rc::new(LoanPath::new(v, cmt.ty));

56
src/librustc_borrowck/borrowck/mod.rs
View file

@ -682,7 +682,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
which is {}",
ol,
moved_lp_msg,
expr_ty.user_string(self.tcx),
expr_ty.user_string(),
suggestion));
} else {
self.tcx.sess.span_note(
@ -690,7 +690,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
&format!("`{}` moved here{} because it has type `{}`, which is {}",
ol,
moved_lp_msg,
expr_ty.user_string(self.tcx),
expr_ty.user_string(),
suggestion));
}
}
@ -703,7 +703,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
which is moved by default",
ol,
moved_lp_msg,
pat_ty.user_string(self.tcx)));
pat_ty.user_string()));
self.tcx.sess.fileline_help(span,
"use `ref` to override");
}
@ -734,7 +734,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
has type `{}`, which is {}",
ol,
moved_lp_msg,
expr_ty.user_string(self.tcx),
expr_ty.user_string(),
suggestion));
self.tcx.sess.fileline_help(expr_span, help);
}
@ -1148,8 +1148,8 @@ impl DataFlowOperator for LoanDataFlowOperator {
}
}
impl<'tcx> Repr<'tcx> for InteriorKind {
fn repr(&self, _tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for InteriorKind {
fn repr(&self) -> String {
match *self {
InteriorField(mc::NamedField(fld)) =>
format!("{}", token::get_name(fld)),
@ -1159,77 +1159,77 @@ impl<'tcx> Repr<'tcx> for InteriorKind {
}
}
impl<'tcx> Repr<'tcx> for Loan<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for Loan<'tcx> {
fn repr(&self) -> String {
format!("Loan_{}({}, {:?}, {:?}-{:?}, {})",
self.index,
self.loan_path.repr(tcx),
self.loan_path.repr(),
self.kind,
self.gen_scope,
self.kill_scope,
self.restricted_paths.repr(tcx))
self.restricted_paths.repr())
}
}
impl<'tcx> Repr<'tcx> for LoanPath<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for LoanPath<'tcx> {
fn repr(&self) -> String {
match self.kind {
LpVar(id) => {
format!("$({})", tcx.map.node_to_string(id))
format!("$({})", ty::tls::with(|tcx| tcx.map.node_to_string(id)))
}
LpUpvar(ty::UpvarId{ var_id, closure_expr_id }) => {
let s = tcx.map.node_to_string(var_id);
let s = ty::tls::with(|tcx| tcx.map.node_to_string(var_id));
format!("$({} captured by id={})", s, closure_expr_id)
}
LpDowncast(ref lp, variant_def_id) => {
let variant_str = if variant_def_id.krate == ast::LOCAL_CRATE {
ty::item_path_str(tcx, variant_def_id)
ty::tls::with(|tcx| ty::item_path_str(tcx, variant_def_id))
} else {
variant_def_id.repr(tcx)
variant_def_id.repr()
};
format!("({}{}{})", lp.repr(tcx), DOWNCAST_PRINTED_OPERATOR, variant_str)
format!("({}{}{})", lp.repr(), DOWNCAST_PRINTED_OPERATOR, variant_str)
}
LpExtend(ref lp, _, LpDeref(_)) => {
format!("{}.*", lp.repr(tcx))
format!("{}.*", lp.repr())
}
LpExtend(ref lp, _, LpInterior(ref interior)) => {
format!("{}.{}", lp.repr(tcx), interior.repr(tcx))
format!("{}.{}", lp.repr(), interior.repr())
}
}
}
}
impl<'tcx> UserString<'tcx> for LoanPath<'tcx> {
fn user_string(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> UserString for LoanPath<'tcx> {
fn user_string(&self) -> String {
match self.kind {
LpVar(id) => {
format!("$({})", tcx.map.node_to_user_string(id))
format!("$({})", ty::tls::with(|tcx| tcx.map.node_to_user_string(id)))
}
LpUpvar(ty::UpvarId{ var_id, closure_expr_id: _ }) => {
let s = tcx.map.node_to_user_string(var_id);
let s = ty::tls::with(|tcx| tcx.map.node_to_user_string(var_id));
format!("$({} captured by closure)", s)
}
LpDowncast(ref lp, variant_def_id) => {
let variant_str = if variant_def_id.krate == ast::LOCAL_CRATE {
ty::item_path_str(tcx, variant_def_id)
ty::tls::with(|tcx| ty::item_path_str(tcx, variant_def_id))
} else {
variant_def_id.repr(tcx)
variant_def_id.repr()
};
format!("({}{}{})", lp.user_string(tcx), DOWNCAST_PRINTED_OPERATOR, variant_str)
format!("({}{}{})", lp.user_string(), DOWNCAST_PRINTED_OPERATOR, variant_str)
}
LpExtend(ref lp, _, LpDeref(_)) => {
format!("{}.*", lp.user_string(tcx))
format!("{}.*", lp.user_string())
}
LpExtend(ref lp, _, LpInterior(ref interior)) => {
format!("{}.{}", lp.user_string(tcx), interior.repr(tcx))
format!("{}.{}", lp.user_string(), interior.repr())
}
}
}

12
src/librustc_borrowck/borrowck/move_data.rs
View file

@ -314,7 +314,7 @@ impl<'tcx> MoveData<'tcx> {
};
debug!("move_path(lp={}, index={:?})",
lp.repr(tcx),
lp.repr(),
index);
assert_eq!(index.get(), self.paths.borrow().len() - 1);
@ -365,7 +365,7 @@ impl<'tcx> MoveData<'tcx> {
id: ast::NodeId,
kind: MoveKind) {
debug!("add_move(lp={}, id={}, kind={:?})",
lp.repr(tcx),
lp.repr(),
id,
kind);
@ -395,7 +395,7 @@ impl<'tcx> MoveData<'tcx> {
assignee_id: ast::NodeId,
mode: euv::MutateMode) {
debug!("add_assignment(lp={}, assign_id={}, assignee_id={}",
lp.repr(tcx), assign_id, assignee_id);
lp.repr(), assign_id, assignee_id);
let path_index = self.move_path(tcx, lp.clone());
@ -416,12 +416,12 @@ impl<'tcx> MoveData<'tcx> {
if self.is_var_path(path_index) {
debug!("add_assignment[var](lp={}, assignment={}, path_index={:?})",
lp.repr(tcx), self.var_assignments.borrow().len(), path_index);
lp.repr(), self.var_assignments.borrow().len(), path_index);
self.var_assignments.borrow_mut().push(assignment);
} else {
debug!("add_assignment[path](lp={}, path_index={:?})",
lp.repr(tcx), path_index);
lp.repr(), path_index);
self.path_assignments.borrow_mut().push(assignment);
}
@ -438,7 +438,7 @@ impl<'tcx> MoveData<'tcx> {
base_lp: Rc<LoanPath<'tcx>>,
mode: euv::MatchMode) {
debug!("add_variant_match(lp={}, pattern_id={})",
lp.repr(tcx), pattern_id);
lp.repr(), pattern_id);
let path_index = self.move_path(tcx, lp.clone());
let base_path_index = self.move_path(tcx, base_lp.clone());

2
src/librustc_driver/pretty.rs
View file

@ -318,7 +318,7 @@ impl<'a, 'tcx> pprust::PpAnn for TypedAnnotation<'a, 'tcx> {
try!(pp::word(&mut s.s, "as"));
try!(pp::space(&mut s.s));
try!(pp::word(&mut s.s,
&ty::expr_ty(self.tcx, expr).user_string(self.tcx)));
&ty::expr_ty(self.tcx, expr).user_string()));
s.pclose()
}
_ => Ok(())

38
src/librustc_driver/test.rs
View file

@ -188,7 +188,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
-> Option<ast::NodeId> {
assert!(idx < names.len());
for item in &m.items {
if item.ident.user_string(this.infcx.tcx) == names[idx] {
if item.ident.user_string() == names[idx] {
return search(this, &**item, idx+1, names);
}
}
@ -253,7 +253,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
}
pub fn ty_to_string(&self, a: Ty<'tcx>) -> String {
a.user_string(self.infcx.tcx)
a.user_string()
}
pub fn t_fn(&self,
@ -388,8 +388,8 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
Ok(_) => { }
Err(ref e) => {
panic!("unexpected error computing sub({},{}): {}",
t1.repr(self.infcx.tcx),
t2.repr(self.infcx.tcx),
t1.repr(),
t2.repr(),
ty::type_err_to_str(self.infcx.tcx, e));
}
}
@ -402,8 +402,8 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
Err(_) => { }
Ok(_) => {
panic!("unexpected success computing sub({},{})",
t1.repr(self.infcx.tcx),
t2.repr(self.infcx.tcx));
t1.repr(),
t2.repr());
}
}
}
@ -659,7 +659,7 @@ fn glb_bound_free_infer() {
let t_resolve1 = env.infcx.shallow_resolve(t_infer1);
match t_resolve1.sty {
ty::TyRef(..) => { }
_ => { panic!("t_resolve1={}", t_resolve1.repr(env.infcx.tcx)); }
_ => { panic!("t_resolve1={}", t_resolve1.repr()); }
}
})
}
@ -702,10 +702,10 @@ fn subst_ty_renumber_bound() {
};
debug!("subst_bound: t_source={} substs={} t_substituted={} t_expected={}",
t_source.repr(env.infcx.tcx),
substs.repr(env.infcx.tcx),
t_substituted.repr(env.infcx.tcx),
t_expected.repr(env.infcx.tcx));
t_source.repr(),
substs.repr(),
t_substituted.repr(),
t_expected.repr());
assert_eq!(t_substituted, t_expected);
})
@ -739,10 +739,10 @@ fn subst_ty_renumber_some_bounds() {
};
debug!("subst_bound: t_source={} substs={} t_substituted={} t_expected={}",
t_source.repr(env.infcx.tcx),
substs.repr(env.infcx.tcx),
t_substituted.repr(env.infcx.tcx),
t_expected.repr(env.infcx.tcx));
t_source.repr(),
substs.repr(),
t_substituted.repr(),
t_expected.repr());
assert_eq!(t_substituted, t_expected);
})
@ -800,10 +800,10 @@ fn subst_region_renumber_region() {
};
debug!("subst_bound: t_source={} substs={} t_substituted={} t_expected={}",
t_source.repr(env.infcx.tcx),
substs.repr(env.infcx.tcx),
t_substituted.repr(env.infcx.tcx),
t_expected.repr(env.infcx.tcx));
t_source.repr(),
substs.repr(),
t_substituted.repr(),
t_expected.repr());
assert_eq!(t_substituted, t_expected);
})

2
src/librustc_lint/builtin.rs
View file

@ -495,7 +495,7 @@ impl BoxPointers {
});
if n_uniq > 0 {
let s = ty.user_string(cx.tcx);
let s = ty.user_string();
let m = format!("type uses owned (Box type) pointers: {}", s);
cx.span_lint(BOX_POINTERS, span, &m[..]);
}

2
src/librustc_trans/back/link.rs
View file

@ -347,7 +347,7 @@ pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathEl
pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
t: Ty<'tcx>,
name: &str) -> String {
let path = [PathName(token::intern(&t.user_string(ccx.tcx()))),
let path = [PathName(token::intern(&t.user_string())),
gensym_name(name)];
let hash = get_symbol_hash(ccx, t);
mangle(path.iter().cloned(), Some(&hash[..]))

4
src/librustc_trans/save/dump_csv.rs
View file

@ -287,7 +287,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
collector.visit_pat(&arg.pat);
let span_utils = self.span.clone();
for &(id, ref p, _, _) in &collector.collected_paths {
let typ = self.tcx.node_types().get(&id).unwrap().user_string(self.tcx);
let typ = self.tcx.node_types().get(&id).unwrap().user_string();
// get the span only for the name of the variable (I hope the path is only ever a
// variable name, but who knows?)
self.fmt.formal_str(p.span,
@ -1392,7 +1392,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
"<mutable>".to_string()
};
let types = self.tcx.node_types();
let typ = types.get(&id).unwrap().user_string(self.tcx);
let typ = types.get(&id).unwrap().user_string();
// Get the span only for the name of the variable (I hope the path
// is only ever a variable name, but who knows?).
let sub_span = self.span.span_for_last_ident(p.span);

2
src/librustc_trans/save/mod.rs
View file

@ -293,7 +293,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
self.tcx.map.path_to_string(parent),
name);
let typ = self.tcx.node_types().get(&field.node.id).unwrap()
.user_string(self.tcx);
.user_string();
let sub_span = self.span_utils.sub_span_before_token(field.span, token::Colon);
Some(Data::VariableData(VariableData {
id: field.node.id,

26
src/librustc_trans/trans/_match.rs
View file

@ -217,7 +217,7 @@ use middle::ty::{self, Ty};
use session::config::{NoDebugInfo, FullDebugInfo};
use util::common::indenter;
use util::nodemap::FnvHashMap;
use util::ppaux::Repr;
use util::ppaux::{self, Repr};
use std;
use std::cmp::Ordering;
@ -371,11 +371,11 @@ struct Match<'a, 'p: 'a, 'blk: 'a, 'tcx: 'blk> {
pat_renaming_map: Option<&'a FnvHashMap<(NodeId, Span), NodeId>>
}
impl<'a, 'p, 'blk, 'tcx> Repr<'tcx> for Match<'a, 'p, 'blk, 'tcx> {
fn repr(&self, tcx: &ty::ctxt) -> String {
if tcx.sess.verbose() {
impl<'a, 'p, 'blk, 'tcx> Repr for Match<'a, 'p, 'blk, 'tcx> {
fn repr(&self) -> String {
if ppaux::verbose() {
// for many programs, this just take too long to serialize
self.pats.repr(tcx)
self.pats.repr()
} else {
format!("{} pats", self.pats.len())
}
@ -399,7 +399,7 @@ fn expand_nested_bindings<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
debug!("expand_nested_bindings(bcx={}, m={}, col={}, val={})",
bcx.to_str(),
m.repr(bcx.tcx()),
m.repr(),
col,
bcx.val_to_string(val));
let _indenter = indenter();
@ -439,7 +439,7 @@ fn enter_match<'a, 'b, 'p, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
{
debug!("enter_match(bcx={}, m={}, col={}, val={})",
bcx.to_str(),
m.repr(bcx.tcx()),
m.repr(),
col,
bcx.val_to_string(val));
let _indenter = indenter();
@ -482,7 +482,7 @@ fn enter_default<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
debug!("enter_default(bcx={}, m={}, col={}, val={})",
bcx.to_str(),
m.repr(bcx.tcx()),
m.repr(),
col,
bcx.val_to_string(val));
let _indenter = indenter();
@ -539,7 +539,7 @@ fn enter_opt<'a, 'p, 'blk, 'tcx>(
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
debug!("enter_opt(bcx={}, m={}, opt={:?}, col={}, val={})",
bcx.to_str(),
m.repr(bcx.tcx()),
m.repr(),
*opt,
col,
bcx.val_to_string(val));
@ -940,7 +940,7 @@ fn compile_guard<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
debug!("compile_guard(bcx={}, guard_expr={}, m={}, vals=[{}])",
bcx.to_str(),
bcx.expr_to_string(guard_expr),
m.repr(bcx.tcx()),
m.repr(),
vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().connect(", "));
let _indenter = indenter();
@ -985,7 +985,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
has_genuine_default: bool) {
debug!("compile_submatch(bcx={}, m={}, vals=[{}])",
bcx.to_str(),
m.repr(bcx.tcx()),
m.repr(),
vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().connect(", "));
let _indenter = indenter();
let _icx = push_ctxt("match::compile_submatch");
@ -1698,11 +1698,11 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-> Block<'blk, 'tcx> {
debug!("bind_irrefutable_pat(bcx={}, pat={})",
bcx.to_str(),
pat.repr(bcx.tcx()));
pat.repr());
if bcx.sess().asm_comments() {
add_comment(bcx, &format!("bind_irrefutable_pat(pat={})",
pat.repr(bcx.tcx())));
pat.repr()));
}
let _indenter = indenter();

4
src/librustc_trans/trans/adt.rs
View file

@ -143,7 +143,7 @@ pub fn represent_node<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
pub fn represent_type<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
t: Ty<'tcx>)
-> Rc<Repr<'tcx>> {
debug!("Representing: {}", t.repr(cx.tcx()));
debug!("Representing: {}", t.repr());
match cx.adt_reprs().borrow().get(&t) {
Some(repr) => return repr.clone(),
None => {}
@ -382,7 +382,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
General(ity, fields, dtor_to_init_u8(dtor))
}
_ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}",
t.repr(cx.tcx())))
t.repr()))
}
}

16
src/librustc_trans/trans/base.rs
View file

@ -531,7 +531,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
}
_ => {
cx.sess().unimpl(&format!("type in iter_structural_ty: {}",
t.repr(cx.tcx())))
t.repr()))
}
}
return cx;
@ -641,7 +641,7 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>(
}
_ => {
cx.sess().bug(&format!("fail-if-zero on unexpected type: {}",
rhs_t.repr(cx.tcx())));
rhs_t.repr()));
}
};
let bcx = with_cond(cx, is_zero, |bcx| {
@ -1193,7 +1193,7 @@ pub fn new_fn_ctxt<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>,
} else {
ccx.tcx().map.path_to_string(id).to_string()
},
id, param_substs.repr(ccx.tcx()));
id, param_substs.repr());
let uses_outptr = match output_type {
ty::FnConverging(output_type) => {
@ -1511,7 +1511,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
attributes::emit_uwtable(llfndecl, true);
debug!("trans_closure(..., param_substs={})",
param_substs.repr(ccx.tcx()));
param_substs.repr());
let has_env = match closure_env {
closure::ClosureEnv::Closure(_) => true,
@ -1554,7 +1554,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
};
for monomorphized_arg_type in &monomorphized_arg_types {
debug!("trans_closure: monomorphized_arg_type: {}",
monomorphized_arg_type.repr(ccx.tcx()));
monomorphized_arg_type.repr());
}
debug!("trans_closure: function lltype: {}",
bcx.fcx.ccx.tn().val_to_string(bcx.fcx.llfn));
@ -1636,7 +1636,7 @@ pub fn trans_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
id: ast::NodeId,
attrs: &[ast::Attribute]) {
let _s = StatRecorder::new(ccx, ccx.tcx().map.path_to_string(id).to_string());
debug!("trans_fn(param_substs={})", param_substs.repr(ccx.tcx()));
debug!("trans_fn(param_substs={})", param_substs.repr());
let _icx = push_ctxt("trans_fn");
let fn_ty = ty::node_id_to_type(ccx.tcx(), id);
let output_type = ty::erase_late_bound_regions(ccx.tcx(), &ty::ty_fn_ret(fn_ty));
@ -1680,7 +1680,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
_ => ccx.sess().bug(
&format!("trans_enum_variant_constructor: \
unexpected ctor return type {}",
ctor_ty.repr(tcx)))
ctor_ty.repr()))
};
// Get location to store the result. If the user does not care about
@ -1758,7 +1758,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx
_ => ccx.sess().bug(
&format!("trans_enum_variant_or_tuple_like_struct: \
unexpected ctor return type {}",
ctor_ty.repr(ccx.tcx())))
ctor_ty.repr()))
};
let (arena, fcx): (TypedArena<_>, FunctionContext);

34
src/librustc_trans/trans/callee.rs
View file

@ -89,7 +89,7 @@ pub struct Callee<'blk, 'tcx: 'blk> {
fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
-> Callee<'blk, 'tcx> {
let _icx = push_ctxt("trans_callee");
debug!("callee::trans(expr={})", expr.repr(bcx.tcx()));
debug!("callee::trans(expr={})", expr.repr());
// pick out special kinds of expressions that can be called:
match expr.node {
@ -134,7 +134,7 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
def: def::Def,
ref_expr: &ast::Expr)
-> Callee<'blk, 'tcx> {
debug!("trans_def(def={}, ref_expr={})", def.repr(bcx.tcx()), ref_expr.repr(bcx.tcx()));
debug!("trans_def(def={}, ref_expr={})", def.repr(), ref_expr.repr());
let expr_ty = common::node_id_type(bcx, ref_expr.id);
match def {
def::DefFn(did, _) if {
@ -229,9 +229,9 @@ pub fn trans_fn_ref<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
let substs = common::node_id_substs(ccx, node, param_substs);
debug!("trans_fn_ref(def_id={}, node={:?}, substs={})",
def_id.repr(ccx.tcx()),
def_id.repr(),
node,
substs.repr(ccx.tcx()));
substs.repr());
trans_fn_ref_with_substs(ccx, def_id, node, param_substs, substs)
}
@ -292,7 +292,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
}
debug!("trans_fn_pointer_shim(bare_fn_ty={})",
bare_fn_ty.repr(tcx));
bare_fn_ty.repr());
// Construct the "tuply" version of `bare_fn_ty`. It takes two arguments: `self`,
// which is the fn pointer, and `args`, which is the arguments tuple.
@ -307,7 +307,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
_ => {
tcx.sess.bug(&format!("trans_fn_pointer_shim invoked on invalid type: {}",
bare_fn_ty.repr(tcx)));
bare_fn_ty.repr()));
}
};
let sig = ty::erase_late_bound_regions(tcx, sig);
@ -323,7 +323,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
output: sig.output,
variadic: false
})}));
debug!("tuple_fn_ty: {}", tuple_fn_ty.repr(tcx));
debug!("tuple_fn_ty: {}", tuple_fn_ty.repr());
//
let function_name = link::mangle_internal_name_by_type_and_seq(ccx, bare_fn_ty,
@ -403,10 +403,10 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>(
debug!("trans_fn_ref_with_substs(def_id={}, node={:?}, \
param_substs={}, substs={})",
def_id.repr(tcx),
def_id.repr(),
node,
param_substs.repr(tcx),
substs.repr(tcx));
param_substs.repr(),
substs.repr());
assert!(substs.types.all(|t| !ty::type_needs_infer(*t)));
assert!(substs.types.all(|t| !ty::type_has_escaping_regions(*t)));
@ -459,8 +459,8 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>(
debug!("trans_fn_with_vtables - default method: \
substs = {}, trait_subst = {}, \
first_subst = {}, new_subst = {}",
substs.repr(tcx), trait_ref.substs.repr(tcx),
first_subst.repr(tcx), new_substs.repr(tcx));
substs.repr(), trait_ref.substs.repr(),
first_subst.repr(), new_substs.repr());
(true, source_id, new_substs)
}
@ -505,7 +505,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>(
};
debug!("trans_fn_ref_with_substs({}) must_monomorphise: {}",
def_id.repr(tcx), must_monomorphise);
def_id.repr(), must_monomorphise);
// Create a monomorphic version of generic functions
if must_monomorphise {
@ -615,7 +615,7 @@ pub fn trans_method_call<'a, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
dest: expr::Dest)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_method_call");
debug!("trans_method_call(call_expr={})", call_expr.repr(bcx.tcx()));
debug!("trans_method_call(call_expr={})", call_expr.repr());
let method_call = MethodCall::expr(call_expr.id);
let method_ty = match bcx.tcx().method_map.borrow().get(&method_call) {
Some(method) => match method.origin {
@ -1126,7 +1126,7 @@ pub fn trans_arg_datum<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
let ccx = bcx.ccx();
debug!("trans_arg_datum({})",
formal_arg_ty.repr(bcx.tcx()));
formal_arg_ty.repr());
let arg_datum_ty = arg_datum.ty;
@ -1165,8 +1165,8 @@ pub fn trans_arg_datum<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
let llformal_arg_ty = type_of::type_of_explicit_arg(ccx, formal_arg_ty);
debug!("casting actual type ({}) to match formal ({})",
bcx.val_to_string(val), bcx.llty_str(llformal_arg_ty));
debug!("Rust types: {}; {}", arg_datum_ty.repr(bcx.tcx()),
formal_arg_ty.repr(bcx.tcx()));
debug!("Rust types: {}; {}", arg_datum_ty.repr(),
formal_arg_ty.repr());
val = PointerCast(bcx, val, llformal_arg_ty);
}

8
src/librustc_trans/trans/cleanup.rs
View file

@ -400,7 +400,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
debug!("schedule_drop_mem({:?}, val={}, ty={}) fill_on_drop={} skip_dtor={}",
cleanup_scope,
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()),
ty.repr(),
drop.fill_on_drop,
drop.skip_dtor);
@ -426,7 +426,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
debug!("schedule_drop_and_fill_mem({:?}, val={}, ty={}, fill_on_drop={}, skip_dtor={})",
cleanup_scope,
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()),
ty.repr(),
drop.fill_on_drop,
drop.skip_dtor);
@ -458,7 +458,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
debug!("schedule_drop_adt_contents({:?}, val={}, ty={}) fill_on_drop={} skip_dtor={}",
cleanup_scope,
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()),
ty.repr(),
drop.fill_on_drop,
drop.skip_dtor);
@ -484,7 +484,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
debug!("schedule_drop_immediate({:?}, val={}, ty={:?}) fill_on_drop={} skip_dtor={}",
cleanup_scope,
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()),
ty.repr(),
drop.fill_on_drop,
drop.skip_dtor);

8
src/librustc_trans/trans/closure.rs
View file

@ -354,8 +354,8 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>(
-> ValueRef
{
debug!("trans_fn_once_adapter_shim(closure_def_id={}, substs={}, llreffn={})",
closure_def_id.repr(ccx.tcx()),
substs.repr(ccx.tcx()),
closure_def_id.repr(),
substs.repr(),
ccx.tn().val_to_string(llreffn));
let tcx = ccx.tcx();
@ -375,7 +375,7 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>(
sig: sig.clone() });
let llref_fn_ty = ty::mk_bare_fn(tcx, None, llref_bare_fn_ty);
debug!("trans_fn_once_adapter_shim: llref_fn_ty={}",
llref_fn_ty.repr(tcx));
llref_fn_ty.repr());
// Make a version of the closure type with the same arguments, but
// with argument #0 being by value.
@ -424,7 +424,7 @@ fn trans_fn_once_adapter_shim<'a, 'tcx>(
ty::TyTuple(ref tys) => &**tys,
_ => bcx.sess().bug(&format!("trans_fn_once_adapter_shim: not rust-call! \
closure_def_id={}",
closure_def_id.repr(tcx)))
closure_def_id.repr()))
};
let llargs: Vec<_> =
input_tys.iter()

40
src/librustc_trans/trans/common.rs
View file

@ -64,11 +64,11 @@ pub use trans::context::CrateContext;
/// subtyping, but they are anonymized and normalized as well). This
/// is a stronger, caching version of `ty_fold::erase_regions`.
pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
let value1 = value.fold_with(&mut RegionEraser(cx));
debug!("erase_regions({}) = {}",
value.repr(cx), value1.repr(cx));
value.repr(), value1.repr());
return value1;
struct RegionEraser<'a, 'tcx: 'a>(&'a ty::ctxt<'tcx>);
@ -88,7 +88,7 @@ pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T
}
fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T>
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
let u = ty::anonymize_late_bound_regions(self.tcx(), t);
ty_fold::super_fold_binder(self, &u)
@ -212,7 +212,7 @@ fn type_needs_drop_given_env<'a,'tcx>(cx: &ty::ctxt<'tcx>,
// destructor (e.g. zero its memory on move).
let contents = ty::type_contents(cx, ty);
debug!("type_needs_drop ty={} contents={:?}", ty.repr(cx), contents);
debug!("type_needs_drop ty={} contents={:?}", ty.repr(), contents);
contents.needs_drop(cx)
}
@ -518,7 +518,7 @@ impl<'a, 'tcx> FunctionContext<'a, 'tcx> {
}
pub fn monomorphize<T>(&self, value: &T) -> T
where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
where T : TypeFoldable<'tcx> + Repr + HasProjectionTypes + Clone
{
monomorphize::apply_param_substs(self.ccx.tcx(),
self.param_substs,
@ -594,7 +594,7 @@ impl<'blk, 'tcx> BlockS<'blk, 'tcx> {
}
pub fn expr_to_string(&self, e: &ast::Expr) -> String {
e.repr(self.tcx())
e.repr()
}
pub fn def(&self, nid: ast::NodeId) -> def::Def {
@ -616,7 +616,7 @@ impl<'blk, 'tcx> BlockS<'blk, 'tcx> {
}
pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
t.repr(self.tcx())
t.repr()
}
pub fn to_str(&self) -> String {
@ -624,7 +624,7 @@ impl<'blk, 'tcx> BlockS<'blk, 'tcx> {
}
pub fn monomorphize<T>(&self, value: &T) -> T
where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
where T : TypeFoldable<'tcx> + Repr + HasProjectionTypes + Clone
{
monomorphize::apply_param_substs(self.tcx(),
self.fcx.param_substs,
@ -994,14 +994,14 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
// First check the cache.
match ccx.trait_cache().borrow().get(&trait_ref) {
Some(vtable) => {
info!("Cache hit: {}", trait_ref.repr(ccx.tcx()));
info!("Cache hit: {}", trait_ref.repr());
return (*vtable).clone();
}
None => { }
}
debug!("trans fulfill_obligation: trait_ref={} def_id={:?}",
trait_ref.repr(ccx.tcx()), trait_ref.def_id());
trait_ref.repr(), trait_ref.def_id());
ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id());
let infcx = infer::new_infer_ctxt(tcx);
@ -1024,7 +1024,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
// where ambiguity can result.
debug!("Encountered ambiguity selecting `{}` during trans, \
presuming due to overflow",
trait_ref.repr(tcx));
trait_ref.repr());
ccx.sess().span_fatal(
span,
"reached the recursion limit during monomorphization");
@ -1033,8 +1033,8 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
tcx.sess.span_bug(
span,
&format!("Encountered error `{}` selecting `{}` during trans",
e.repr(tcx),
trait_ref.repr(tcx)))
e.repr(),
trait_ref.repr()))
}
};
@ -1047,7 +1047,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
});
let vtable = drain_fulfillment_cx_or_panic(span, &infcx, &mut fulfill_cx, &vtable);
info!("Cache miss: {}", trait_ref.repr(ccx.tcx()));
info!("Cache miss: {}", trait_ref.repr());
ccx.trait_cache().borrow_mut().insert(trait_ref,
vtable.clone());
@ -1063,7 +1063,7 @@ pub fn normalize_and_test_predicates<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
-> bool
{
debug!("normalize_and_test_predicates(predicates={})",
predicates.repr(ccx.tcx()));
predicates.repr());
let tcx = ccx.tcx();
let infcx = infer::new_infer_ctxt(tcx);
@ -1135,7 +1135,7 @@ pub fn drain_fulfillment_cx_or_panic<'a,'tcx,T>(span: Span,
fulfill_cx: &mut traits::FulfillmentContext<'tcx>,
result: &T)
-> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
match drain_fulfillment_cx(infcx, fulfill_cx, result) {
Ok(v) => v,
@ -1143,7 +1143,7 @@ pub fn drain_fulfillment_cx_or_panic<'a,'tcx,T>(span: Span,
infcx.tcx.sess.span_bug(
span,
&format!("Encountered errors `{}` fulfilling during trans",
errors.repr(infcx.tcx)));
errors.repr()));
}
}
}
@ -1159,10 +1159,10 @@ pub fn drain_fulfillment_cx<'a,'tcx,T>(infcx: &infer::InferCtxt<'a,'tcx>,
fulfill_cx: &mut traits::FulfillmentContext<'tcx>,
result: &T)
-> StdResult<T,Vec<traits::FulfillmentError<'tcx>>>
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
debug!("drain_fulfillment_cx(result={})",
result.repr(infcx.tcx));
result.repr());
// In principle, we only need to do this so long as `result`
// contains unbound type parameters. It could be a slight
@ -1210,7 +1210,7 @@ pub fn node_id_substs<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
if substs.types.any(|t| ty::type_needs_infer(*t)) {
tcx.sess.bug(&format!("type parameters for node {:?} include inference types: {:?}",
node, substs.repr(tcx)));
node, substs.repr()));
}
monomorphize::apply_param_substs(tcx,

20
src/librustc_trans/trans/consts.rs
View file

@ -68,7 +68,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit)
_ => cx.sess().span_bug(lit.span,
&format!("integer literal has type {} (expected int \
or usize)",
lit_int_ty.repr(cx.tcx())))
lit_int_ty.repr()))
}
}
ast::LitFloat(ref fs, t) => {
@ -161,7 +161,7 @@ fn const_deref<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
}
None => {
cx.sess().bug(&format!("unexpected dereferenceable type {}",
ty.repr(cx.tcx())))
ty.repr()))
}
}
}
@ -369,7 +369,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
llvm::LLVMDumpValue(C_undef(llty));
}
cx.sess().bug(&format!("const {} of type {} has size {} instead of {}",
e.repr(cx.tcx()), ety_adjusted.repr(cx.tcx()),
e.repr(), ety_adjusted.repr(),
csize, tsize));
}
(llconst, ety_adjusted)
@ -477,9 +477,9 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
-> ValueRef
{
debug!("const_expr_unadjusted(e={}, ety={}, param_substs={})",
e.repr(cx.tcx()),
ety.repr(cx.tcx()),
param_substs.repr(cx.tcx()));
e.repr(),
ety.repr(),
param_substs.repr());
let map_list = |exprs: &[P<ast::Expr>]| -> Vec<ValueRef> {
exprs.iter()
@ -498,7 +498,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
let (te1, ty) = const_expr(cx, &**e1, param_substs, fn_args);
debug!("const_expr_unadjusted: te1={}, ty={}",
cx.tn().val_to_string(te1),
ty.repr(cx.tcx()));
ty.repr());
let is_simd = ty::type_is_simd(cx.tcx(), ty);
let intype = if is_simd {
ty::simd_type(cx.tcx(), ty)
@ -621,12 +621,12 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
_ => cx.sess().span_bug(base.span,
&format!("index-expr base must be a vector \
or string type, found {}",
bt.repr(cx.tcx())))
bt.repr()))
},
_ => cx.sess().span_bug(base.span,
&format!("index-expr base must be a vector \
or string type, found {}",
bt.repr(cx.tcx())))
bt.repr()))
};
let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
@ -654,7 +654,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
let t_cast = ety;
let llty = type_of::type_of(cx, t_cast);
let (v, t_expr) = const_expr(cx, &**base, param_substs, fn_args);
debug!("trans_const_cast({} as {})", t_expr.repr(cx.tcx()), t_cast.repr(cx.tcx()));
debug!("trans_const_cast({} as {})", t_expr.repr(), t_cast.repr());
if expr::cast_is_noop(cx.tcx(), base, t_expr, t_cast) {
return v;
}

2
src/librustc_trans/trans/context.rs
View file

@ -767,7 +767,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> {
pub fn report_overbig_object(&self, obj: Ty<'tcx>) -> ! {
self.sess().fatal(
&format!("the type `{}` is too big for the current architecture",
obj.repr(self.tcx())))
obj.repr()))
}
pub fn check_overflow(&self) -> bool {

4
src/librustc_trans/trans/controlflow.rs
View file

@ -36,14 +36,14 @@ pub fn trans_stmt<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_stmt");
let fcx = cx.fcx;
debug!("trans_stmt({})", s.repr(cx.tcx()));
debug!("trans_stmt({})", s.repr());
if cx.unreachable.get() {
return cx;
}
if cx.sess().asm_comments() {
add_span_comment(cx, s.span, &s.repr(cx.tcx()));
add_span_comment(cx, s.span, &s.repr());
}
let mut bcx = cx;

2
src/librustc_trans/trans/datum.rs
View file

@ -616,7 +616,7 @@ impl<'tcx, K: KindOps + fmt::Debug> Datum<'tcx, K> {
pub fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String {
format!("Datum({}, {}, {:?})",
ccx.tn().val_to_string(self.val),
self.ty.repr(ccx.tcx()),
self.ty.repr(),
self.kind)
}

12
src/librustc_trans/trans/debuginfo/metadata.rs
View file

@ -105,7 +105,7 @@ impl<'tcx> TypeMap<'tcx> {
metadata: DIType) {
if self.type_to_metadata.insert(type_, metadata).is_some() {
cx.sess().bug(&format!("Type metadata for Ty '{}' is already in the TypeMap!",
type_.repr(cx.tcx())));
type_.repr()));
}
}
@ -298,7 +298,7 @@ impl<'tcx> TypeMap<'tcx> {
},
_ => {
cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
type_.repr(cx.tcx()), type_.sty))
type_.repr(), type_.sty))
}
};
@ -489,7 +489,7 @@ impl<'tcx> RecursiveTypeDescription<'tcx> {
type_map.find_metadata_for_type(unfinished_type).is_none() {
cx.sess().bug(&format!("Forward declaration of potentially recursive type \
'{}' was not found in TypeMap!",
unfinished_type.repr(cx.tcx()))
unfinished_type.repr())
);
}
}
@ -677,7 +677,7 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
_ => {
cx.sess().bug(&format!("debuginfo: Unexpected trait-object type in \
trait_pointer_metadata(): {}",
trait_type.repr(cx.tcx())));
trait_type.repr()));
}
};
@ -839,7 +839,7 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
the debuginfo::TypeMap but it \
was not. (Ty = {})",
&unique_type_id_str[..],
t.user_string(cx.tcx()));
t.user_string());
cx.sess().span_bug(usage_site_span, &error_message[..]);
}
};
@ -854,7 +854,7 @@ pub fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
debuginfo::TypeMap. \
UniqueTypeId={}, Ty={}",
&unique_type_id_str[..],
t.user_string(cx.tcx()));
t.user_string());
cx.sess().span_bug(usage_site_span, &error_message[..]);
}
}

2
src/librustc_trans/trans/debuginfo/type_names.rs
View file

@ -163,7 +163,7 @@ pub fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
ty::TyProjection(..) |
ty::TyParam(_) => {
cx.sess().bug(&format!("debuginfo: Trying to create type name for \
unexpected type: {}", t.repr(cx.tcx())));
unexpected type: {}", t.repr()));
}
}

8
src/librustc_trans/trans/declare.rs
View file

@ -107,10 +107,10 @@ pub fn declare_cfn(ccx: &CrateContext, name: &str, fn_type: Type,
pub fn declare_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, name: &str,
fn_type: ty::Ty<'tcx>) -> ValueRef {
debug!("declare_rust_fn(name={:?}, fn_type={})", name,
fn_type.repr(ccx.tcx()));
fn_type.repr());
let fn_type = monomorphize::normalize_associated_type(ccx.tcx(), &fn_type);
debug!("declare_rust_fn (after normalised associated types) fn_type={}",
fn_type.repr(ccx.tcx()));
fn_type.repr());
let function_type; // placeholder so that the memory ownership works out ok
let (sig, abi, env) = match fn_type.sty {
@ -123,14 +123,14 @@ pub fn declare_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, name: &str,
let self_type = base::self_type_for_closure(ccx, closure_did, fn_type);
let llenvironment_type = type_of::type_of_explicit_arg(ccx, self_type);
debug!("declare_rust_fn function_type={} self_type={}",
function_type.repr(ccx.tcx()), self_type.repr(ccx.tcx()));
function_type.repr(), self_type.repr());
(&function_type.sig, abi::RustCall, Some(llenvironment_type))
}
_ => ccx.sess().bug("expected closure or fn")
};
let sig = ty::Binder(ty::erase_late_bound_regions(ccx.tcx(), sig));
debug!("declare_rust_fn (after region erasure) sig={}", sig.repr(ccx.tcx()));
debug!("declare_rust_fn (after region erasure) sig={}", sig.repr());
let llfty = type_of::type_of_rust_fn(ccx, env, &sig, abi);
debug!("declare_rust_fn llfty={}", ccx.tn().type_to_string(llfty));

30
src/librustc_trans/trans/expr.rs
View file

@ -181,7 +181,7 @@ pub fn trans_into<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
}
}
debug!("trans_into() expr={}", expr.repr(bcx.tcx()));
debug!("trans_into() expr={}", expr.repr());
let cleanup_debug_loc = debuginfo::get_cleanup_debug_loc_for_ast_node(bcx.ccx(),
expr.id,
@ -330,8 +330,8 @@ pub fn unsized_info<'ccx, 'tcx>(ccx: &CrateContext<'ccx, 'tcx>,
Type::vtable_ptr(ccx))
}
_ => ccx.sess().bug(&format!("unsized_info: invalid unsizing {} -> {}",
source.repr(ccx.tcx()),
target.repr(ccx.tcx())))
source.repr(),
target.repr()))
}
}
@ -351,7 +351,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
Some(adj) => { adj }
};
debug!("unadjusted datum for expr {}: {} adjustment={:?}",
expr.repr(bcx.tcx()),
expr.repr(),
datum.to_string(bcx.ccx()),
adjustment);
match adjustment {
@ -502,7 +502,7 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
}
vtable => {
bcx.sess().span_bug(span, &format!("invalid CoerceUnsized vtable: {}",
vtable.repr(bcx.tcx())));
vtable.repr()));
}
};
@ -546,8 +546,8 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
}
}
_ => bcx.sess().bug(&format!("coerce_unsized: invalid coercion {} -> {}",
source.ty.repr(bcx.tcx()),
target.ty.repr(bcx.tcx())))
source.ty.repr(),
target.ty.repr()))
}
bcx
}
@ -1283,7 +1283,7 @@ pub fn trans_def_fn_unadjusted<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
ccx.tcx().sess.span_bug(ref_expr.span, &format!(
"trans_def_fn_unadjusted invoked on: {:?} for {}",
def,
ref_expr.repr(ccx.tcx())));
ref_expr.repr()));
}
}
}
@ -1356,7 +1356,7 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>,
tcx.sess.bug(&format!(
"cannot get field types from the enum type {} \
without a node ID",
ty.repr(tcx)));
ty.repr()));
}
Some(node_id) => {
let def = tcx.def_map.borrow().get(&node_id).unwrap().full_def();
@ -1379,7 +1379,7 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>,
_ => {
tcx.sess.bug(&format!(
"cannot get field types from the type {}",
ty.repr(tcx)));
ty.repr()));
}
}
}
@ -2060,7 +2060,7 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
let t_in = expr_ty_adjusted(bcx, expr);
let t_out = node_id_type(bcx, id);
debug!("trans_cast({} as {})", t_in.repr(bcx.tcx()), t_out.repr(bcx.tcx()));
debug!("trans_cast({} as {})", t_in.repr(), t_out.repr());
let mut ll_t_in = type_of::arg_type_of(ccx, t_in);
let ll_t_out = type_of::arg_type_of(ccx, t_out);
// Convert the value to be cast into a ValueRef, either by-ref or
@ -2124,8 +2124,8 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
_ => ccx.sess().span_bug(expr.span,
&format!("translating unsupported cast: \
{} -> {}",
t_in.repr(bcx.tcx()),
t_out.repr(bcx.tcx()))
t_in.repr(),
t_out.repr())
)
};
return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock();
@ -2211,7 +2211,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
let ccx = bcx.ccx();
debug!("deref_once(expr={}, datum={}, method_call={:?})",
expr.repr(bcx.tcx()),
expr.repr(),
datum.to_string(ccx),
method_call);
@ -2296,7 +2296,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
bcx.tcx().sess.span_bug(
expr.span,
&format!("deref invoked on expr of illegal type {}",
datum.ty.repr(bcx.tcx())));
datum.ty.repr()));
}
};

18
src/librustc_trans/trans/foreign.rs
View file

@ -186,8 +186,8 @@ pub fn register_foreign_item_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
debug!("register_foreign_item_fn(abi={}, \
ty={}, \
name={})",
abi.repr(ccx.tcx()),
fty.repr(ccx.tcx()),
abi.repr(),
fty.repr(),
name);
let cc = llvm_calling_convention(ccx, abi);
@ -238,7 +238,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
debug!("trans_native_call(callee_ty={}, \
llfn={}, \
llretptr={})",
callee_ty.repr(tcx),
callee_ty.repr(),
ccx.tn().val_to_string(llfn),
ccx.tn().val_to_string(llretptr));
@ -613,13 +613,13 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
ccx.sess().bug(&format!("build_rust_fn: extern fn {} has ty {}, \
expected a bare fn ty",
ccx.tcx().map.path_to_string(id),
t.repr(tcx)));
t.repr()));
}
};
debug!("build_rust_fn: path={} id={} t={}",
ccx.tcx().map.path_to_string(id),
id, t.repr(tcx));
id, t.repr());
let llfn = declare::define_internal_rust_fn(ccx, &ps[..], t).unwrap_or_else(||{
ccx.sess().bug(&format!("symbol `{}` already defined", ps));
@ -641,7 +641,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
debug!("build_wrap_fn(llrustfn={}, llwrapfn={}, t={})",
ccx.tn().val_to_string(llrustfn),
ccx.tn().val_to_string(llwrapfn),
t.repr(ccx.tcx()));
t.repr());
// Avoid all the Rust generation stuff and just generate raw
// LLVM here.
@ -726,7 +726,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
return_ty={}",
ccx.tn().val_to_string(slot),
ccx.tn().type_to_string(llrust_ret_ty),
tys.fn_sig.output.repr(tcx));
tys.fn_sig.output.repr());
llrust_args.push(slot);
return_alloca = Some(slot);
}
@ -818,7 +818,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
// Perform the call itself
debug!("calling llrustfn = {}, t = {}",
ccx.tn().val_to_string(llrustfn), t.repr(ccx.tcx()));
ccx.tn().val_to_string(llrustfn), t.repr());
let attributes = attributes::from_fn_type(ccx, t);
let llrust_ret_val = builder.call(llrustfn, &llrust_args, Some(attributes));
@ -940,7 +940,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
llsig={} -> {}, \
fn_ty={} -> {}, \
ret_def={}",
ty.repr(ccx.tcx()),
ty.repr(),
ccx.tn().types_to_str(&llsig.llarg_tys),
ccx.tn().type_to_string(llsig.llret_ty),
ccx.tn().types_to_str(&fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>()),

8
src/librustc_trans/trans/glue.rs
View file

@ -140,7 +140,7 @@ pub fn drop_ty_core<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
debug_loc: DebugLoc,
skip_dtor: bool) -> Block<'blk, 'tcx> {
// NB: v is an *alias* of type t here, not a direct value.
debug!("drop_ty_core(t={}, skip_dtor={})", t.repr(bcx.tcx()), skip_dtor);
debug!("drop_ty_core(t={}, skip_dtor={})", t.repr(), skip_dtor);
let _icx = push_ctxt("drop_ty");
if bcx.fcx.type_needs_drop(t) {
let ccx = bcx.ccx();
@ -207,10 +207,10 @@ impl<'tcx> DropGlueKind<'tcx> {
fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String {
match *self {
DropGlueKind::Ty(ty) => {
format!("DropGlueKind::Ty({})", ty.repr(ccx.tcx()))
format!("DropGlueKind::Ty({})", ty.repr())
}
DropGlueKind::TyContents(ty) => {
format!("DropGlueKind::TyContents({})", ty.repr(ccx.tcx()))
format!("DropGlueKind::TyContents({})", ty.repr())
}
}
}
@ -249,7 +249,7 @@ fn get_drop_glue_core<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
});
ccx.available_drop_glues().borrow_mut().insert(g, fn_nm);
let _s = StatRecorder::new(ccx, format!("drop {}", t.repr(ccx.tcx())));
let _s = StatRecorder::new(ccx, format!("drop {}", t.repr()));
let empty_substs = ccx.tcx().mk_substs(Substs::trans_empty());
let (arena, fcx): (TypedArena<_>, FunctionContext);

12
src/librustc_trans/trans/intrinsic.rs
View file

@ -102,7 +102,7 @@ pub fn check_intrinsics(ccx: &CrateContext) {
continue;
}
debug!("transmute_restriction: {}", transmute_restriction.repr(ccx.tcx()));
debug!("transmute_restriction: {}", transmute_restriction.repr());
assert!(!ty::type_has_params(transmute_restriction.substituted_from));
assert!(!ty::type_has_params(transmute_restriction.substituted_to));
@ -121,10 +121,10 @@ pub fn check_intrinsics(ccx: &CrateContext) {
transmute_restriction.span,
&format!("transmute called on types with potentially different sizes: \
{} (could be {} bit{}) to {} (could be {} bit{})",
transmute_restriction.original_from.user_string(ccx.tcx()),
transmute_restriction.original_from.user_string(),
from_type_size as usize,
if from_type_size == 1 {""} else {"s"},
transmute_restriction.original_to.user_string(ccx.tcx()),
transmute_restriction.original_to.user_string(),
to_type_size as usize,
if to_type_size == 1 {""} else {"s"}));
} else {
@ -132,10 +132,10 @@ pub fn check_intrinsics(ccx: &CrateContext) {
transmute_restriction.span,
&format!("transmute called on types with different sizes: \
{} ({} bit{}) to {} ({} bit{})",
transmute_restriction.original_from.user_string(ccx.tcx()),
transmute_restriction.original_from.user_string(),
from_type_size as usize,
if from_type_size == 1 {""} else {"s"},
transmute_restriction.original_to.user_string(ccx.tcx()),
transmute_restriction.original_to.user_string(),
to_type_size as usize,
if to_type_size == 1 {""} else {"s"}));
}
@ -405,7 +405,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
}
(_, "type_name") => {
let tp_ty = *substs.types.get(FnSpace, 0);
let ty_name = token::intern_and_get_ident(&tp_ty.user_string(ccx.tcx()));
let ty_name = token::intern_and_get_ident(&tp_ty.user_string());
C_str_slice(ccx, ty_name)
}
(_, "type_id") => {

50
src/librustc_trans/trans/meth.rs
View file

@ -62,7 +62,7 @@ pub fn trans_impl(ccx: &CrateContext,
let _icx = push_ctxt("meth::trans_impl");
let tcx = ccx.tcx();
debug!("trans_impl(name={}, id={})", name.repr(tcx), id);
debug!("trans_impl(name={}, id={})", name.repr(), id);
let mut v = TransItemVisitor { ccx: ccx };
@ -138,13 +138,13 @@ pub fn trans_method_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
let span = bcx.tcx().map.span(method_call.expr_id);
debug!("method_call={:?} trait_ref={} trait_ref id={:?} substs={:?}",
method_call,
trait_ref.repr(bcx.tcx()),
trait_ref.repr(),
trait_ref.0.def_id,
trait_ref.0.substs);
let origin = fulfill_obligation(bcx.ccx(),
span,
trait_ref.clone());
debug!("origin = {}", origin.repr(bcx.tcx()));
debug!("origin = {}", origin.repr());
trans_monomorphized_callee(bcx,
method_call,
trait_ref.def_id(),
@ -234,7 +234,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
rcvr_self,
Vec::new()));
let trait_substs = tcx.mk_substs(trait_substs);
debug!("trait_substs={}", trait_substs.repr(tcx));
debug!("trait_substs={}", trait_substs.repr());
let trait_ref = ty::Binder(ty::TraitRef { def_id: trait_id,
substs: trait_substs });
let vtbl = fulfill_obligation(ccx,
@ -297,7 +297,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
}
_ => {
tcx.sess.bug(&format!("static call to invalid vtable: {}",
vtbl.repr(tcx)));
vtbl.repr()));
}
}
}
@ -391,7 +391,7 @@ fn trans_monomorphized_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
traits::VtableParam(..) => {
bcx.sess().bug(
&format!("resolved vtable bad vtable {} in trans",
vtable.repr(bcx.tcx())));
vtable.repr()));
}
}
}
@ -415,8 +415,8 @@ fn combine_impl_and_methods_tps<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
let node_substs = node_id_substs(ccx, node, bcx.fcx.param_substs);
debug!("rcvr_substs={}", rcvr_substs.repr(ccx.tcx()));
debug!("node_substs={}", node_substs.repr(ccx.tcx()));
debug!("rcvr_substs={}", rcvr_substs.repr());
debug!("node_substs={}", node_substs.repr());
// Break apart the type parameters from the node and type
// parameters from the receiver.
@ -484,7 +484,7 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
// Load the data pointer from the object.
debug!("trans_trait_callee_from_llval(callee_ty={}, vtable_index={}, llpair={})",
callee_ty.repr(ccx.tcx()),
callee_ty.repr(),
vtable_index,
bcx.val_to_string(llpair));
let llboxptr = GEPi(bcx, llpair, &[0, abi::FAT_PTR_ADDR]);
@ -557,8 +557,8 @@ pub fn trans_object_shim<'a, 'tcx>(
let trait_id = upcast_trait_ref.def_id();
debug!("trans_object_shim(object_ty={}, upcast_trait_ref={}, method_offset_in_trait={})",
object_ty.repr(tcx),
upcast_trait_ref.repr(tcx),
object_ty.repr(),
upcast_trait_ref.repr(),
method_offset_in_trait);
let object_trait_ref =
@ -568,14 +568,14 @@ pub fn trans_object_shim<'a, 'tcx>(
}
_ => {
tcx.sess.bug(&format!("trans_object_shim() called on non-object: {}",
object_ty.repr(tcx)));
object_ty.repr()));
}
};
// Upcast to the trait in question and extract out the substitutions.
let upcast_trait_ref = ty::erase_late_bound_regions(tcx, &upcast_trait_ref);
let object_substs = upcast_trait_ref.substs.clone().erase_regions();
debug!("trans_object_shim: object_substs={}", object_substs.repr(tcx));
debug!("trans_object_shim: object_substs={}", object_substs.repr());
// Lookup the type of this method as declared in the trait and apply substitutions.
let method_ty = match ty::trait_item(tcx, trait_id, method_offset_in_trait) {
@ -587,7 +587,7 @@ pub fn trans_object_shim<'a, 'tcx>(
let fty = monomorphize::apply_param_substs(tcx, &object_substs, &method_ty.fty);
let fty = tcx.mk_bare_fn(fty);
let method_ty = opaque_method_ty(tcx, fty);
debug!("trans_object_shim: fty={} method_ty={}", fty.repr(tcx), method_ty.repr(tcx));
debug!("trans_object_shim: fty={} method_ty={}", fty.repr(), method_ty.repr());
//
let shim_fn_ty = ty::mk_bare_fn(tcx, None, fty);
@ -628,7 +628,7 @@ pub fn trans_object_shim<'a, 'tcx>(
_ => {
bcx.sess().bug(
&format!("rust-call expects a tuple not {}",
sig.inputs[1].repr(tcx)));
sig.inputs[1].repr()));
}
}
}
@ -692,7 +692,7 @@ pub fn get_vtable<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
let tcx = ccx.tcx();
let _icx = push_ctxt("meth::get_vtable");
debug!("get_vtable(trait_ref={})", trait_ref.repr(tcx));
debug!("get_vtable(trait_ref={})", trait_ref.repr());
// Check the cache.
match ccx.vtables().borrow().get(&trait_ref) {
@ -740,13 +740,13 @@ pub fn get_vtable<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
// cannot cast an unsized type into a trait object
tcx.sess.bug(
&format!("cannot get vtable for an object type: {}",
data.repr(tcx)));
data.repr()));
}
traits::VtableParam(..) => {
tcx.sess.bug(
&format!("resolved vtable for {} to bad vtable {} in trans",
trait_ref.repr(tcx),
vtable.repr(tcx)));
trait_ref.repr(),
vtable.repr()));
}
}
});
@ -777,9 +777,9 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
let tcx = ccx.tcx();
debug!("emit_vtable_methods(impl_id={}, substs={}, param_substs={})",
impl_id.repr(tcx),
substs.repr(tcx),
param_substs.repr(tcx));
impl_id.repr(),
substs.repr(),
param_substs.repr());
let trt_id = match ty::impl_trait_ref(tcx, impl_id) {
Some(t_id) => t_id.def_id,
@ -807,7 +807,7 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
// null.
.map(|trait_method_def_id| {
debug!("emit_vtable_methods: trait_method_def_id={}",
trait_method_def_id.repr(tcx));
trait_method_def_id.repr());
let trait_method_type = match ty::impl_or_trait_item(tcx, trait_method_def_id) {
ty::MethodTraitItem(m) => m,
@ -822,7 +822,7 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
}
debug!("emit_vtable_methods: trait_method_type={}",
trait_method_type.repr(tcx));
trait_method_type.repr());
// The substitutions we have are on the impl, so we grab
// the method type from the impl to substitute into.
@ -833,7 +833,7 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
};
debug!("emit_vtable_methods: impl_method_type={}",
impl_method_type.repr(tcx));
impl_method_type.repr());
// If this is a default method, it's possible that it
// relies on where clauses that do not hold for this

24
src/librustc_trans/trans/monomorphize.rs
View file

@ -44,8 +44,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
fn_id={}, \
real_substs={}, \
ref_id={:?})",
fn_id.repr(ccx.tcx()),
psubsts.repr(ccx.tcx()),
fn_id.repr(),
psubsts.repr(),
ref_id);
assert!(psubsts.types.all(|t| {
@ -61,7 +61,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
let item_ty = ty::lookup_item_type(ccx.tcx(), fn_id).ty;
debug!("monomorphic_fn about to subst into {}", item_ty.repr(ccx.tcx()));
debug!("monomorphic_fn about to subst into {}", item_ty.repr());
let mono_ty = item_ty.subst(ccx.tcx(), psubsts);
match ccx.monomorphized().borrow().get(&hash_id) {
@ -77,8 +77,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
fn_id={}, \
psubsts={}, \
hash_id={:?})",
fn_id.repr(ccx.tcx()),
psubsts.repr(ccx.tcx()),
fn_id.repr(),
psubsts.repr(),
hash_id);
@ -99,10 +99,10 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
}
}
debug!("mono_ty = {} (post-substitution)", mono_ty.repr(ccx.tcx()));
debug!("mono_ty = {} (post-substitution)", mono_ty.repr());
let mono_ty = normalize_associated_type(ccx.tcx(), &mono_ty);
debug!("mono_ty = {} (post-normalization)", mono_ty.repr(ccx.tcx()));
debug!("mono_ty = {} (post-normalization)", mono_ty.repr());
ccx.stats().n_monos.set(ccx.stats().n_monos.get() + 1);
@ -303,7 +303,7 @@ pub fn apply_param_substs<'tcx,T>(tcx: &ty::ctxt<'tcx>,
param_substs: &Substs<'tcx>,
value: &T)
-> T
where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
where T : TypeFoldable<'tcx> + Repr + HasProjectionTypes + Clone
{
let substituted = value.subst(tcx, param_substs);
normalize_associated_type(tcx, &substituted)
@ -314,9 +314,9 @@ pub fn apply_param_substs<'tcx,T>(tcx: &ty::ctxt<'tcx>,
/// and hence we can be sure that all associated types will be
/// completely normalized away.
pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T
where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
where T : TypeFoldable<'tcx> + Repr + HasProjectionTypes + Clone
{
debug!("normalize_associated_type(t={})", value.repr(tcx));
debug!("normalize_associated_type(t={})", value.repr());
let value = erase_regions(tcx, value);
@ -334,8 +334,8 @@ pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T
traits::normalize(&mut selcx, cause, &value);
debug!("normalize_associated_type: result={} obligations={}",
result.repr(tcx),
obligations.repr(tcx));
result.repr(),
obligations.repr());
let mut fulfill_cx = traits::FulfillmentContext::new(true);
for obligation in obligations {

2
src/librustc_trans/trans/tvec.rs
View file

@ -42,7 +42,7 @@ struct VecTypes<'tcx> {
impl<'tcx> VecTypes<'tcx> {
pub fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String {
format!("VecTypes {{unit_ty={}, llunit_ty={}}}",
self.unit_ty.user_string(ccx.tcx()),
self.unit_ty.user_string(),
ccx.tn().type_to_string(self.llunit_ty))
}
}

16
src/librustc_trans/trans/type_of.rs
View file

@ -100,7 +100,7 @@ pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
-> Type
{
debug!("type_of_rust_fn(sig={},abi={:?})",
sig.repr(cx.tcx()),
sig.repr(),
abi);
let sig = ty::erase_late_bound_regions(cx.tcx(), sig);
@ -229,7 +229,7 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ
ty::TyProjection(..) | ty::TyInfer(..) | ty::TyParam(..) | ty::TyError(..) => {
cx.sess().bug(&format!("fictitious type {} in sizing_type_of()",
t.repr(cx.tcx())))
t.repr()))
}
ty::TySlice(_) | ty::TyTrait(..) | ty::TyStr => unreachable!()
};
@ -298,7 +298,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) ->
None => ()
}
debug!("type_of {} {:?}", t.repr(cx.tcx()), t.sty);
debug!("type_of {} {:?}", t.repr(), t.sty);
assert!(!t.has_escaping_regions());
@ -312,9 +312,9 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) ->
if t != t_norm {
let llty = in_memory_type_of(cx, t_norm);
debug!("--> normalized {} {:?} to {} {:?} llty={}",
t.repr(cx.tcx()),
t.repr(),
t,
t_norm.repr(cx.tcx()),
t_norm.repr(),
t_norm,
cx.tn().type_to_string(llty));
cx.lltypes().borrow_mut().insert(t, llty);
@ -364,7 +364,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) ->
ty::TyTrait(_) => Type::vtable_ptr(cx),
_ => panic!("Unexpected type returned from \
struct_tail: {} for ty={}",
unsized_part.repr(cx.tcx()), ty.repr(cx.tcx()))
unsized_part.repr(), ty.repr())
};
Type::struct_(cx, &[ptr_ty, info_ty], false)
}
@ -419,7 +419,7 @@ pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) ->
};
debug!("--> mapped t={} {:?} to llty={}",
t.repr(cx.tcx()),
t.repr(),
t,
cx.tn().type_to_string(llty));
@ -449,7 +449,7 @@ fn llvm_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
tps: &[Ty<'tcx>])
-> String {
let base = ty::item_path_str(cx.tcx(), did);
let strings: Vec<String> = tps.iter().map(|t| t.repr(cx.tcx())).collect();
let strings: Vec<String> = tps.iter().map(|t| t.repr()).collect();
let tstr = if strings.is_empty() {
base
} else {

54
src/librustc_typeck/astconv.rs
View file

@ -179,9 +179,9 @@ pub fn ast_region_to_region(tcx: &ty::ctxt, lifetime: &ast::Lifetime)
};
debug!("ast_region_to_region(lifetime={} id={}) yields {}",
lifetime.repr(tcx),
lifetime.repr(),
lifetime.id,
r.repr(tcx));
r.repr());
r
}
@ -257,8 +257,8 @@ pub fn opt_ast_region_to_region<'tcx>(
};
debug!("opt_ast_region_to_region(opt_lifetime={}) yields {}",
opt_lifetime.repr(this.tcx()),
r.repr(this.tcx()));
opt_lifetime.repr(),
r.repr());
r
}
@ -375,8 +375,8 @@ fn create_substs_for_ast_path<'tcx>(
debug!("create_substs_for_ast_path(decl_generics={}, self_ty={}, \
types_provided={}, region_substs={}",
decl_generics.repr(tcx), self_ty.repr(tcx), types_provided.repr(tcx),
region_substs.repr(tcx));
decl_generics.repr(), self_ty.repr(), types_provided.repr(),
region_substs.repr());
assert_eq!(region_substs.regions().len(TypeSpace), decl_generics.regions.len(TypeSpace));
assert!(region_substs.types.is_empty());
@ -441,8 +441,8 @@ fn create_substs_for_ast_path<'tcx>(
"the type parameter `{}` must be explicitly specified \
in an object type because its default value `{}` references \
the type `Self`",
param.name.user_string(tcx),
default.user_string(tcx));
param.name.user_string(),
default.user_string());
substs.types.push(TypeSpace, tcx.types.err);
} else {
// This is a default type parameter.
@ -649,7 +649,7 @@ fn trait_def_id<'tcx>(this: &AstConv<'tcx>, trait_ref: &ast::TraitRef) -> ast::D
def::DefTrait(trait_def_id) => trait_def_id,
_ => {
span_fatal!(this.tcx().sess, path.span, E0245, "`{}` is not a trait",
path.user_string(this.tcx()));
path.user_string());
}
}
}
@ -879,7 +879,7 @@ fn ast_type_binding_to_poly_projection_predicate<'tcx>(
let candidate = try!(one_bound_for_assoc_type(tcx,
candidates,
&trait_ref.user_string(tcx),
&trait_ref.user_string(),
&token::get_name(binding.item_name),
binding.span));
@ -1031,7 +1031,7 @@ fn trait_ref_to_object_type<'tcx>(this: &AstConv<'tcx>,
let result = make_object_type(this, span, trait_ref, existential_bounds);
debug!("trait_ref_to_object_type: result={}",
result.repr(this.tcx()));
result.repr());
result
}
@ -1074,7 +1074,7 @@ fn make_object_type<'tcx>(this: &AstConv<'tcx>,
for (trait_def_id, name) in associated_types {
span_err!(tcx.sess, span, E0191,
"the value of the associated type `{}` (from the trait `{}`) must be specified",
name.user_string(tcx),
name.user_string(),
ty::item_path_str(tcx, trait_def_id));
}
@ -1160,7 +1160,7 @@ fn one_bound_for_assoc_type<'tcx>(tcx: &ty::ctxt<'tcx>,
span_note!(tcx.sess, span,
"associated type `{}` could derive from `{}`",
ty_param_name,
bound.user_string(tcx));
bound.user_string());
}
}
@ -1183,7 +1183,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>,
let tcx = this.tcx();
let assoc_name = item_segment.identifier.name;
debug!("associated_path_def_to_ty: {}::{}", ty.repr(tcx), token::get_name(assoc_name));
debug!("associated_path_def_to_ty: {}::{}", ty.repr(), token::get_name(assoc_name));
check_path_args(tcx, slice::ref_slice(item_segment), NO_TPS | NO_REGIONS);
@ -1239,7 +1239,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>,
_ => {
report_ambiguous_associated_type(tcx,
span,
&ty.user_string(tcx),
&ty.user_string(),
"Trait",
&token::get_name(assoc_name));
return (tcx.types.err, ty_path_def);
@ -1296,7 +1296,7 @@ fn qpath_to_ty<'tcx>(this: &AstConv<'tcx>,
return tcx.types.err;
};
debug!("qpath_to_ty: self_type={}", self_ty.repr(tcx));
debug!("qpath_to_ty: self_type={}", self_ty.repr());
let trait_ref = ast_path_to_mono_trait_ref(this,
rscope,
@ -1306,7 +1306,7 @@ fn qpath_to_ty<'tcx>(this: &AstConv<'tcx>,
Some(self_ty),
trait_segment);
debug!("qpath_to_ty: trait_ref={}", trait_ref.repr(tcx));
debug!("qpath_to_ty: trait_ref={}", trait_ref.repr());
this.projected_ty(span, trait_ref, item_segment.identifier.name)
}
@ -1496,7 +1496,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
-> Ty<'tcx>
{
debug!("ast_ty_to_ty(ast_ty={})",
ast_ty.repr(this.tcx()));
ast_ty.repr());
let tcx = this.tcx();
@ -1531,7 +1531,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
}
ast::TyRptr(ref region, ref mt) => {
let r = opt_ast_region_to_region(this, rscope, ast_ty.span, region);
debug!("TyRef r={}", r.repr(this.tcx()));
debug!("TyRef r={}", r.repr());
let rscope1 =
&ObjectLifetimeDefaultRscope::new(
rscope,
@ -1569,7 +1569,7 @@ pub fn ast_ty_to_ty<'tcx>(this: &AstConv<'tcx>,
}
} else {
tcx.sess.span_bug(ast_ty.span,
&format!("unbound path {}", ast_ty.repr(tcx)))
&format!("unbound path {}", ast_ty.repr()))
};
let def = path_res.base_def;
let base_ty_end = path.segments.len() - path_res.depth;
@ -1846,8 +1846,8 @@ fn determine_explicit_self_category<'a, 'tcx>(this: &AstConv<'tcx>,
debug!("determine_explicit_self_category(self_info.untransformed_self_ty={} \
explicit_type={} \
modifiers=({},{})",
self_info.untransformed_self_ty.repr(this.tcx()),
explicit_type.repr(this.tcx()),
self_info.untransformed_self_ty.repr(),
explicit_type.repr(),
impl_modifiers,
method_modifiers);
@ -1881,7 +1881,7 @@ pub fn ty_of_closure<'tcx>(
-> ty::ClosureTy<'tcx>
{
debug!("ty_of_closure(expected_sig={})",
expected_sig.repr(this.tcx()));
expected_sig.repr());
// new region names that appear inside of the fn decl are bound to
// that function type
@ -1919,8 +1919,8 @@ pub fn ty_of_closure<'tcx>(
ast::NoReturn(..) => ty::FnDiverging
};
debug!("ty_of_closure: input_tys={}", input_tys.repr(this.tcx()));
debug!("ty_of_closure: output_ty={}", output_ty.repr(this.tcx()));
debug!("ty_of_closure: input_tys={}", input_tys.repr());
debug!("ty_of_closure: output_ty={}", output_ty.repr());
ty::ClosureTy {
unsafety: unsafety,
@ -2039,8 +2039,8 @@ fn compute_object_lifetime_bound<'tcx>(
debug!("compute_opt_region_bound(explicit_region_bounds={:?}, \
principal_trait_ref={}, builtin_bounds={})",
explicit_region_bounds,
principal_trait_ref.repr(tcx),
builtin_bounds.repr(tcx));
principal_trait_ref.repr(),
builtin_bounds.repr());
if explicit_region_bounds.len() > 1 {
span_err!(tcx.sess, explicit_region_bounds[1].span, E0226,

6
src/librustc_typeck/check/_match.rs
View file

@ -41,8 +41,8 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
let tcx = pcx.fcx.ccx.tcx;
debug!("check_pat(pat={},expected={})",
pat.repr(tcx),
expected.repr(tcx));
pat.repr(),
expected.repr());
match pat.node {
ast::PatWild(_) => {
@ -222,7 +222,7 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
}
} else {
tcx.sess.span_bug(pat.span,
&format!("unbound path {}", pat.repr(tcx)))
&format!("unbound path {}", pat.repr()))
};
if let Some((opt_ty, segments, def)) =
resolve_ty_and_def_ufcs(fcx, path_res, Some(self_ty),

8
src/librustc_typeck/check/assoc.rs
View file

@ -24,15 +24,15 @@ pub fn normalize_associated_types_in<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
body_id: ast::NodeId,
value: &T)
-> T
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr<'tcx>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr
{
debug!("normalize_associated_types_in(value={})", value.repr(infcx.tcx));
debug!("normalize_associated_types_in(value={})", value.repr());
let mut selcx = SelectionContext::new(infcx, typer);
let cause = ObligationCause::new(span, body_id, MiscObligation);
let Normalized { value: result, obligations } = traits::normalize(&mut selcx, cause, value);
debug!("normalize_associated_types_in: result={} predicates={}",
result.repr(infcx.tcx),
obligations.repr(infcx.tcx));
result.repr(),
obligations.repr());
for obligation in obligations {
fulfillment_cx.register_predicate_obligation(infcx, obligation);
}

22
src/librustc_typeck/check/callee.rs
View file

@ -121,8 +121,8 @@ fn try_overloaded_call_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-> Option<CallStep<'tcx>>
{
debug!("try_overloaded_call_step(call_expr={}, adjusted_ty={}, autoderefs={})",
call_expr.repr(fcx.tcx()),
adjusted_ty.repr(fcx.tcx()),
call_expr.repr(),
adjusted_ty.repr(),
autoderefs);
// If the callee is a bare function or a closure, then we're all set.
@ -337,23 +337,23 @@ struct CallResolution<'tcx> {
closure_def_id: ast::DefId,
}
impl<'tcx> Repr<'tcx> for CallResolution<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for CallResolution<'tcx> {
fn repr(&self) -> String {
format!("CallResolution(call_expr={}, callee_expr={}, adjusted_ty={}, \
autoderefs={}, fn_sig={}, closure_def_id={})",
self.call_expr.repr(tcx),
self.callee_expr.repr(tcx),
self.adjusted_ty.repr(tcx),
self.call_expr.repr(),
self.callee_expr.repr(),
self.adjusted_ty.repr(),
self.autoderefs,
self.fn_sig.repr(tcx),
self.closure_def_id.repr(tcx))
self.fn_sig.repr(),
self.closure_def_id.repr())
}
}
impl<'tcx> DeferredCallResolution<'tcx> for CallResolution<'tcx> {
fn resolve<'a>(&mut self, fcx: &FnCtxt<'a,'tcx>) {
debug!("DeferredCallResolution::resolve() {}",
self.repr(fcx.tcx()));
self.repr());
// we should not be invoked until the closure kind has been
// determined by upvar inference
@ -376,7 +376,7 @@ impl<'tcx> DeferredCallResolution<'tcx> for CallResolution<'tcx> {
ty::ty_fn_sig(method_callee.ty)).unwrap();
debug!("attempt_resolution: method_callee={}",
method_callee.repr(fcx.tcx()));
method_callee.repr());
for (&method_arg_ty, &self_arg_ty) in
method_sig.inputs[1..].iter().zip(&self.fn_sig.inputs)

6
src/librustc_typeck/check/cast.rs
View file

@ -192,8 +192,8 @@ impl<'tcx> CastCheck<'tcx> {
self.expr_ty = structurally_resolved_type(fcx, self.span, self.expr_ty);
self.cast_ty = structurally_resolved_type(fcx, self.span, self.cast_ty);
debug!("check_cast({}, {} as {})", self.expr.id, self.expr_ty.repr(fcx.tcx()),
self.cast_ty.repr(fcx.tcx()));
debug!("check_cast({}, {} as {})", self.expr.id, self.expr_ty.repr(),
self.cast_ty.repr());
if ty::type_is_error(self.expr_ty) || ty::type_is_error(self.cast_ty) {
// No sense in giving duplicate error messages
@ -274,7 +274,7 @@ impl<'tcx> CastCheck<'tcx> {
-> Result<CastKind, CastError>
{
debug!("check_ptr_ptr_cast m_expr={} m_cast={}",
m_expr.repr(fcx.tcx()), m_cast.repr(fcx.tcx()));
m_expr.repr(), m_cast.repr());
// ptr-ptr cast. vtables must match.
// Cast to sized is OK

28
src/librustc_typeck/check/closure.rs
View file

@ -29,8 +29,8 @@ pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
body: &'tcx ast::Block,
expected: Expectation<'tcx>) {
debug!("check_expr_closure(expr={},expected={})",
expr.repr(fcx.tcx()),
expected.repr(fcx.tcx()));
expr.repr(),
expected.repr());
// It's always helpful for inference if we know the kind of
// closure sooner rather than later, so first examine the expected
@ -52,7 +52,7 @@ fn check_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
debug!("check_closure opt_kind={:?} expected_sig={}",
opt_kind,
expected_sig.repr(fcx.tcx()));
expected_sig.repr());
let mut fn_ty = astconv::ty_of_closure(
fcx,
@ -87,8 +87,8 @@ fn check_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
fn_ty.sig.0.inputs = vec![ty::mk_tup(fcx.tcx(), fn_ty.sig.0.inputs)];
debug!("closure for {} --> sig={} opt_kind={:?}",
expr_def_id.repr(fcx.tcx()),
fn_ty.sig.repr(fcx.tcx()),
expr_def_id.repr(),
fn_ty.sig.repr(),
opt_kind);
fcx.inh.closure_tys.borrow_mut().insert(expr_def_id, fn_ty);
@ -104,7 +104,7 @@ fn deduce_expectations_from_expected_type<'a,'tcx>(
-> (Option<ty::FnSig<'tcx>>,Option<ty::ClosureKind>)
{
debug!("deduce_expectations_from_expected_type(expected_ty={})",
expected_ty.repr(fcx.tcx()));
expected_ty.repr());
match expected_ty.sty {
ty::TyTrait(ref object_type) => {
@ -139,7 +139,7 @@ fn deduce_expectations_from_obligations<'a,'tcx>(
.iter()
.filter_map(|obligation| {
debug!("deduce_expectations_from_obligations: obligation.predicate={}",
obligation.predicate.repr(fcx.tcx()));
obligation.predicate.repr());
match obligation.predicate {
// Given a Projection predicate, we can potentially infer
@ -201,7 +201,7 @@ fn deduce_sig_from_projection<'a,'tcx>(
let tcx = fcx.tcx();
debug!("deduce_sig_from_projection({})",
projection.repr(tcx));
projection.repr());
let trait_ref = projection.to_poly_trait_ref();
@ -211,24 +211,24 @@ fn deduce_sig_from_projection<'a,'tcx>(
let arg_param_ty = *trait_ref.substs().types.get(subst::TypeSpace, 0);
let arg_param_ty = fcx.infcx().resolve_type_vars_if_possible(&arg_param_ty);
debug!("deduce_sig_from_projection: arg_param_ty {}", arg_param_ty.repr(tcx));
debug!("deduce_sig_from_projection: arg_param_ty {}", arg_param_ty.repr());
let input_tys = match arg_param_ty.sty {
ty::TyTuple(ref tys) => { (*tys).clone() }
_ => { return None; }
};
debug!("deduce_sig_from_projection: input_tys {}", input_tys.repr(tcx));
debug!("deduce_sig_from_projection: input_tys {}", input_tys.repr());
let ret_param_ty = projection.0.ty;
let ret_param_ty = fcx.infcx().resolve_type_vars_if_possible(&ret_param_ty);
debug!("deduce_sig_from_projection: ret_param_ty {}", ret_param_ty.repr(tcx));
debug!("deduce_sig_from_projection: ret_param_ty {}", ret_param_ty.repr());
let fn_sig = ty::FnSig {
inputs: input_tys,
output: ty::FnConverging(ret_param_ty),
variadic: false
};
debug!("deduce_sig_from_projection: fn_sig {}", fn_sig.repr(tcx));
debug!("deduce_sig_from_projection: fn_sig {}", fn_sig.repr());
Some(fn_sig)
}
@ -241,8 +241,8 @@ fn self_type_matches_expected_vid<'a,'tcx>(
{
let self_ty = fcx.infcx().shallow_resolve(trait_ref.self_ty());
debug!("self_type_matches_expected_vid(trait_ref={}, self_ty={})",
trait_ref.repr(fcx.tcx()),
self_ty.repr(fcx.tcx()));
trait_ref.repr(),
self_ty.repr());
match self_ty.sty {
ty::TyInfer(ty::TyVar(v)) if expected_vid == v => Some(trait_ref),
_ => None,

28
src/librustc_typeck/check/coercion.rs
View file

@ -105,8 +105,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
b: Ty<'tcx>)
-> CoerceResult<'tcx> {
debug!("Coerce.tys({} => {})",
a.repr(self.tcx()),
b.repr(self.tcx()));
a.repr(),
b.repr());
// Consider coercing the subtype to a DST
let unsize = self.unpack_actual_value(a, |a| {
@ -167,8 +167,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
mutbl_b: ast::Mutability)
-> CoerceResult<'tcx> {
debug!("coerce_borrowed_pointer(a={}, b={})",
a.repr(self.tcx()),
b.repr(self.tcx()));
a.repr(),
b.repr());
// If we have a parameter of type `&M T_a` and the value
// provided is `expr`, we will be adding an implicit borrow,
@ -239,8 +239,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
target: Ty<'tcx>)
-> CoerceResult<'tcx> {
debug!("coerce_unsized(source={}, target={})",
source.repr(self.tcx()),
target.repr(self.tcx()));
source.repr(),
target.repr());
let traits = (self.tcx().lang_items.unsize_trait(),
self.tcx().lang_items.coerce_unsized_trait());
@ -294,7 +294,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
// inference might unify those two inner type variables later.
let traits = [coerce_unsized_did, unsize_did];
while let Some(obligation) = queue.pop_front() {
debug!("coerce_unsized resolve step: {}", obligation.repr(self.tcx()));
debug!("coerce_unsized resolve step: {}", obligation.repr());
let trait_ref = match obligation.predicate {
ty::Predicate::Trait(ref tr) if traits.contains(&tr.def_id()) => {
tr.clone()
@ -336,7 +336,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
autoref: reborrow,
unsize: Some(target)
};
debug!("Success, coerced with {}", adjustment.repr(self.tcx()));
debug!("Success, coerced with {}", adjustment.repr());
Ok(Some(AdjustDerefRef(adjustment)))
}
@ -353,7 +353,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
self.unpack_actual_value(b, |b| {
debug!("coerce_from_fn_pointer(a={}, b={})",
a.repr(self.tcx()), b.repr(self.tcx()));
a.repr(), b.repr());
if let ty::TyBareFn(None, fn_ty_b) = b.sty {
match (fn_ty_a.unsafety, fn_ty_b.unsafety) {
@ -381,7 +381,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
self.unpack_actual_value(b, |b| {
debug!("coerce_from_fn_item(a={}, b={})",
a.repr(self.tcx()), b.repr(self.tcx()));
a.repr(), b.repr());
match b.sty {
ty::TyBareFn(None, _) => {
@ -400,8 +400,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
mutbl_b: ast::Mutability)
-> CoerceResult<'tcx> {
debug!("coerce_unsafe_ptr(a={}, b={})",
a.repr(self.tcx()),
b.repr(self.tcx()));
a.repr(),
b.repr());
let (is_ref, mt_a) = match a.sty {
ty::TyRef(_, mt) => (true, mt),
@ -436,7 +436,7 @@ pub fn mk_assignty<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
a: Ty<'tcx>,
b: Ty<'tcx>)
-> RelateResult<'tcx, ()> {
debug!("mk_assignty({} -> {})", a.repr(fcx.tcx()), b.repr(fcx.tcx()));
debug!("mk_assignty({} -> {})", a.repr(), b.repr());
let mut unsizing_obligations = vec![];
let adjustment = try!(indent(|| {
fcx.infcx().commit_if_ok(|_| {
@ -460,7 +460,7 @@ pub fn mk_assignty<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
}
if let Some(adjustment) = adjustment {
debug!("Success, coerced with {}", adjustment.repr(fcx.tcx()));
debug!("Success, coerced with {}", adjustment.repr());
fcx.write_adjustment(expr.id, adjustment);
}
Ok(())

42
src/librustc_typeck/check/compare_method.rs
View file

@ -39,10 +39,10 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
trait_m: &ty::Method<'tcx>,
impl_trait_ref: &ty::TraitRef<'tcx>) {
debug!("compare_impl_method(impl_trait_ref={})",
impl_trait_ref.repr(tcx));
impl_trait_ref.repr());
debug!("compare_impl_method: impl_trait_ref (liberated) = {}",
impl_trait_ref.repr(tcx));
impl_trait_ref.repr());
let infcx = infer::new_infer_ctxt(tcx);
let mut fulfillment_cx = traits::FulfillmentContext::new(true);
@ -64,7 +64,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
"method `{}` has a `{}` declaration in the impl, \
but not in the trait",
token::get_name(trait_m.name),
impl_m.explicit_self.repr(tcx));
impl_m.explicit_self.repr());
return;
}
(_, &ty::StaticExplicitSelfCategory) => {
@ -72,7 +72,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
"method `{}` has a `{}` declaration in the trait, \
but not in the impl",
token::get_name(trait_m.name),
trait_m.explicit_self.repr(tcx));
trait_m.explicit_self.repr());
return;
}
_ => {
@ -184,7 +184,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
.with_method(impl_to_skol_substs.types.get_slice(subst::FnSpace).to_vec(),
impl_to_skol_substs.regions().get_slice(subst::FnSpace).to_vec());
debug!("compare_impl_method: trait_to_skol_substs={}",
trait_to_skol_substs.repr(tcx));
trait_to_skol_substs.repr());
// Check region bounds. FIXME(@jroesch) refactor this away when removing
// ParamBounds.
@ -212,7 +212,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
infer::HigherRankedType,
&ty::Binder(impl_bounds));
debug!("compare_impl_method: impl_bounds={}",
impl_bounds.repr(tcx));
impl_bounds.repr());
// Normalize the associated types in the trait_bounds.
let trait_bounds = trait_m.predicates.instantiate(tcx, &trait_to_skol_substs);
@ -243,7 +243,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
normalize_cause.clone());
debug!("compare_impl_method: trait_bounds={}",
trait_param_env.caller_bounds.repr(tcx));
trait_param_env.caller_bounds.repr());
let mut selcx = traits::SelectionContext::new(&infcx, &trait_param_env);
@ -304,7 +304,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
abi: impl_m.fty.abi,
sig: ty::Binder(impl_sig) }));
debug!("compare_impl_method: impl_fty={}",
impl_fty.repr(tcx));
impl_fty.repr());
let (trait_sig, skol_map) =
infcx.skolemize_late_bound_regions(&trait_m.fty.sig, snapshot);
@ -325,7 +325,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
sig: ty::Binder(trait_sig) }));
debug!("compare_impl_method: trait_fty={}",
trait_fty.repr(tcx));
trait_fty.repr());
try!(infer::mk_subty(&infcx, false, origin, impl_fty, trait_fty));
@ -336,8 +336,8 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
Ok(()) => { }
Err(terr) => {
debug!("checking trait method for compatibility: impl ty {}, trait ty {}",
impl_fty.repr(tcx),
trait_fty.repr(tcx));
impl_fty.repr(),
trait_fty.repr());
span_err!(tcx.sess, impl_m_span, E0053,
"method `{}` has an incompatible type for trait: {}",
token::get_name(trait_m.name),
@ -385,10 +385,10 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
impl_generics={} \
trait_to_skol_substs={} \
impl_to_skol_substs={}",
trait_generics.repr(tcx),
impl_generics.repr(tcx),
trait_to_skol_substs.repr(tcx),
impl_to_skol_substs.repr(tcx));
trait_generics.repr(),
impl_generics.repr(),
trait_to_skol_substs.repr(),
impl_to_skol_substs.repr());
// Must have same number of early-bound lifetime parameters.
// Unfortunately, if the user screws up the bounds, then this
@ -417,7 +417,7 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>,
trait_c: &ty::AssociatedConst<'tcx>,
impl_trait_ref: &ty::TraitRef<'tcx>) {
debug!("compare_const_impl(impl_trait_ref={})",
impl_trait_ref.repr(tcx));
impl_trait_ref.repr());
let infcx = infer::new_infer_ctxt(tcx);
let mut fulfillment_cx = traits::FulfillmentContext::new(true);
@ -444,7 +444,7 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>,
.with_method(impl_to_skol_substs.types.get_slice(subst::FnSpace).to_vec(),
impl_to_skol_substs.regions().get_slice(subst::FnSpace).to_vec());
debug!("compare_const_impl: trait_to_skol_substs={}",
trait_to_skol_substs.repr(tcx));
trait_to_skol_substs.repr());
// Compute skolemized form of impl and trait const tys.
let impl_ty = impl_c.ty.subst(tcx, impl_to_skol_substs);
@ -462,7 +462,7 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>,
0,
&impl_ty);
debug!("compare_const_impl: impl_ty={}",
impl_ty.repr(tcx));
impl_ty.repr());
let trait_ty =
assoc::normalize_associated_types_in(&infcx,
@ -472,7 +472,7 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>,
0,
&trait_ty);
debug!("compare_const_impl: trait_ty={}",
trait_ty.repr(tcx));
trait_ty.repr());
infer::mk_subty(&infcx, false, origin, impl_ty, trait_ty)
});
@ -481,8 +481,8 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>,
Ok(()) => { }
Err(terr) => {
debug!("checking associated const for compatibility: impl ty {}, trait ty {}",
impl_ty.repr(tcx),
trait_ty.repr(tcx));
impl_ty.repr(),
trait_ty.repr());
span_err!(tcx.sess, impl_c_span, E0326,
"implemented const `{}` has an incompatible type for \
trait: {}",

4
src/librustc_typeck/check/demand.rs
View file

@ -60,8 +60,8 @@ pub fn coerce<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
expr: &ast::Expr) {
let expr_ty = fcx.expr_ty(expr);
debug!("demand::coerce(expected = {}, expr_ty = {})",
expected.repr(fcx.ccx.tcx),
expr_ty.repr(fcx.ccx.tcx));
expected.repr(),
expr_ty.repr());
let expr_ty = fcx.resolve_type_vars_if_possible(expr_ty);
let expected = fcx.resolve_type_vars_if_possible(expected);
match coercion::mk_assignty(fcx, expr, expr_ty, expected) {

36
src/librustc_typeck/check/dropck.rs
View file

@ -62,7 +62,7 @@ pub fn check_drop_impl(tcx: &ty::ctxt, drop_impl_did: ast::DefId) -> Result<(),
let span = tcx.map.def_id_span(drop_impl_did, codemap::DUMMY_SP);
tcx.sess.span_bug(
span, &format!("should have been rejected by coherence check: {}",
dtor_self_type.repr(tcx)));
dtor_self_type.repr()));
}
}
}
@ -212,7 +212,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
if !assumptions_in_impl_context.contains(&predicate) {
let item_span = tcx.map.span(self_type_did.node);
let req = predicate.user_string(tcx);
let req = predicate.user_string();
span_err!(tcx.sess, drop_impl_span, E0367,
"The requirement `{}` is added only by the Drop impl.", req);
tcx.sess.span_note(item_span,
@ -258,7 +258,7 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>
span: Span,
scope: region::CodeExtent) {
debug!("check_safety_of_destructor_if_necessary typ: {} scope: {:?}",
typ.repr(rcx.tcx()), scope);
typ.repr(), scope);
// types that have been traversed so far by `traverse_type_if_unseen`
let mut breadcrumbs: Vec<Ty<'tcx>> = Vec::new();
@ -278,7 +278,7 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>
let tcx = rcx.tcx();
span_err!(tcx.sess, span, E0320,
"overflow while adding drop-check rules for {}",
typ.user_string(rcx.tcx()));
typ.user_string());
match *ctxt {
TypeContext::Root => {
// no need for an additional note if the overflow
@ -294,7 +294,7 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>
ty::item_path_str(tcx, def_id),
variant,
arg_index,
detected_on_typ.user_string(rcx.tcx()));
detected_on_typ.user_string());
}
TypeContext::Struct { def_id, field } => {
span_note!(
@ -303,7 +303,7 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>
"overflowed on struct {} field {} type: {}",
ty::item_path_str(tcx, def_id),
field,
detected_on_typ.user_string(rcx.tcx()));
detected_on_typ.user_string());
}
}
}
@ -373,7 +373,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>(
.opt_get(subst::TypeSpace, 0).unwrap();
let new_typ = substs.type_for_def(tp_def);
debug!("replacing phantom {} with {}",
typ.repr(rcx.tcx()), new_typ.repr(rcx.tcx()));
typ.repr(), new_typ.repr());
(new_typ, xref_depth_orig + 1)
} else {
(typ, xref_depth_orig)
@ -385,7 +385,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>(
// puts us into the previous case.
ty::TyBox(new_typ) => {
debug!("replacing TyBox {} with {}",
typ.repr(rcx.tcx()), new_typ.repr(rcx.tcx()));
typ.repr(), new_typ.repr());
(new_typ, xref_depth_orig + 1)
}
@ -411,7 +411,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>(
debug!("iterate_over_potentially_unsafe_regions_in_type \
{}typ: {} scope: {:?} xref: {}",
(0..depth).map(|_| ' ').collect::<String>(),
typ.repr(rcx.tcx()), scope, xref_depth);
typ.repr(), scope, xref_depth);
// If `typ` has a destructor, then we must ensure that all
// borrowed data reachable via `typ` must outlive the parent
@ -468,7 +468,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>(
match typ.sty {
ty::TyStruct(struct_did, substs) => {
debug!("typ: {} is struct; traverse structure and not type-expression",
typ.repr(rcx.tcx()));
typ.repr());
// Don't recurse; we extract type's substructure,
// so do not process subparts of type expression.
walker.skip_current_subtree();
@ -498,7 +498,7 @@ fn iterate_over_potentially_unsafe_regions_in_type<'a, 'tcx>(
ty::TyEnum(enum_did, substs) => {
debug!("typ: {} is enum; traverse structure and not type-expression",
typ.repr(rcx.tcx()));
typ.repr());
// Don't recurse; we extract type's substructure,
// so do not process subparts of type expression.
walker.skip_current_subtree();
@ -572,23 +572,23 @@ fn has_dtor_of_interest<'tcx>(tcx: &ty::ctxt<'tcx>,
DtorKind::PureRecur => {
has_dtor_of_interest = false;
debug!("typ: {} has no dtor, and thus is uninteresting",
typ.repr(tcx));
typ.repr());
}
DtorKind::Unknown(bounds) => {
match bounds.region_bound {
ty::ReStatic => {
debug!("trait: {} has 'static bound, and thus is uninteresting",
typ.repr(tcx));
typ.repr());
has_dtor_of_interest = false;
}
ty::ReEmpty => {
debug!("trait: {} has empty region bound, and thus is uninteresting",
typ.repr(tcx));
typ.repr());
has_dtor_of_interest = false;
}
r => {
debug!("trait: {} has non-static bound: {}; assumed interesting",
typ.repr(tcx), r.repr(tcx));
typ.repr(), r.repr());
has_dtor_of_interest = true;
}
}
@ -646,7 +646,7 @@ fn has_dtor_of_interest<'tcx>(tcx: &ty::ctxt<'tcx>,
if result {
has_pred_of_interest = true;
debug!("typ: {} has interesting dtor due to generic preds, e.g. {}",
typ.repr(tcx), pred.repr(tcx));
typ.repr(), pred.repr());
break 'items;
}
}
@ -672,12 +672,12 @@ fn has_dtor_of_interest<'tcx>(tcx: &ty::ctxt<'tcx>,
if has_dtor_of_interest {
debug!("typ: {} has interesting dtor, due to \
region params: {} or pred: {}",
typ.repr(tcx),
typ.repr(),
has_region_param_of_interest,
has_pred_of_interest);
} else {
debug!("typ: {} has dtor, but it is uninteresting",
typ.repr(tcx));
typ.repr());
}
}
}

50
src/librustc_typeck/check/method/confirm.rs
View file

@ -57,9 +57,9 @@ pub fn confirm<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-> MethodCallee<'tcx>
{
debug!("confirm(unadjusted_self_ty={}, pick={}, supplied_method_types={})",
unadjusted_self_ty.repr(fcx.tcx()),
pick.repr(fcx.tcx()),
supplied_method_types.repr(fcx.tcx()));
unadjusted_self_ty.repr(),
pick.repr(),
supplied_method_types.repr());
let mut confirm_cx = ConfirmContext::new(fcx, span, self_expr, call_expr);
confirm_cx.confirm(unadjusted_self_ty, pick, supplied_method_types)
@ -93,7 +93,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
let (method_types, method_regions) =
self.instantiate_method_substs(&pick, supplied_method_types);
let all_substs = rcvr_substs.with_method(method_types, method_regions);
debug!("all_substs={}", all_substs.repr(self.tcx()));
debug!("all_substs={}", all_substs.repr());
// Create the final signature for the method, replacing late-bound regions.
let InstantiatedMethodSig {
@ -226,9 +226,9 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
let upcast_trait_ref =
this.replace_late_bound_regions_with_fresh_var(&upcast_poly_trait_ref);
debug!("original_poly_trait_ref={} upcast_trait_ref={} target_trait={}",
original_poly_trait_ref.repr(this.tcx()),
upcast_trait_ref.repr(this.tcx()),
trait_def_id.repr(this.tcx()));
original_poly_trait_ref.repr(),
upcast_trait_ref.repr(),
trait_def_id.repr());
let substs = upcast_trait_ref.substs.clone();
let origin = MethodTraitObject(MethodObject {
trait_ref: upcast_trait_ref,
@ -322,7 +322,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
self.tcx().sess.span_bug(
self.span,
&format!("self-type `{}` for ObjectPick never dereferenced to an object",
self_ty.repr(self.tcx())))
self_ty.repr()))
}
}
}
@ -378,8 +378,8 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
self.span,
&format!(
"{} was a subtype of {} but now is not?",
self_ty.repr(self.tcx()),
method_self_ty.repr(self.tcx())));
self_ty.repr(),
method_self_ty.repr()));
}
}
}
@ -393,8 +393,8 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
-> InstantiatedMethodSig<'tcx>
{
debug!("instantiate_method_sig(pick={}, all_substs={})",
pick.repr(self.tcx()),
all_substs.repr(self.tcx()));
pick.repr(),
all_substs.repr());
// Instantiate the bounds on the method with the
// type/early-bound-regions substitutions performed. There can
@ -405,7 +405,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
&method_predicates);
debug!("method_predicates after subst = {}",
method_predicates.repr(self.tcx()));
method_predicates.repr());
// Instantiate late-bound regions and substitute the trait
// parameters into the method type to get the actual method type.
@ -416,11 +416,11 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
let method_sig = self.replace_late_bound_regions_with_fresh_var(
&pick.item.as_opt_method().unwrap().fty.sig);
debug!("late-bound lifetimes from method instantiated, method_sig={}",
method_sig.repr(self.tcx()));
method_sig.repr());
let method_sig = self.fcx.instantiate_type_scheme(self.span, &all_substs, &method_sig);
debug!("type scheme substituted, method_sig={}",
method_sig.repr(self.tcx()));
method_sig.repr());
InstantiatedMethodSig {
method_sig: method_sig,
@ -434,9 +434,9 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
all_substs: &subst::Substs<'tcx>,
method_predicates: &ty::InstantiatedPredicates<'tcx>) {
debug!("add_obligations: pick={} all_substs={} method_predicates={}",
pick.repr(self.tcx()),
all_substs.repr(self.tcx()),
method_predicates.repr(self.tcx()));
pick.repr(),
all_substs.repr(),
method_predicates.repr());
self.fcx.add_obligations_for_parameters(
traits::ObligationCause::misc(self.span, self.fcx.body_id),
@ -484,7 +484,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
}
debug!("fixup_derefs_on_method_receiver_if_necessary: exprs={}",
exprs.repr(self.tcx()));
exprs.repr());
// Fix up autoderefs and derefs.
for (i, &expr) in exprs.iter().rev().enumerate() {
@ -499,7 +499,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
};
debug!("fixup_derefs_on_method_receiver_if_necessary: i={} expr={} autoderef_count={}",
i, expr.repr(self.tcx()), autoderef_count);
i, expr.repr(), autoderef_count);
if autoderef_count > 0 {
check::autoderef(self.fcx,
@ -546,7 +546,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
self.tcx().sess.span_bug(
base_expr.span,
&format!("unexpected adjustment autoref {}",
adr.repr(self.tcx())));
adr.repr()));
}
},
None => (0, None),
@ -648,16 +648,16 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
self.tcx().sess.span_bug(
self.span,
&format!("cannot uniquely upcast `{}` to `{}`: `{}`",
source_trait_ref.repr(self.tcx()),
target_trait_def_id.repr(self.tcx()),
upcast_trait_refs.repr(self.tcx())));
source_trait_ref.repr(),
target_trait_def_id.repr(),
upcast_trait_refs.repr()));
}
upcast_trait_refs.into_iter().next().unwrap()
}
fn replace_late_bound_regions_with_fresh_var<T>(&self, value: &ty::Binder<T>) -> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
self.infcx().replace_late_bound_regions_with_fresh_var(
self.span, infer::FnCall, value).0

26
src/librustc_typeck/check/method/mod.rs
View file

@ -97,10 +97,10 @@ pub fn lookup<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-> Result<ty::MethodCallee<'tcx>, MethodError>
{
debug!("lookup(method_name={}, self_ty={}, call_expr={}, self_expr={})",
method_name.repr(fcx.tcx()),
self_ty.repr(fcx.tcx()),
call_expr.repr(fcx.tcx()),
self_expr.repr(fcx.tcx()));
method_name.repr(),
self_ty.repr(),
call_expr.repr(),
self_expr.repr());
let mode = probe::Mode::MethodCall;
let self_ty = fcx.infcx().resolve_type_vars_if_possible(&self_ty);
@ -142,10 +142,10 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-> Option<ty::MethodCallee<'tcx>>
{
debug!("lookup_in_trait_adjusted(self_ty={}, self_expr={}, m_name={}, trait_def_id={})",
self_ty.repr(fcx.tcx()),
self_expr.repr(fcx.tcx()),
m_name.repr(fcx.tcx()),
trait_def_id.repr(fcx.tcx()));
self_ty.repr(),
self_expr.repr(),
m_name.repr(),
trait_def_id.repr());
let trait_def = ty::lookup_trait_def(fcx.tcx(), trait_def_id);
@ -191,7 +191,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
assert_eq!(method_ty.generics.regions.len(subst::FnSpace), 0);
debug!("lookup_in_trait_adjusted: method_num={} method_ty={}",
method_num, method_ty.repr(fcx.tcx()));
method_num, method_ty.repr());
// Instantiate late-bound regions and substitute the trait
// parameters into the method type to get the actual method type.
@ -211,8 +211,8 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
}));
debug!("lookup_in_trait_adjusted: matched method fty={} obligation={}",
fty.repr(fcx.tcx()),
obligation.repr(fcx.tcx()));
fty.repr(),
obligation.repr());
// Register obligations for the parameters. This will include the
// `Self` parameter, which in turn has a bound of the main trait,
@ -272,7 +272,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
span,
&format!(
"trait method is &self but first arg is: {}",
transformed_self_ty.repr(fcx.tcx())));
transformed_self_ty.repr()));
}
}
}
@ -296,7 +296,7 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
substs: trait_ref.substs.clone()
};
debug!("callee = {}", callee.repr(fcx.tcx()));
debug!("callee = {}", callee.repr());
Some(callee)
}

122
src/librustc_typeck/check/method/probe.rs
View file

@ -124,7 +124,7 @@ pub fn probe<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
-> PickResult<'tcx>
{
debug!("probe(self_ty={}, item_name={}, scope_expr_id={})",
self_ty.repr(fcx.tcx()),
self_ty.repr(),
item_name,
scope_expr_id);
@ -164,8 +164,8 @@ pub fn probe<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
};
debug!("ProbeContext: steps for self_ty={} are {}",
self_ty.repr(fcx.tcx()),
steps.repr(fcx.tcx()));
self_ty.repr(),
steps.repr());
// this creates one big transaction so that all type variables etc
// that we create during the probe process are removed later
@ -269,7 +269,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
fn assemble_probe(&mut self, self_ty: Ty<'tcx>) {
debug!("assemble_probe: self_ty={}",
self_ty.repr(self.tcx()));
self_ty.repr());
match self_ty.sty {
ty::TyTrait(box ref data) => {
@ -412,7 +412,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
let traits::Normalized { value: xform_self_ty, obligations } =
traits::normalize(selcx, cause, &xform_self_ty);
debug!("assemble_inherent_impl_probe: xform_self_ty = {:?}",
xform_self_ty.repr(self.tcx()));
xform_self_ty.repr());
self.inherent_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
@ -425,7 +425,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
self_ty: Ty<'tcx>,
data: &ty::TraitTy<'tcx>) {
debug!("assemble_inherent_candidates_from_object(self_ty={})",
self_ty.repr(self.tcx()));
self_ty.repr());
let tcx = self.tcx();
@ -497,9 +497,9 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
if let Some(ref m) = item.as_opt_method() {
debug!("found match: trait_ref={} substs={} m={}",
trait_ref.repr(this.tcx()),
trait_ref.substs.repr(this.tcx()),
m.repr(this.tcx()));
trait_ref.repr(),
trait_ref.substs.repr(),
m.repr());
assert_eq!(m.generics.types.get_slice(subst::TypeSpace).len(),
trait_ref.substs.types.get_slice(subst::TypeSpace).len());
assert_eq!(m.generics.regions.get_slice(subst::TypeSpace).len(),
@ -539,7 +539,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
usize,
),
{
debug!("elaborate_bounds(bounds={})", bounds.repr(self.tcx()));
debug!("elaborate_bounds(bounds={})", bounds.repr());
let tcx = self.tcx();
for bound_trait_ref in traits::transitive_bounds(tcx, bounds) {
@ -589,7 +589,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
-> Result<(),MethodError>
{
debug!("assemble_extension_candidates_for_trait(trait_def_id={})",
trait_def_id.repr(self.tcx()));
trait_def_id.repr());
// Check whether `trait_def_id` defines a method with suitable name:
let trait_items =
@ -639,8 +639,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
// FIXME(arielb1): can we use for_each_relevant_impl here?
trait_def.for_each_impl(self.tcx(), |impl_def_id| {
debug!("assemble_extension_candidates_for_trait_impl: trait_def_id={} impl_def_id={}",
trait_def_id.repr(self.tcx()),
impl_def_id.repr(self.tcx()));
trait_def_id.repr(),
impl_def_id.repr());
if !self.impl_can_possibly_match(impl_def_id) {
return;
@ -648,14 +648,14 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
let (_, impl_substs) = self.impl_ty_and_substs(impl_def_id);
debug!("impl_substs={}", impl_substs.repr(self.tcx()));
debug!("impl_substs={}", impl_substs.repr());
let impl_trait_ref =
ty::impl_trait_ref(self.tcx(), impl_def_id)
.unwrap() // we know this is a trait impl
.subst(self.tcx(), &impl_substs);
debug!("impl_trait_ref={}", impl_trait_ref.repr(self.tcx()));
debug!("impl_trait_ref={}", impl_trait_ref.repr());
// Determine the receiver type that the method itself expects.
let xform_self_ty =
@ -671,7 +671,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
let traits::Normalized { value: xform_self_ty, obligations } =
traits::normalize(selcx, cause, &xform_self_ty);
debug!("xform_self_ty={}", xform_self_ty.repr(self.tcx()));
debug!("xform_self_ty={}", xform_self_ty.repr());
self.extension_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
@ -772,13 +772,13 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
trait_def_id={}, \
item={}, \
item_index={})",
trait_def_id.repr(self.tcx()),
item.repr(self.tcx()),
trait_def_id.repr(),
item.repr(),
item_index);
for step in self.steps.iter() {
debug!("assemble_projection_candidates: step={}",
step.repr(self.tcx()));
step.repr());
let projection_trait_ref = match step.self_ty.sty {
ty::TyProjection(ref data) => &data.trait_ref,
@ -786,14 +786,14 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
};
debug!("assemble_projection_candidates: projection_trait_ref={}",
projection_trait_ref.repr(self.tcx()));
projection_trait_ref.repr());
let trait_predicates = ty::lookup_predicates(self.tcx(),
projection_trait_ref.def_id);
let bounds = trait_predicates.instantiate(self.tcx(), projection_trait_ref.substs);
let predicates = bounds.predicates.into_vec();
debug!("assemble_projection_candidates: predicates={}",
predicates.repr(self.tcx()));
predicates.repr());
for poly_bound in
traits::elaborate_predicates(self.tcx(), predicates)
.filter_map(|p| p.to_opt_poly_trait_ref())
@ -802,8 +802,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
let bound = self.erase_late_bound_regions(&poly_bound);
debug!("assemble_projection_candidates: projection_trait_ref={} bound={}",
projection_trait_ref.repr(self.tcx()),
bound.repr(self.tcx()));
projection_trait_ref.repr(),
bound.repr());
if self.infcx().can_equate(&step.self_ty, &bound.self_ty()).is_ok() {
let xform_self_ty = self.xform_self_ty(&item,
@ -811,8 +811,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
bound.substs);
debug!("assemble_projection_candidates: bound={} xform_self_ty={}",
bound.repr(self.tcx()),
xform_self_ty.repr(self.tcx()));
bound.repr(),
xform_self_ty.repr());
self.extension_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
@ -830,7 +830,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
item_index: usize)
{
debug!("assemble_where_clause_candidates(trait_def_id={})",
trait_def_id.repr(self.tcx()));
trait_def_id.repr());
let caller_predicates = self.fcx.inh.param_env.caller_bounds.clone();
for poly_bound in traits::elaborate_predicates(self.tcx(), caller_predicates)
@ -843,8 +843,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
bound.substs);
debug!("assemble_where_clause_candidates: bound={} xform_self_ty={}",
bound.repr(self.tcx()),
xform_self_ty.repr(self.tcx()));
bound.repr(),
xform_self_ty.repr());
self.extension_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
@ -910,7 +910,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
}
fn pick_step(&mut self, step: &CandidateStep<'tcx>) -> Option<PickResult<'tcx>> {
debug!("pick_step: step={}", step.repr(self.tcx()));
debug!("pick_step: step={}", step.repr());
if ty::type_is_error(step.self_ty) {
return None;
@ -1008,7 +1008,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
.filter(|&probe| self.consider_probe(self_ty, probe))
.collect();
debug!("applicable_candidates: {}", applicable_candidates.repr(self.tcx()));
debug!("applicable_candidates: {}", applicable_candidates.repr());
if applicable_candidates.len() > 1 {
match self.collapse_candidates_to_trait_pick(&applicable_candidates[..]) {
@ -1030,8 +1030,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
fn consider_probe(&self, self_ty: Ty<'tcx>, probe: &Candidate<'tcx>) -> bool {
debug!("consider_probe: self_ty={} probe={}",
self_ty.repr(self.tcx()),
probe.repr(self.tcx()));
self_ty.repr(),
probe.repr());
self.infcx().probe(|_| {
// First check that the self type can be related.
@ -1065,7 +1065,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
traits::predicates_for_generics(self.tcx(),
cause.clone(),
&impl_bounds);
debug!("impl_obligations={}", obligations.repr(self.tcx()));
debug!("impl_obligations={}", obligations.repr());
// Evaluate those obligations to see if they might possibly hold.
obligations.iter()
@ -1178,9 +1178,9 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
-> Ty<'tcx>
{
debug!("xform_self_ty(impl_ty={}, self_ty={}, substs={})",
impl_ty.repr(self.tcx()),
method.fty.sig.0.inputs.get(0).repr(self.tcx()),
substs.repr(self.tcx()));
impl_ty.repr(),
method.fty.sig.0.inputs.get(0).repr(),
substs.repr());
assert!(!substs.has_escaping_regions());
@ -1265,7 +1265,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
/// and/or tracking the substitution and
/// so forth.
fn erase_late_bound_regions<T>(&self, value: &ty::Binder<T>) -> T
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
ty::erase_late_bound_regions(self.tcx(), value)
}
@ -1372,58 +1372,58 @@ impl<'tcx> Candidate<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for Candidate<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for Candidate<'tcx> {
fn repr(&self) -> String {
format!("Candidate(xform_self_ty={}, kind={})",
self.xform_self_ty.repr(tcx),
self.kind.repr(tcx))
self.xform_self_ty.repr(),
self.kind.repr())
}
}
impl<'tcx> Repr<'tcx> for CandidateKind<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for CandidateKind<'tcx> {
fn repr(&self) -> String {
match *self {
InherentImplCandidate(ref a, ref b, ref c) =>
format!("InherentImplCandidate({},{},{})", a.repr(tcx), b.repr(tcx),
c.repr(tcx)),
format!("InherentImplCandidate({},{},{})", a.repr(), b.repr(),
c.repr()),
ObjectCandidate(a, b, c) =>
format!("ObjectCandidate({},{},{})", a.repr(tcx), b, c),
format!("ObjectCandidate({},{},{})", a.repr(), b, c),
ExtensionImplCandidate(ref a, ref b, ref c, ref d, ref e) =>
format!("ExtensionImplCandidate({},{},{},{},{})", a.repr(tcx), b.repr(tcx),
c.repr(tcx), d, e.repr(tcx)),
format!("ExtensionImplCandidate({},{},{},{},{})", a.repr(), b.repr(),
c.repr(), d, e.repr()),
ClosureCandidate(ref a, ref b) =>
format!("ClosureCandidate({},{})", a.repr(tcx), b),
format!("ClosureCandidate({},{})", a.repr(), b),
WhereClauseCandidate(ref a, ref b) =>
format!("WhereClauseCandidate({},{})", a.repr(tcx), b),
format!("WhereClauseCandidate({},{})", a.repr(), b),
ProjectionCandidate(ref a, ref b) =>
format!("ProjectionCandidate({},{})", a.repr(tcx), b),
format!("ProjectionCandidate({},{})", a.repr(), b),
}
}
}
impl<'tcx> Repr<'tcx> for CandidateStep<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for CandidateStep<'tcx> {
fn repr(&self) -> String {
format!("CandidateStep({}, autoderefs={}, unsize={})",
self.self_ty.repr(tcx),
self.self_ty.repr(),
self.autoderefs,
self.unsize)
}
}
impl<'tcx> Repr<'tcx> for PickKind<'tcx> {
fn repr(&self, _tcx: &ty::ctxt) -> String {
impl<'tcx> Repr for PickKind<'tcx> {
fn repr(&self) -> String {
format!("{:?}", self)
}
}
impl<'tcx> Repr<'tcx> for Pick<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for Pick<'tcx> {
fn repr(&self) -> String {
format!("Pick(item={}, autoderefs={},
autoref={}, unsize={}, kind={:?})",
self.item.repr(tcx),
self.item.repr(),
self.autoderefs,
self.autoref.repr(tcx),
self.unsize.repr(tcx),
self.autoref.repr(),
self.unsize.repr(),
self.kind)
}
}

8
src/librustc_typeck/check/method/suggest.rs
View file

@ -45,7 +45,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
match error {
MethodError::NoMatch(static_sources, out_of_scope_traits, mode) => {
let cx = fcx.tcx();
let item_ustring = item_name.user_string(cx);
let item_ustring = item_name.user_string();
fcx.type_error_message(
span,
@ -93,7 +93,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
let msg = format!("the `{}` method from the `{}` trait cannot be explicitly \
invoked on this closure as we have not yet inferred what \
kind of closure it is",
item_name.user_string(fcx.tcx()),
item_name.user_string(),
ty::item_path_str(fcx.tcx(), trait_def_id));
let msg = if let Some(callee) = rcvr_expr {
format!("{}; use overloaded call notation instead (e.g., `{}()`)",
@ -134,7 +134,7 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
"candidate #{} is defined in an impl{} for the type `{}`",
idx + 1,
insertion,
impl_ty.user_string(fcx.tcx()));
impl_ty.user_string());
}
CandidateSource::TraitSource(trait_did) => {
let (_, item) = trait_item(fcx.tcx(), trait_did, item_name).unwrap();
@ -160,7 +160,7 @@ fn suggest_traits_to_import<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
valid_out_of_scope_traits: Vec<ast::DefId>)
{
let tcx = fcx.tcx();
let item_ustring = item_name.user_string(tcx);
let item_ustring = item_name.user_string();
if !valid_out_of_scope_traits.is_empty() {
let mut candidates = valid_out_of_scope_traits;

114
src/librustc_typeck/check/mod.rs
View file

@ -398,7 +398,7 @@ impl<'a, 'tcx> Inherited<'a, 'tcx> {
body_id: ast::NodeId,
value: &T)
-> T
where T : TypeFoldable<'tcx> + Clone + HasProjectionTypes + Repr<'tcx>
where T : TypeFoldable<'tcx> + Clone + HasProjectionTypes + Repr
{
let mut fulfillment_cx = self.fulfillment_cx.borrow_mut();
assoc::normalize_associated_types_in(&self.infcx,
@ -587,7 +587,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
token::get_ident(path1.node),
self.fcx.infcx().ty_to_string(
self.fcx.inh.locals.borrow().get(&p.id).unwrap().clone()),
var_ty.repr(self.fcx.tcx()));
var_ty.repr());
}
}
visit::walk_pat(self, p);
@ -642,8 +642,8 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
let ret_ty = fn_sig.output;
debug!("check_fn(arg_tys={}, ret_ty={}, fn_id={})",
arg_tys.repr(tcx),
ret_ty.repr(tcx),
arg_tys.repr(),
ret_ty.repr(),
fn_id);
// Create the function context. This is either derived from scratch or,
@ -671,7 +671,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
debug!("fn-sig-map: fn_id={} fn_sig_tys={}",
fn_id,
fn_sig_tys.repr(tcx));
fn_sig_tys.repr());
inherited.fn_sig_map.borrow_mut().insert(fn_id, fn_sig_tys);
@ -919,11 +919,11 @@ fn check_method_body<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
body: &'tcx ast::Block,
id: ast::NodeId, span: Span) {
debug!("check_method_body(item_generics={}, id={})",
item_generics.repr(ccx.tcx), id);
item_generics.repr(), id);
let param_env = ParameterEnvironment::for_item(ccx.tcx, id);
let fty = ty::node_id_to_type(ccx.tcx, id);
debug!("check_method_body: fty={}", fty.repr(ccx.tcx));
debug!("check_method_body: fty={}", fty.repr());
check_bare_fn(ccx, &sig.decl, body, id, span, fty, param_env);
}
@ -965,7 +965,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
"item `{}` is an associated const, \
which doesn't match its trait `{}`",
token::get_name(impl_const_ty.name()),
impl_trait_ref.repr(tcx))
impl_trait_ref.repr())
}
}
}
@ -978,7 +978,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
"associated const `{}` is not a member of \
trait `{}`",
token::get_name(impl_const_ty.name()),
impl_trait_ref.repr(tcx)));
impl_trait_ref.repr()));
}
}
}
@ -1011,7 +1011,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
"item `{}` is an associated method, \
which doesn't match its trait `{}`",
token::get_name(impl_item_ty.name()),
impl_trait_ref.repr(tcx))
impl_trait_ref.repr())
}
}
}
@ -1022,7 +1022,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
impl_item.span,
&format!("method `{}` is not a member of trait `{}`",
token::get_name(impl_item_ty.name()),
impl_trait_ref.repr(tcx)));
impl_trait_ref.repr()));
}
}
}
@ -1045,7 +1045,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
"item `{}` is an associated type, \
which doesn't match its trait `{}`",
token::get_name(typedef_ty.name()),
impl_trait_ref.repr(tcx))
impl_trait_ref.repr())
}
}
}
@ -1058,7 +1058,7 @@ fn check_impl_items_against_trait<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
"associated type `{}` is not a member of \
trait `{}`",
token::get_name(typedef_ty.name()),
impl_trait_ref.repr(tcx)));
impl_trait_ref.repr()));
}
}
}
@ -1295,18 +1295,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// version, this version will also select obligations if it seems
/// useful, in an effort to get more type information.
fn resolve_type_vars_if_possible(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
debug!("resolve_type_vars_if_possible(ty={})", ty.repr(self.tcx()));
debug!("resolve_type_vars_if_possible(ty={})", ty.repr());
// No ty::infer()? Nothing needs doing.
if !ty::type_has_ty_infer(ty) {
debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
debug!("resolve_type_vars_if_possible: ty={}", ty.repr());
return ty;
}
// If `ty` is a type variable, see whether we already know what it is.
ty = self.infcx().resolve_type_vars_if_possible(&ty);
if !ty::type_has_ty_infer(ty) {
debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
debug!("resolve_type_vars_if_possible: ty={}", ty.repr());
return ty;
}
@ -1314,7 +1314,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.select_new_obligations();
ty = self.infcx().resolve_type_vars_if_possible(&ty);
if !ty::type_has_ty_infer(ty) {
debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
debug!("resolve_type_vars_if_possible: ty={}", ty.repr());
return ty;
}
@ -1325,7 +1325,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.select_obligations_where_possible();
ty = self.infcx().resolve_type_vars_if_possible(&ty);
debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
debug!("resolve_type_vars_if_possible: ty={}", ty.repr());
ty
}
@ -1396,7 +1396,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
#[inline]
pub fn write_ty(&self, node_id: ast::NodeId, ty: Ty<'tcx>) {
debug!("write_ty({}, {}) in fcx {}",
node_id, ty.repr(self.tcx()), self.tag());
node_id, ty.repr(), self.tag());
self.inh.node_types.borrow_mut().insert(node_id, ty);
}
@ -1404,7 +1404,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if !substs.substs.is_noop() {
debug!("write_substs({}, {}) in fcx {}",
node_id,
substs.repr(self.tcx()),
substs.repr(),
self.tag());
self.inh.item_substs.borrow_mut().insert(node_id, substs);
@ -1427,7 +1427,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub fn write_adjustment(&self,
node_id: ast::NodeId,
adj: ty::AutoAdjustment<'tcx>) {
debug!("write_adjustment(node_id={}, adj={})", node_id, adj.repr(self.tcx()));
debug!("write_adjustment(node_id={}, adj={})", node_id, adj.repr());
if adj.is_identity() {
return;
@ -1444,14 +1444,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
substs: &Substs<'tcx>,
value: &T)
-> T
where T : TypeFoldable<'tcx> + Clone + HasProjectionTypes + Repr<'tcx>
where T : TypeFoldable<'tcx> + Clone + HasProjectionTypes + Repr
{
let value = value.subst(self.tcx(), substs);
let result = self.normalize_associated_types_in(span, &value);
debug!("instantiate_type_scheme(value={}, substs={}) = {}",
value.repr(self.tcx()),
substs.repr(self.tcx()),
result.repr(self.tcx()));
value.repr(),
substs.repr(),
result.repr());
result
}
@ -1470,7 +1470,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn normalize_associated_types_in<T>(&self, span: Span, value: &T) -> T
where T : TypeFoldable<'tcx> + Clone + HasProjectionTypes + Repr<'tcx>
where T : TypeFoldable<'tcx> + Clone + HasProjectionTypes + Repr
{
self.inh.normalize_associated_types_in(self, span, self.body_id, value)
}
@ -1616,7 +1616,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
obligation: traits::PredicateObligation<'tcx>)
{
debug!("register_predicate({})",
obligation.repr(self.tcx()));
obligation.repr());
self.inh.fulfillment_cx
.borrow_mut()
.register_predicate_obligation(self.infcx(), obligation);
@ -1634,7 +1634,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
pub fn pat_to_string(&self, pat: &ast::Pat) -> String {
pat.repr(self.tcx())
pat.repr()
}
pub fn expr_ty(&self, ex: &ast::Expr) -> Ty<'tcx> {
@ -1785,7 +1785,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
assert!(!predicates.has_escaping_regions());
debug!("add_obligations_for_parameters(predicates={})",
predicates.repr(self.tcx()));
predicates.repr());
for obligation in traits::predicates_for_generics(self.tcx(),
cause,
@ -1943,8 +1943,8 @@ pub fn autoderef<'a, 'tcx, T, F>(fcx: &FnCtxt<'a, 'tcx>,
where F: FnMut(Ty<'tcx>, usize) -> Option<T>,
{
debug!("autoderef(base_ty={}, opt_expr={}, lvalue_pref={:?})",
base_ty.repr(fcx.tcx()),
opt_expr.repr(fcx.tcx()),
base_ty.repr(),
opt_expr.repr(),
lvalue_pref);
let mut t = base_ty;
@ -2005,7 +2005,7 @@ pub fn autoderef<'a, 'tcx, T, F>(fcx: &FnCtxt<'a, 'tcx>,
// We've reached the recursion limit, error gracefully.
span_err!(fcx.tcx().sess, sp, E0055,
"reached the recursion limit while auto-dereferencing {}",
base_ty.repr(fcx.tcx()));
base_ty.repr());
(fcx.tcx().types.err, 0, None)
}
@ -2122,12 +2122,12 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
let tcx = fcx.tcx();
debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, \
autoderefs={}, unsize={}, index_ty={})",
expr.repr(tcx),
base_expr.repr(tcx),
adjusted_ty.repr(tcx),
expr.repr(),
base_expr.repr(),
adjusted_ty.repr(),
autoderefs,
unsize,
index_ty.repr(tcx));
index_ty.repr());
let input_ty = fcx.infcx().next_ty_var();
@ -2607,8 +2607,8 @@ fn expected_types_for_fn_args<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
}
}).unwrap_or(vec![]);
debug!("expected_types_for_fn_args(formal={} -> {}, expected={} -> {})",
formal_args.repr(fcx.tcx()), formal_ret.repr(fcx.tcx()),
expected_args.repr(fcx.tcx()), expected_ret.repr(fcx.tcx()));
formal_args.repr(), formal_ret.repr(),
expected_args.repr(), expected_ret.repr());
expected_args
}
@ -2630,7 +2630,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
F: FnOnce(),
{
debug!(">> typechecking: expr={} expected={}",
expr.repr(fcx.tcx()), expected.repr(fcx.tcx()));
expr.repr(), expected.repr());
// Checks a method call.
fn check_method_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
@ -2746,7 +2746,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
|base_t, _| {
match base_t.sty {
ty::TyStruct(base_id, substs) => {
debug!("struct named {}", base_t.repr(tcx));
debug!("struct named {}", base_t.repr());
let fields = ty::lookup_struct_fields(tcx, base_id);
fcx.lookup_field_ty(expr.span, base_id, &fields[..],
field.node.name, &(*substs))
@ -2850,7 +2850,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
ty::TyStruct(base_id, substs) => {
tuple_like = ty::is_tuple_struct(tcx, base_id);
if tuple_like {
debug!("tuple struct named {}", base_t.repr(tcx));
debug!("tuple struct named {}", base_t.repr());
let fields = ty::lookup_struct_fields(tcx, base_id);
fcx.lookup_tup_field_ty(expr.span, base_id, &fields[..],
idx.node, &(*substs))
@ -3276,7 +3276,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
}
} else {
tcx.sess.span_bug(expr.span,
&format!("unbound path {}", expr.repr(tcx)))
&format!("unbound path {}", expr.repr()))
};
if let Some((opt_ty, segments, def)) =
@ -3749,8 +3749,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
debug!("type of expr({}) {} is...", expr.id,
syntax::print::pprust::expr_to_string(expr));
debug!("... {}, expected is {}",
fcx.expr_ty(expr).repr(tcx),
expected.repr(tcx));
fcx.expr_ty(expr).repr(),
expected.repr());
unifier();
}
@ -3909,16 +3909,16 @@ impl<'tcx> Expectation<'tcx> {
}
}
impl<'tcx> Repr<'tcx> for Expectation<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
impl<'tcx> Repr for Expectation<'tcx> {
fn repr(&self) -> String {
match *self {
NoExpectation => format!("NoExpectation"),
ExpectHasType(t) => format!("ExpectHasType({})",
t.repr(tcx)),
t.repr()),
ExpectCastableToType(t) => format!("ExpectCastableToType({})",
t.repr(tcx)),
t.repr()),
ExpectRvalueLikeUnsized(t) => format!("ExpectRvalueLikeUnsized({})",
t.repr(tcx)),
t.repr()),
}
}
}
@ -4198,7 +4198,7 @@ pub fn check_instantiable(tcx: &ty::ctxt,
"this type cannot be instantiated without an \
instance of itself");
fileline_help!(tcx.sess, sp, "consider using `Option<{}>`",
item_ty.repr(tcx));
item_ty.repr());
false
} else {
true
@ -4391,9 +4391,9 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
node_id: ast::NodeId) {
debug!("instantiate_path(path={:?}, def={}, node_id={}, type_scheme={})",
segments,
def.repr(fcx.tcx()),
def.repr(),
node_id,
type_scheme.repr(fcx.tcx()));
type_scheme.repr());
// We need to extract the type parameters supplied by the user in
// the path `path`. Due to the current setup, this is a bit of a
@ -4634,8 +4634,8 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
fcx.tcx().sess.span_bug(span,
&format!(
"instantiate_path: (UFCS) {} was a subtype of {} but now is not?",
self_ty.repr(fcx.tcx()),
impl_ty.repr(fcx.tcx())));
self_ty.repr(),
impl_ty.repr()));
}
}
@ -4840,7 +4840,7 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
}
assert_eq!(substs.types.len(space), desired.len());
debug!("Final substs: {}", substs.repr(fcx.tcx()));
debug!("Final substs: {}", substs.repr());
}
fn adjust_region_parameters(
@ -4950,7 +4950,7 @@ pub fn check_bounds_are_used<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
tps: &OwnedSlice<ast::TyParam>,
ty: Ty<'tcx>) {
debug!("check_bounds_are_used(n_tps={}, ty={})",
tps.len(), ty.repr(ccx.tcx));
tps.len(), ty.repr());
// make a vector of booleans initially false, set to true when used
if tps.is_empty() { return; }
@ -5273,7 +5273,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
fty,
|| {
format!("intrinsic has wrong type: expected `{}`",
fty.user_string(ccx.tcx))
fty.user_string())
});
}
}

28
src/librustc_typeck/check/op.rs
View file

@ -51,8 +51,8 @@ pub fn check_binop_assign<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
span_err!(tcx.sess, lhs_expr.span, E0368,
"binary assignment operation `{}=` cannot be applied to types `{}` and `{}`",
ast_util::binop_to_string(op.node),
lhs_ty.user_string(fcx.tcx()),
rhs_ty.user_string(fcx.tcx()));
lhs_ty.user_string(),
rhs_ty.user_string());
fcx.write_error(expr.id);
}
@ -75,10 +75,10 @@ pub fn check_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
debug!("check_binop(expr.id={}, expr={}, op={:?}, lhs_expr={}, rhs_expr={})",
expr.id,
expr.repr(tcx),
expr.repr(),
op,
lhs_expr.repr(tcx),
rhs_expr.repr(tcx));
lhs_expr.repr(),
rhs_expr.repr());
check_expr(fcx, lhs_expr);
let lhs_ty = fcx.resolve_type_vars_if_possible(fcx.expr_ty(lhs_expr));
@ -181,15 +181,15 @@ fn enforce_builtin_binop_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
if ty::type_is_simd(tcx, lhs_ty) {
let unit_ty = ty::simd_type(tcx, lhs_ty);
debug!("enforce_builtin_binop_types: lhs_ty={} unit_ty={}",
lhs_ty.repr(tcx),
unit_ty.repr(tcx));
lhs_ty.repr(),
unit_ty.repr());
if !ty::type_is_integral(unit_ty) {
tcx.sess.span_err(
lhs_expr.span,
&format!("binary comparison operation `{}` not supported \
for floating point SIMD vector `{}`",
ast_util::binop_to_string(op.node),
lhs_ty.user_string(tcx)));
lhs_ty.user_string()));
tcx.types.err
} else {
lhs_ty
@ -211,7 +211,7 @@ fn check_overloaded_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
{
debug!("check_overloaded_binop(expr.id={}, lhs_ty={})",
expr.id,
lhs_ty.repr(fcx.tcx()));
lhs_ty.repr());
let (name, trait_def_id) = name_and_trait_def_id(fcx, op);
@ -233,7 +233,7 @@ fn check_overloaded_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
span_err!(fcx.tcx().sess, lhs_expr.span, E0369,
"binary operation `{}` cannot be applied to type `{}`",
ast_util::binop_to_string(op.node),
lhs_ty.user_string(fcx.tcx()));
lhs_ty.user_string());
}
fcx.tcx().types.err
}
@ -305,11 +305,11 @@ fn lookup_op_method<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
-> Result<Ty<'tcx>,()>
{
debug!("lookup_op_method(expr={}, lhs_ty={}, opname={:?}, trait_did={}, lhs_expr={})",
expr.repr(fcx.tcx()),
lhs_ty.repr(fcx.tcx()),
expr.repr(),
lhs_ty.repr(),
opname,
trait_did.repr(fcx.tcx()),
lhs_expr.repr(fcx.tcx()));
trait_did.repr(),
lhs_expr.repr());
let method = match trait_did {
Some(trait_did) => {

108
src/librustc_typeck/check/regionck.rs
View file

@ -322,7 +322,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> {
for r_o in &region_obligations {
debug!("visit_region_obligations: r_o={}",
r_o.repr(self.tcx()));
r_o.repr());
let sup_type = self.resolve_type(r_o.sup_type);
let origin = infer::RelateParamBound(r_o.cause.span, sup_type);
type_must_outlive(self, origin, sup_type, r_o.sub_region);
@ -352,7 +352,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> {
for &ty in fn_sig_tys {
let ty = self.resolve_type(ty);
debug!("relate_free_regions(t={})", ty.repr(tcx));
debug!("relate_free_regions(t={})", ty.repr());
let body_scope = CodeExtent::from_node_id(body_id);
let body_scope = ty::ReScope(body_scope);
let implications = implicator::implications(self.fcx.infcx(), self.fcx, body_id,
@ -365,7 +365,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> {
// that don't go into the free-region-map but which we use
// here.
for implication in implications {
debug!("implication: {}", implication.repr(tcx));
debug!("implication: {}", implication.repr());
match implication {
implicator::Implication::RegionSubRegion(_,
ty::ReFree(free_a),
@ -374,7 +374,7 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> {
}
implicator::Implication::RegionSubGeneric(_, r_a, ref generic_b) => {
debug!("RegionSubGeneric: {} <= {}",
r_a.repr(tcx), generic_b.repr(tcx));
r_a.repr(), generic_b.repr());
self.region_bound_pairs.push((r_a, generic_b.clone()));
}
@ -465,7 +465,7 @@ fn visit_local(rcx: &mut Rcx, l: &ast::Local) {
fn constrain_bindings_in_pat(pat: &ast::Pat, rcx: &mut Rcx) {
let tcx = rcx.fcx.tcx();
debug!("regionck::visit_pat(pat={})", pat.repr(tcx));
debug!("regionck::visit_pat(pat={})", pat.repr());
pat_util::pat_bindings(&tcx.def_map, pat, |_, id, span, _| {
// If we have a variable that contains region'd data, that
// data will be accessible from anywhere that the variable is
@ -503,7 +503,7 @@ fn constrain_bindings_in_pat(pat: &ast::Pat, rcx: &mut Rcx) {
fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
debug!("regionck::visit_expr(e={}, repeating_scope={})",
expr.repr(rcx.fcx.tcx()), rcx.repeating_scope);
expr.repr(), rcx.repeating_scope);
// No matter what, the type of each expression must outlive the
// scope of that expression. This also guarantees basic WF.
@ -746,8 +746,8 @@ fn constrain_cast(rcx: &mut Rcx,
source_expr: &ast::Expr)
{
debug!("constrain_cast(cast_expr={}, source_expr={})",
cast_expr.repr(rcx.tcx()),
source_expr.repr(rcx.tcx()));
cast_expr.repr(),
source_expr.repr());
let source_ty = rcx.resolve_node_type(source_expr.id);
let target_ty = rcx.resolve_node_type(cast_expr.id);
@ -759,8 +759,8 @@ fn constrain_cast(rcx: &mut Rcx,
from_ty: Ty<'tcx>,
to_ty: Ty<'tcx>) {
debug!("walk_cast(from_ty={}, to_ty={})",
from_ty.repr(rcx.tcx()),
to_ty.repr(rcx.tcx()));
from_ty.repr(),
to_ty.repr());
match (&from_ty.sty, &to_ty.sty) {
/*From:*/ (&ty::TyRef(from_r, ref from_mt),
/*To: */ &ty::TyRef(to_r, ref to_mt)) => {
@ -808,7 +808,7 @@ fn constrain_callee(rcx: &mut Rcx,
//
// tcx.sess.span_bug(
// callee_expr.span,
// format!("Calling non-function: {}", callee_ty.repr(tcx)));
// format!("Calling non-function: {}", callee_ty.repr()));
}
}
}
@ -827,8 +827,8 @@ fn constrain_call<'a, I: Iterator<Item=&'a ast::Expr>>(rcx: &mut Rcx,
debug!("constrain_call(call_expr={}, \
receiver={}, \
implicitly_ref_args={})",
call_expr.repr(tcx),
receiver.repr(tcx),
call_expr.repr(),
receiver.repr(),
implicitly_ref_args);
// `callee_region` is the scope representing the time in which the
@ -838,10 +838,10 @@ fn constrain_call<'a, I: Iterator<Item=&'a ast::Expr>>(rcx: &mut Rcx,
let callee_scope = CodeExtent::from_node_id(call_expr.id);
let callee_region = ty::ReScope(callee_scope);
debug!("callee_region={}", callee_region.repr(tcx));
debug!("callee_region={}", callee_region.repr());
for arg_expr in arg_exprs {
debug!("Argument: {}", arg_expr.repr(tcx));
debug!("Argument: {}", arg_expr.repr());
// ensure that any regions appearing in the argument type are
// valid for at least the lifetime of the function:
@ -860,7 +860,7 @@ fn constrain_call<'a, I: Iterator<Item=&'a ast::Expr>>(rcx: &mut Rcx,
// as loop above, but for receiver
if let Some(r) = receiver {
debug!("receiver: {}", r.repr(tcx));
debug!("receiver: {}", r.repr());
type_of_node_must_outlive(
rcx, infer::CallRcvr(r.span),
r.id, callee_region);
@ -878,9 +878,9 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
mut derefd_ty: Ty<'tcx>)
{
debug!("constrain_autoderefs(deref_expr={}, derefs={}, derefd_ty={})",
deref_expr.repr(rcx.tcx()),
deref_expr.repr(),
derefs,
derefd_ty.repr(rcx.tcx()));
derefd_ty.repr());
let r_deref_expr = ty::ReScope(CodeExtent::from_node_id(deref_expr.id));
for i in 0..derefs {
@ -890,7 +890,7 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
derefd_ty = match rcx.fcx.inh.method_map.borrow().get(&method_call) {
Some(method) => {
debug!("constrain_autoderefs: #{} is overloaded, method={}",
i, method.repr(rcx.tcx()));
i, method.repr());
// Treat overloaded autoderefs as if an AutoRef adjustment
// was applied on the base type, as that is always the case.
@ -904,18 +904,18 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
rcx.tcx().sess.span_bug(
deref_expr.span,
&format!("bad overloaded deref type {}",
method.ty.repr(rcx.tcx())))
method.ty.repr()))
}
};
debug!("constrain_autoderefs: receiver r={:?} m={:?}",
r.repr(rcx.tcx()), m);
r.repr(), m);
{
let mc = mc::MemCategorizationContext::new(rcx.fcx);
let self_cmt = ignore_err!(mc.cat_expr_autoderefd(deref_expr, i));
debug!("constrain_autoderefs: self_cmt={:?}",
self_cmt.repr(rcx.tcx()));
self_cmt.repr());
link_region(rcx, deref_expr.span, r,
ty::BorrowKind::from_mutbl(m), self_cmt);
}
@ -977,7 +977,7 @@ fn check_safety_of_rvalue_destructor_if_necessary<'a, 'tcx>(rcx: &mut Rcx<'a, 't
.span_bug(span,
&format!("unexpected rvalue region in rvalue \
destructor safety checking: `{}`",
region.repr(rcx.tcx())));
region.repr()));
}
}
}
@ -1025,7 +1025,7 @@ fn type_of_node_must_outlive<'a, 'tcx>(
|method_call| rcx.resolve_method_type(method_call));
debug!("constrain_regions_in_type_of_node(\
ty={}, ty0={}, id={}, minimum_lifetime={:?})",
ty.user_string(tcx), ty0.user_string(tcx),
ty.user_string(), ty0.user_string(),
id, minimum_lifetime);
type_must_outlive(rcx, origin, ty, minimum_lifetime);
}
@ -1034,14 +1034,14 @@ fn type_of_node_must_outlive<'a, 'tcx>(
/// resulting pointer is linked to the lifetime of its guarantor (if any).
fn link_addr_of(rcx: &mut Rcx, expr: &ast::Expr,
mutability: ast::Mutability, base: &ast::Expr) {
debug!("link_addr_of(expr={}, base={})", expr.repr(rcx.tcx()), base.repr(rcx.tcx()));
debug!("link_addr_of(expr={}, base={})", expr.repr(), base.repr());
let cmt = {
let mc = mc::MemCategorizationContext::new(rcx.fcx);
ignore_err!(mc.cat_expr(base))
};
debug!("link_addr_of: cmt={}", cmt.repr(rcx.tcx()));
debug!("link_addr_of: cmt={}", cmt.repr());
link_region_from_node_type(rcx, expr.span, expr.id, mutability, cmt);
}
@ -1067,7 +1067,7 @@ fn link_match(rcx: &Rcx, discr: &ast::Expr, arms: &[ast::Arm]) {
debug!("regionck::for_match()");
let mc = mc::MemCategorizationContext::new(rcx.fcx);
let discr_cmt = ignore_err!(mc.cat_expr(discr));
debug!("discr_cmt={}", discr_cmt.repr(rcx.tcx()));
debug!("discr_cmt={}", discr_cmt.repr());
for arm in arms {
for root_pat in &arm.pats {
link_pattern(rcx, mc, discr_cmt.clone(), &**root_pat);
@ -1086,8 +1086,8 @@ fn link_fn_args(rcx: &Rcx, body_scope: CodeExtent, args: &[ast::Arg]) {
let re_scope = ty::ReScope(body_scope);
let arg_cmt = mc.cat_rvalue(arg.id, arg.ty.span, re_scope, arg_ty);
debug!("arg_ty={} arg_cmt={}",
arg_ty.repr(rcx.tcx()),
arg_cmt.repr(rcx.tcx()));
arg_ty.repr(),
arg_cmt.repr());
link_pattern(rcx, mc, arg_cmt, &*arg.pat);
}
}
@ -1099,8 +1099,8 @@ fn link_pattern<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
discr_cmt: mc::cmt<'tcx>,
root_pat: &ast::Pat) {
debug!("link_pattern(discr_cmt={}, root_pat={})",
discr_cmt.repr(rcx.tcx()),
root_pat.repr(rcx.tcx()));
discr_cmt.repr(),
root_pat.repr());
let _ = mc.cat_pattern(discr_cmt, root_pat, |mc, sub_cmt, sub_pat| {
match sub_pat.node {
// `ref x` pattern
@ -1136,7 +1136,7 @@ fn link_autoref(rcx: &Rcx,
debug!("link_autoref(autoref={:?})", autoref);
let mc = mc::MemCategorizationContext::new(rcx.fcx);
let expr_cmt = ignore_err!(mc.cat_expr_autoderefd(expr, autoderefs));
debug!("expr_cmt={}", expr_cmt.repr(rcx.tcx()));
debug!("expr_cmt={}", expr_cmt.repr());
match *autoref {
ty::AutoPtr(r, m) => {
@ -1158,7 +1158,7 @@ fn link_by_ref(rcx: &Rcx,
callee_scope: CodeExtent) {
let tcx = rcx.tcx();
debug!("link_by_ref(expr={}, callee_scope={:?})",
expr.repr(tcx), callee_scope);
expr.repr(), callee_scope);
let mc = mc::MemCategorizationContext::new(rcx.fcx);
let expr_cmt = ignore_err!(mc.cat_expr(expr));
let borrow_region = ty::ReScope(callee_scope);
@ -1173,12 +1173,12 @@ fn link_region_from_node_type<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
mutbl: ast::Mutability,
cmt_borrowed: mc::cmt<'tcx>) {
debug!("link_region_from_node_type(id={:?}, mutbl={:?}, cmt_borrowed={})",
id, mutbl, cmt_borrowed.repr(rcx.tcx()));
id, mutbl, cmt_borrowed.repr());
let rptr_ty = rcx.resolve_node_type(id);
if !ty::type_is_error(rptr_ty) {
let tcx = rcx.fcx.ccx.tcx;
debug!("rptr_ty={}", rptr_ty.user_string(tcx));
debug!("rptr_ty={}", rptr_ty.user_string());
let r = ty::ty_region(tcx, span, rptr_ty);
link_region(rcx, span, &r, ty::BorrowKind::from_mutbl(mutbl),
cmt_borrowed);
@ -1198,9 +1198,9 @@ fn link_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
loop {
debug!("link_region(borrow_region={}, borrow_kind={}, borrow_cmt={})",
borrow_region.repr(rcx.tcx()),
borrow_kind.repr(rcx.tcx()),
borrow_cmt.repr(rcx.tcx()));
borrow_region.repr(),
borrow_kind.repr(),
borrow_cmt.repr());
match borrow_cmt.cat.clone() {
mc::cat_deref(ref_cmt, _,
mc::Implicit(ref_kind, ref_region)) |
@ -1311,7 +1311,7 @@ fn link_reborrowed_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
rcx.tcx().sess.span_bug(
span,
&format!("Illegal upvar id: {}",
upvar_id.repr(rcx.tcx())));
upvar_id.repr()));
}
}
}
@ -1327,8 +1327,8 @@ fn link_reborrowed_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
};
debug!("link_reborrowed_region: {} <= {}",
borrow_region.repr(rcx.tcx()),
ref_region.repr(rcx.tcx()));
borrow_region.repr(),
ref_region.repr());
rcx.fcx.mk_subr(cause, *borrow_region, ref_region);
// If we end up needing to recurse and establish a region link
@ -1402,13 +1402,13 @@ pub fn type_must_outlive<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
region: ty::Region)
{
debug!("type_must_outlive(ty={}, region={})",
ty.repr(rcx.tcx()),
region.repr(rcx.tcx()));
ty.repr(),
region.repr());
let implications = implicator::implications(rcx.fcx.infcx(), rcx.fcx, rcx.body_id,
ty, region, origin.span());
for implication in implications {
debug!("implication: {}", implication.repr(rcx.tcx()));
debug!("implication: {}", implication.repr());
match implication {
implicator::Implication::RegionSubRegion(None, r_a, r_b) => {
rcx.fcx.mk_subr(origin.clone(), r_a, r_b);
@ -1444,7 +1444,7 @@ fn closure_must_outlive<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
def_id: ast::DefId,
substs: &'tcx Substs<'tcx>) {
debug!("closure_must_outlive(region={}, def_id={}, substs={})",
region.repr(rcx.tcx()), def_id.repr(rcx.tcx()), substs.repr(rcx.tcx()));
region.repr(), def_id.repr(), substs.repr());
let upvars = rcx.fcx.closure_upvars(def_id, substs).unwrap();
for upvar in upvars {
@ -1462,8 +1462,8 @@ fn generic_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
let param_env = &rcx.fcx.inh.param_env;
debug!("param_must_outlive(region={}, generic={})",
region.repr(rcx.tcx()),
generic.repr(rcx.tcx()));
region.repr(),
generic.repr());
// To start, collect bounds from user:
let mut param_bounds =
@ -1497,8 +1497,8 @@ fn generic_must_outlive<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
// don't know that this holds from first principles.
for &(ref r, ref p) in &rcx.region_bound_pairs {
debug!("generic={} p={}",
generic.repr(rcx.tcx()),
p.repr(rcx.tcx()));
generic.repr(),
p.repr());
if generic == p {
param_bounds.push(*r);
}
@ -1522,7 +1522,7 @@ fn projection_bounds<'a,'tcx>(rcx: &Rcx<'a, 'tcx>,
let infcx = fcx.infcx();
debug!("projection_bounds(projection_ty={})",
projection_ty.repr(tcx));
projection_ty.repr());
let ty = ty::mk_projection(tcx, projection_ty.trait_ref.clone(), projection_ty.item_name);
@ -1547,7 +1547,7 @@ fn projection_bounds<'a,'tcx>(rcx: &Rcx<'a, 'tcx>,
};
debug!("projection_bounds: outlives={} (1)",
outlives.repr(tcx));
outlives.repr());
// apply the substitutions (and normalize any projected types)
let outlives = fcx.instantiate_type_scheme(span,
@ -1555,7 +1555,7 @@ fn projection_bounds<'a,'tcx>(rcx: &Rcx<'a, 'tcx>,
&outlives);
debug!("projection_bounds: outlives={} (2)",
outlives.repr(tcx));
outlives.repr());
let region_result = infcx.commit_if_ok(|_| {
let (outlives, _) =
@ -1565,7 +1565,7 @@ fn projection_bounds<'a,'tcx>(rcx: &Rcx<'a, 'tcx>,
&outlives);
debug!("projection_bounds: outlives={} (3)",
outlives.repr(tcx));
outlives.repr());
// check whether this predicate applies to our current projection
match infer::mk_eqty(infcx, false, infer::Misc(span), ty, outlives.0) {
@ -1575,7 +1575,7 @@ fn projection_bounds<'a,'tcx>(rcx: &Rcx<'a, 'tcx>,
});
debug!("projection_bounds: region_result={}",
region_result.repr(tcx));
region_result.repr());
region_result.ok()
})

18
src/librustc_typeck/check/upvar.rs
View file

@ -134,7 +134,7 @@ impl<'a,'tcx> SeedBorrowKind<'a,'tcx> {
self.closures_with_inferred_kinds.insert(expr.id);
self.fcx.inh.closure_kinds.borrow_mut().insert(closure_def_id, ty::FnClosureKind);
debug!("check_closure: adding closure_id={} to closures_with_inferred_kinds",
closure_def_id.repr(self.tcx()));
closure_def_id.repr());
}
ty::with_freevars(self.tcx(), expr.id, |freevars| {
@ -246,7 +246,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> {
mode: euv::ConsumeMode)
{
debug!("adjust_upvar_borrow_kind_for_consume(cmt={}, mode={:?})",
cmt.repr(self.tcx()), mode);
cmt.repr(), mode);
// we only care about moves
match mode {
@ -259,7 +259,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> {
// by value instead
let guarantor = cmt.guarantor();
debug!("adjust_upvar_borrow_kind_for_consume: guarantor={}",
guarantor.repr(self.tcx()));
guarantor.repr());
match guarantor.cat {
mc::cat_deref(_, _, mc::BorrowedPtr(..)) |
mc::cat_deref(_, _, mc::Implicit(..)) => {
@ -297,7 +297,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> {
/// those upvars must be borrowed using an `&mut` borrow.
fn adjust_upvar_borrow_kind_for_mut(&mut self, cmt: mc::cmt<'tcx>) {
debug!("adjust_upvar_borrow_kind_for_mut(cmt={})",
cmt.repr(self.tcx()));
cmt.repr());
match cmt.cat.clone() {
mc::cat_deref(base, _, mc::Unique) |
@ -331,7 +331,7 @@ impl<'a,'tcx> AdjustBorrowKind<'a,'tcx> {
fn adjust_upvar_borrow_kind_for_unique(&self, cmt: mc::cmt<'tcx>) {
debug!("adjust_upvar_borrow_kind_for_unique(cmt={})",
cmt.repr(self.tcx()));
cmt.repr());
match cmt.cat.clone() {
mc::cat_deref(base, _, mc::Unique) |
@ -498,7 +498,7 @@ impl<'a,'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a,'tcx> {
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode)
{
debug!("consume(cmt={},mode={:?})", cmt.repr(self.tcx()), mode);
debug!("consume(cmt={},mode={:?})", cmt.repr(), mode);
self.adjust_upvar_borrow_kind_for_consume(cmt, mode);
}
@ -513,7 +513,7 @@ impl<'a,'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a,'tcx> {
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode)
{
debug!("consume_pat(cmt={},mode={:?})", cmt.repr(self.tcx()), mode);
debug!("consume_pat(cmt={},mode={:?})", cmt.repr(), mode);
self.adjust_upvar_borrow_kind_for_consume(cmt, mode);
}
@ -526,7 +526,7 @@ impl<'a,'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a,'tcx> {
_loan_cause: euv::LoanCause)
{
debug!("borrow(borrow_id={}, cmt={}, bk={:?})",
borrow_id, cmt.repr(self.tcx()), bk);
borrow_id, cmt.repr(), bk);
match bk {
ty::ImmBorrow => { }
@ -551,7 +551,7 @@ impl<'a,'tcx> euv::Delegate<'tcx> for AdjustBorrowKind<'a,'tcx> {
_mode: euv::MutateMode)
{
debug!("mutate(assignee_cmt={})",
assignee_cmt.repr(self.tcx()));
assignee_cmt.repr());
self.adjust_upvar_borrow_kind_for_mut(assignee_cmt);
}

12
src/librustc_typeck/check/wf.rs
View file

@ -350,7 +350,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
param_name: ast::Name)
{
span_err!(self.tcx().sess, span, E0392,
"parameter `{}` is never used", param_name.user_string(self.tcx()));
"parameter `{}` is never used", param_name.user_string());
let suggested_marker_id = self.tcx().lang_items.phantom_data();
match suggested_marker_id {
@ -358,7 +358,7 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
self.tcx().sess.fileline_help(
span,
&format!("consider removing `{}` or using a marker such as `{}`",
param_name.user_string(self.tcx()),
param_name.user_string(),
ty::item_path_str(self.tcx(), def_id)));
}
None => {
@ -395,7 +395,7 @@ fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>,
"cannot bound type `{}`, where clause \
bounds may only be attached to types involving \
type parameters",
bounded_ty.repr(tcx))
bounded_ty.repr())
}
fn is_ty_param(ty: ty::Ty) -> bool {
@ -536,7 +536,7 @@ impl<'cx,'tcx> TypeFolder<'tcx> for BoundsChecker<'cx,'tcx> {
}
fn fold_binder<T>(&mut self, binder: &ty::Binder<T>) -> ty::Binder<T>
where T : TypeFoldable<'tcx> + Repr<'tcx>
where T : TypeFoldable<'tcx> + Repr
{
self.binding_count += 1;
let value = liberate_late_bound_regions(
@ -544,7 +544,7 @@ impl<'cx,'tcx> TypeFolder<'tcx> for BoundsChecker<'cx,'tcx> {
region::DestructionScopeData::new(self.scope),
binder);
debug!("BoundsChecker::fold_binder: late-bound regions replaced: {} at scope: {:?}",
value.repr(self.tcx()), self.scope);
value.repr(), self.scope);
let value = value.fold_with(self);
self.binding_count -= 1;
ty::Binder(value)
@ -552,7 +552,7 @@ impl<'cx,'tcx> TypeFolder<'tcx> for BoundsChecker<'cx,'tcx> {
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
debug!("BoundsChecker t={}",
t.repr(self.tcx()));
t.repr());
match self.cache {
Some(ref mut cache) => {

12
src/librustc_typeck/check/writeback.rs
View file

@ -172,7 +172,7 @@ impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx> {
debug!("Type for pattern binding {} (id {}) resolved to {}",
pat_to_string(p),
p.id,
ty::node_id_to_type(self.tcx(), p.id).repr(self.tcx()));
ty::node_id_to_type(self.tcx(), p.id).repr());
visit::walk_pat(self, p);
}
@ -216,8 +216,8 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
}
};
debug!("Upvar capture for {} resolved to {}",
upvar_id.repr(self.tcx()),
new_upvar_capture.repr(self.tcx()));
upvar_id.repr(),
new_upvar_capture.repr());
self.fcx.tcx().upvar_capture_map.borrow_mut().insert(*upvar_id, new_upvar_capture);
}
}
@ -245,7 +245,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
let n_ty = self.fcx.node_ty(id);
let n_ty = self.resolve(&n_ty, reason);
write_ty_to_tcx(self.tcx(), id, n_ty);
debug!("Node {} has type {}", id, n_ty.repr(self.tcx()));
debug!("Node {} has type {}", id, n_ty.repr());
// Resolve any substitutions
self.fcx.opt_node_ty_substs(id, |item_substs| {
@ -296,7 +296,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
Some(method) => {
debug!("writeback::resolve_method_map_entry(call={:?}, entry={})",
method_call,
method.repr(self.tcx()));
method.repr());
let new_method = MethodCallee {
origin: self.resolve(&method.origin, reason),
ty: self.resolve(&method.ty, reason),
@ -428,7 +428,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Resolver<'cx, 'tcx> {
Ok(t) => t,
Err(e) => {
debug!("Resolver::fold_ty: input type `{}` not fully resolvable",
t.repr(self.tcx));
t.repr());
self.report_error(e);
self.tcx().types.err
}

34
src/librustc_typeck/coherence/mod.rs
View file

@ -82,7 +82,7 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>,
inference_context.tcx.sess.span_bug(
span,
&format!("coherence encountered unexpected type searching for base type: {}",
ty.repr(inference_context.tcx)));
ty.repr()));
}
}
}
@ -150,7 +150,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
if let Some(trait_ref) = ty::impl_trait_ref(self.crate_context.tcx,
impl_did) {
debug!("(checking implementation) adding impl for trait '{}', item '{}'",
trait_ref.repr(self.crate_context.tcx),
trait_ref.repr(),
token::get_ident(item.ident));
enforce_trait_manually_implementable(self.crate_context.tcx,
@ -180,7 +180,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
all_impl_items: &mut Vec<ImplOrTraitItemId>) {
let tcx = self.crate_context.tcx;
debug!("instantiate_default_methods(impl_id={:?}, trait_ref={})",
impl_id, trait_ref.repr(tcx));
impl_id, trait_ref.repr());
let impl_type_scheme = ty::lookup_item_type(tcx, impl_id);
@ -190,7 +190,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
let new_id = tcx.sess.next_node_id();
let new_did = local_def(new_id);
debug!("new_did={:?} trait_method={}", new_did, trait_method.repr(tcx));
debug!("new_did={:?} trait_method={}", new_did, trait_method.repr());
// Create substitutions for the various trait parameters.
let new_method_ty =
@ -203,7 +203,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
&**trait_method,
Some(trait_method.def_id)));
debug!("new_method_ty={}", new_method_ty.repr(tcx));
debug!("new_method_ty={}", new_method_ty.repr());
all_impl_items.push(MethodTraitItemId(new_did));
// construct the polytype for the method based on the
@ -214,7 +214,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
ty: ty::mk_bare_fn(tcx, Some(new_did),
tcx.mk_bare_fn(new_method_ty.fty.clone()))
};
debug!("new_polytype={}", new_polytype.repr(tcx));
debug!("new_polytype={}", new_polytype.repr());
tcx.tcache.borrow_mut().insert(new_did, new_polytype);
tcx.predicates.borrow_mut().insert(new_did, new_method_ty.predicates.clone());
@ -361,7 +361,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
copy_trait.for_each_impl(tcx, |impl_did| {
debug!("check_implementations_of_copy: impl_did={}",
impl_did.repr(tcx));
impl_did.repr());
if impl_did.krate != ast::LOCAL_CRATE {
debug!("check_implementations_of_copy(): impl not in this \
@ -371,7 +371,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
let self_type = ty::lookup_item_type(tcx, impl_did);
debug!("check_implementations_of_copy: self_type={} (bound)",
self_type.repr(tcx));
self_type.repr());
let span = tcx.map.span(impl_did.node);
let param_env = ParameterEnvironment::for_item(tcx, impl_did.node);
@ -379,7 +379,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
assert!(!self_type.has_escaping_regions());
debug!("check_implementations_of_copy: self_type={} (free)",
self_type.repr(tcx));
self_type.repr());
match ty::can_type_implement_copy(&param_env, span, self_type) {
Ok(()) => {}
@ -430,7 +430,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
trait_def.for_each_impl(tcx, |impl_did| {
debug!("check_implementations_of_coerce_unsized: impl_did={}",
impl_did.repr(tcx));
impl_did.repr());
if impl_did.krate != ast::LOCAL_CRATE {
debug!("check_implementations_of_coerce_unsized(): impl not \
@ -443,7 +443,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
impl_did).unwrap();
let target = *trait_ref.substs.types.get(subst::TypeSpace, 0);
debug!("check_implementations_of_coerce_unsized: {} -> {} (bound)",
source.repr(tcx), target.repr(tcx));
source.repr(), target.repr());
let span = tcx.map.span(impl_did.node);
let param_env = ParameterEnvironment::for_item(tcx, impl_did.node);
@ -452,7 +452,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
assert!(!source.has_escaping_regions());
debug!("check_implementations_of_coerce_unsized: {} -> {} (free)",
source.repr(tcx), target.repr(tcx));
source.repr(), target.repr());
let infcx = new_infer_ctxt(tcx);
@ -520,8 +520,8 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
} else {
token::get_name(name).to_string()
},
a.repr(tcx),
b.repr(tcx))
a.repr(),
b.repr())
}).collect::<Vec<_>>().connect(", "));
return;
}
@ -598,7 +598,7 @@ fn subst_receiver_types_in_method_ty<'tcx>(tcx: &ty::ctxt<'tcx>,
let combined_substs = ty::make_substs_for_receiver_types(tcx, trait_ref, method);
debug!("subst_receiver_types_in_method_ty: combined_substs={}",
combined_substs.repr(tcx));
combined_substs.repr());
let method_predicates = method.predicates.subst(tcx, &combined_substs);
let mut method_generics = method.generics.subst(tcx, &combined_substs);
@ -615,12 +615,12 @@ fn subst_receiver_types_in_method_ty<'tcx>(tcx: &ty::ctxt<'tcx>,
}
debug!("subst_receiver_types_in_method_ty: method_generics={}",
method_generics.repr(tcx));
method_generics.repr());
let method_fty = method.fty.subst(tcx, &combined_substs);
debug!("subst_receiver_types_in_method_ty: method_ty={}",
method.fty.repr(tcx));
method.fty.repr());
ty::Method::new(
method.name,

14
src/librustc_typeck/coherence/orphan.rs
View file

@ -66,7 +66,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
ast::ItemImpl(_, _, _, None, _, _) => {
// For inherent impls, self type must be a nominal type
// defined in this crate.
debug!("coherence2::orphan check: inherent impl {}", item.repr(self.tcx));
debug!("coherence2::orphan check: inherent impl {}", item.repr());
let self_ty = ty::lookup_item_type(self.tcx, def_id).ty;
match self_ty.sty {
ty::TyEnum(def_id, _) |
@ -208,7 +208,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
}
ast::ItemImpl(_, _, _, Some(_), _, _) => {
// "Trait" impl
debug!("coherence2::orphan check: trait impl {}", item.repr(self.tcx));
debug!("coherence2::orphan check: trait impl {}", item.repr());
let trait_ref = ty::impl_trait_ref(self.tcx, def_id).unwrap();
let trait_def_id = trait_ref.def_id;
match traits::orphan_check(self.tcx, def_id) {
@ -227,7 +227,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
"type parameter `{}` must be used as the type parameter for \
some local type (e.g. `MyStruct<T>`); only traits defined in \
the current crate can be implemented for a type parameter",
param_ty.user_string(self.tcx));
param_ty.user_string());
return;
}
}
@ -266,8 +266,8 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
// rules, but it invalidates the reasoning from
// `two_foos` above.
debug!("trait_ref={} trait_def_id={} trait_has_default_impl={}",
trait_ref.repr(self.tcx),
trait_def_id.repr(self.tcx),
trait_ref.repr(),
trait_def_id.repr(),
ty::trait_has_default_impl(self.tcx, trait_def_id));
if
ty::trait_has_default_impl(self.tcx, trait_def_id) &&
@ -305,7 +305,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
can only be implemented for a struct/enum type, \
not `{}`",
ty::item_path_str(self.tcx, trait_def_id),
self_ty.user_string(self.tcx)))
self_ty.user_string()))
}
};
@ -329,7 +329,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
}
ast::ItemDefaultImpl(..) => {
// "Trait" impl
debug!("coherence2::orphan check: default trait impl {}", item.repr(self.tcx));
debug!("coherence2::orphan check: default trait impl {}", item.repr());
let trait_ref = ty::impl_trait_ref(self.tcx, def_id).unwrap();
if trait_ref.def_id.krate != ast::LOCAL_CRATE {
span_err!(self.tcx.sess, item.span, E0318,

10
src/librustc_typeck/coherence/overlap.rs
View file

@ -62,7 +62,7 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> {
trait_def: &'tcx ty::TraitDef<'tcx>)
{
debug!("check_for_overlapping_impls_of_trait(trait_def={})",
trait_def.repr(self.tcx));
trait_def.repr());
// We should already know all impls of this trait, so these
// borrows are safe.
@ -132,9 +132,9 @@ impl<'cx, 'tcx> OverlapChecker<'cx, 'tcx> {
impl1_def_id, impl2_def_id)
{
debug!("check_if_impls_overlap({}, {}, {})",
trait_def_id.repr(self.tcx),
impl1_def_id.repr(self.tcx),
impl2_def_id.repr(self.tcx));
trait_def_id.repr(),
impl1_def_id.repr(),
impl2_def_id.repr());
let infcx = infer::new_infer_ctxt(self.tcx);
if traits::overlapping_impls(&infcx, impl1_def_id, impl2_def_id) {
@ -217,7 +217,7 @@ impl<'cx, 'tcx,'v> visit::Visitor<'v> for OverlapChecker<'cx, 'tcx> {
span_err!(self.tcx.sess, item.span, E0371,
"the object type `{}` automatically \
implements the trait `{}`",
trait_ref.self_ty().user_string(self.tcx),
trait_ref.self_ty().user_string(),
ty::item_path_str(self.tcx, trait_def_id));
}
}

Some files were not shown because too many files have changed in this diff Show more