use middle::def;
use middle::ty::{self, Ty};
use syntax::ast;
-use util::ppaux::Repr;
pub const NO_REGIONS: usize = 1;
pub const NO_TPS: usize = 2;
let def = match tcx.def_map.borrow().get(&ast_ty.id) {
None => {
tcx.sess.span_bug(ast_ty.span,
- &format!("unbound path {}", path.repr()))
+ &format!("unbound path {:?}", path))
}
Some(d) => d.full_def()
};
use middle::subst;
use middle::subst::VecPerParamSpace;
use middle::ty::{self, Ty, MethodCall, MethodCallee, MethodOrigin};
-use util::ppaux::Repr;
use syntax::{ast, ast_util, codemap, fold};
use syntax::codemap::Span;
}
c::tag_table_node_type => {
let ty = val_dsr.read_ty(dcx);
- debug!("inserting ty for node {}: {}",
- id, ty.repr());
+ debug!("inserting ty for node {}: {:?}",
+ id, ty);
dcx.tcx.node_type_insert(id, ty);
}
c::tag_table_item_subst => {
use syntax::parse::token;
use syntax::ptr::P;
use syntax::visit::{self, Visitor, FnKind};
-use util::ppaux::UserString;
use util::nodemap::FnvHashMap;
pub const DUMMY_WILD_PAT: &'static Pat = &Pat {
// 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());
+ pat_ty);
}
// If the type *is* empty, it's vacuously exhaustive
return;
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());
+ &token::get_ident(ident.node), pat_ty);
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(), &token::get_ident(ident.node));
+ pat_ty, &token::get_ident(ident.node));
}
}
}
use middle::mem_categorization as mc;
use middle::ty::ParameterEnvironment;
use middle::ty;
-use util::ppaux::{Repr, UserString};
use syntax::ast;
use syntax::codemap::Span;
span: Span,
cmt: mc::cmt<'tcx>,
_: euv::ConsumeMode) {
- debug!("consume; cmt: {:?}; type: {}", *cmt, cmt.ty.repr());
+ debug!("consume; cmt: {:?}; type: {:?}", *cmt, cmt.ty);
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());
+ cmt.ty);
}
}
use middle::ty::{self, Ty};
use middle::astconv_util::ast_ty_to_prim_ty;
use util::num::ToPrimitive;
-use util::ppaux::Repr;
use syntax::ast::{self, Expr};
use syntax::ast_util;
rcvr_self,
Vec::new()));
let trait_substs = tcx.mk_substs(trait_substs);
- debug!("resolve_trait_associated_const: trait_substs={}",
- trait_substs.repr());
+ debug!("resolve_trait_associated_const: trait_substs={:?}",
+ trait_substs);
let trait_ref = ty::Binder(ty::TraitRef { def_id: trait_id,
substs: trait_substs });
}
Err(e) => {
tcx.sess.span_bug(ti.span,
- &format!("Encountered error `{}` when trying \
+ &format!("Encountered error `{:?}` when trying \
to select an implementation for \
constant trait item reference.",
- e.repr()))
+ e))
}
};
use middle::def;
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
-use util::ppaux::Repr;
use syntax::ast;
use syntax::codemap::Span;
ast::ExprIndex(ref base, _) => ty::node_id_to_type(self.tcx, base.id),
_ => return
};
- debug!("effect: checking index with base type {}",
- base_type.repr());
+ debug!("effect: checking index with base type {:?}",
+ base_type);
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,
ast::ExprMethodCall(_, _, _) => {
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());
+ debug!("effect: method call case, base type is {:?}",
+ base_type);
if type_is_unsafe_function(base_type) {
self.require_unsafe(expr.span,
"invocation of unsafe method")
}
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());
+ debug!("effect: call case, base type is {:?}",
+ base_type);
if type_is_unsafe_function(base_type) {
self.require_unsafe(expr.span, "call to unsafe function")
}
}
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());
+ debug!("effect: unary case, base type is {:?}",
+ base_type);
if let ty::TyRawPtr(_) = base_type.sty {
self.require_unsafe(expr.span, "dereference of raw pointer")
}
use middle::ty::{MethodCall, MethodObject, MethodTraitObject};
use middle::ty::{MethodOrigin, MethodParam, MethodTypeParam};
use middle::ty::{MethodStatic, MethodStaticClosure};
-use util::ppaux::Repr;
use syntax::{ast, ast_util};
use syntax::ptr::P;
consume_id: ast::NodeId,
consume_span: Span,
cmt: mc::cmt<'tcx>) {
- debug!("delegate_consume(consume_id={}, cmt={})",
- consume_id, cmt.repr());
+ debug!("delegate_consume(consume_id={}, cmt={:?})",
+ consume_id, cmt);
let mode = copy_or_move(self.typer, &cmt, DirectRefMove);
self.delegate.consume(consume_id, consume_span, cmt, mode);
}
pub fn consume_expr(&mut self, expr: &ast::Expr) {
- debug!("consume_expr(expr={})", expr.repr());
+ debug!("consume_expr(expr={:?})", expr);
let cmt = return_if_err!(self.mc.cat_expr(expr));
self.delegate_consume(expr.id, expr.span, cmt);
r: ty::Region,
bk: ty::BorrowKind,
cause: LoanCause) {
- debug!("borrow_expr(expr={}, r={}, bk={})",
- expr.repr(), r.repr(), bk.repr());
+ debug!("borrow_expr(expr={:?}, r={:?}, bk={:?})",
+ expr, r, bk);
let cmt = return_if_err!(self.mc.cat_expr(expr));
self.delegate.borrow(expr.id, expr.span, cmt, r, bk, cause);
}
pub fn walk_expr(&mut self, expr: &ast::Expr) {
- debug!("walk_expr(expr={})", expr.repr());
+ debug!("walk_expr(expr={:?})", expr);
self.walk_adjustment(expr);
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(), callee_ty.repr());
+ debug!("walk_callee: callee={:?} callee_ty={:?}",
+ callee, callee_ty);
let call_scope = region::CodeExtent::from_node_id(call.id);
match callee_ty.sty {
ty::TyBareFn(..) => {
None => {
self.tcx().sess.span_bug(
callee.span,
- &format!("unexpected callee type {}", callee_ty.repr()))
+ &format!("unexpected callee type {}", callee_ty))
}
};
match overloaded_call_type {
fn walk_autoderefs(&mut self,
expr: &ast::Expr,
autoderefs: usize) {
- debug!("walk_autoderefs expr={} autoderefs={}", expr.repr(), autoderefs);
+ debug!("walk_autoderefs expr={:?} autoderefs={}", expr, autoderefs);
for i in 0..autoderefs {
let deref_id = ty::MethodCall::autoderef(expr.id, i as u32);
let (m, r) = match self_ty.sty {
ty::TyRef(r, ref m) => (m.mutbl, r),
_ => self.tcx().sess.span_bug(expr.span,
- &format!("bad overloaded deref type {}",
- method_ty.repr()))
+ &format!("bad overloaded deref type {:?}",
+ method_ty))
};
let bk = ty::BorrowKind::from_mutbl(m);
self.delegate.borrow(expr.id, expr.span, cmt,
fn walk_autoderefref(&mut self,
expr: &ast::Expr,
adj: &ty::AutoDerefRef<'tcx>) {
- debug!("walk_autoderefref expr={} adj={}",
- expr.repr(),
- adj.repr());
+ debug!("walk_autoderefref expr={:?} adj={:?}",
+ expr,
+ adj);
self.walk_autoderefs(expr, adj.autoderefs);
opt_autoref: Option<ty::AutoRef<'tcx>>)
-> mc::cmt<'tcx>
{
- debug!("walk_autoref(expr.id={} cmt_derefd={} opt_autoref={:?})",
+ debug!("walk_autoref(expr.id={} cmt_derefd={:?} opt_autoref={:?})",
expr.id,
- cmt_base.repr(),
+ cmt_base,
opt_autoref);
let cmt_base_ty = cmt_base.ty;
}
ty::AutoUnsafe(m) => {
- debug!("walk_autoref: expr.id={} cmt_base={}",
+ debug!("walk_autoref: expr.id={} cmt_base={:?}",
expr.id,
- cmt_base.repr());
+ cmt_base);
// Converting from a &T to *T (or &mut T to *mut T) is
// treated as borrowing it for the enclosing temporary
cmt_discr: mc::cmt<'tcx>,
pat: &ast::Pat,
mode: &mut TrackMatchMode) {
- debug!("determine_pat_move_mode cmt_discr={} pat={}", cmt_discr.repr(),
- pat.repr());
+ debug!("determine_pat_move_mode cmt_discr={:?} pat={:?}", cmt_discr,
+ pat);
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;
cmt_discr: mc::cmt<'tcx>,
pat: &ast::Pat,
match_mode: MatchMode) {
- debug!("walk_pat cmt_discr={} pat={}", cmt_discr.repr(),
- pat.repr());
+ debug!("walk_pat cmt_discr={:?} pat={:?}", cmt_discr,
+ pat);
let mc = &self.mc;
let typer = self.typer;
if pat_util::pat_is_binding(def_map, pat) {
let tcx = typer.tcx();
- debug!("binding cmt_pat={} pat={} match_mode={:?}",
- cmt_pat.repr(),
- pat.repr(),
+ debug!("binding cmt_pat={:?} pat={:?} match_mode={:?}",
+ cmt_pat,
+ pat,
match_mode);
// pat_ty: the type of the binding being produced.
mc.cat_downcast(pat, cmt_pat, cmt_pat_ty, variant_did)
};
- debug!("variant downcast_cmt={} pat={}",
- downcast_cmt.repr(),
- pat.repr());
+ debug!("variant downcast_cmt={:?} pat={:?}",
+ downcast_cmt,
+ pat);
delegate.matched_pat(pat, downcast_cmt, match_mode);
}
// namespace; we encounter the former on
// e.g. patterns for unit structs).
- debug!("struct cmt_pat={} pat={}",
- cmt_pat.repr(),
- pat.repr());
+ debug!("struct cmt_pat={:?} pat={:?}",
+ cmt_pat,
+ pat);
delegate.matched_pat(pat, cmt_pat, match_mode);
}
// pattern.
if !tcx.sess.has_errors() {
- let msg = format!("Pattern has unexpected type: {:?} and type {}",
+ let msg = format!("Pattern has unexpected type: {:?} and type {:?}",
def,
- cmt_pat.ty.repr());
+ cmt_pat.ty);
tcx.sess.span_bug(pat.span, &msg)
}
}
// reported.
if !tcx.sess.has_errors() {
- let msg = format!("Pattern has unexpected def: {:?} and type {}",
+ let msg = format!("Pattern has unexpected def: {:?} and type {:?}",
def,
- cmt_pat.ty.repr());
+ cmt_pat.ty);
tcx.sess.span_bug(pat.span, &msg[..])
}
}
}
fn walk_captures(&mut self, closure_expr: &ast::Expr) {
- debug!("walk_captures({})", closure_expr.repr());
+ debug!("walk_captures({:?})", closure_expr);
ty::with_freevars(self.tcx(), closure_expr.id, |freevars| {
for freevar in freevars {
use middle::ty::{self, FreeRegion};
use util::common::can_reach;
use util::nodemap::FnvHashMap;
-use util::ppaux::Repr;
#[derive(Clone)]
pub struct FreeRegionMap {
implications: &[Implication<'tcx>])
{
for implication in implications {
- debug!("implication: {}", implication.repr());
+ debug!("implication: {:?}", implication);
match *implication {
Implication::RegionSubRegion(_, ty::ReFree(free_a), ty::ReFree(free_b)) => {
self.relate_free_regions(free_a, free_b);
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());
+ debug!("relate_free_regions_from_predicates(predicates={:?})", predicates);
for predicate in predicates {
match *predicate {
ty::Predicate::Projection(..) |
_ => {
// All named regions are instantiated with free regions.
tcx.sess.bug(
- &format!("record_region_bounds: non free region: {} / {}",
- r_a.repr(),
- r_b.repr()));
+ &format!("record_region_bounds: non free region: {:?} / {:?}",
+ r_a,
+ r_b));
}
}
}
use util::common::ErrorReported;
use util::nodemap::FnvHashSet;
-use util::ppaux::Repr;
// Helper functions related to manipulating region types.
span: Span)
-> Vec<Implication<'tcx>>
{
- debug!("implications(body_id={}, ty={}, outer_region={})",
+ debug!("implications(body_id={}, ty={:?}, outer_region={:?})",
body_id,
- ty.repr(),
- outer_region.repr());
+ ty,
+ outer_region);
let mut stack = Vec::new();
stack.push((outer_region, None));
out: Vec::new(),
visited: FnvHashSet() };
wf.accumulate_from_ty(ty);
- debug!("implications: out={}", wf.out.repr());
+ debug!("implications: out={:?}", wf.out);
wf.out
}
}
fn accumulate_from_ty(&mut self, ty: Ty<'tcx>) {
- debug!("accumulate_from_ty(ty={})",
- ty.repr());
+ debug!("accumulate_from_ty(ty={:?})",
+ ty);
// When expanding out associated types, we can visit a cyclic
// set of types. Issue #23003.
fn accumulate_from_assoc_types_transitive(&mut self,
data: &ty::PolyTraitPredicate<'tcx>)
{
- debug!("accumulate_from_assoc_types_transitive({})",
- data.repr());
+ debug!("accumulate_from_assoc_types_transitive({:?})",
+ data);
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) {
fn accumulate_from_assoc_types(&mut self,
trait_ref: ty::TraitRef<'tcx>)
{
- debug!("accumulate_from_assoc_types({})",
- trait_ref.repr());
+ debug!("accumulate_from_assoc_types({:?})",
+ trait_ref);
let trait_def_id = trait_ref.def_id;
let trait_def = ty::lookup_trait_def(self.tcx(), trait_def_id);
.iter()
.map(|&name| ty::mk_projection(self.tcx(), trait_ref.clone(), name))
.collect();
- debug!("accumulate_from_assoc_types: assoc_type_projections={}",
- assoc_type_projections.repr());
+ debug!("accumulate_from_assoc_types: assoc_type_projections={:?}",
+ assoc_type_projections);
let tys = match self.fully_normalize(&assoc_type_projections) {
Ok(tys) => { tys }
Err(ErrorReported) => { return; }
use middle::ty::{self, Ty};
use middle::ty::TyVar;
use middle::ty_relate::{Relate, RelateResult, TypeRelation};
-use util::ppaux::{Repr};
pub struct Bivariate<'a, 'tcx: 'a> {
fields: CombineFields<'a, 'tcx>
}
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
- debug!("{}.tys({}, {})", self.tag(),
- a.repr(), b.repr());
+ debug!("{}.tys({:?}, {:?})", self.tag(),
+ a, b);
if a == b { return Ok(a); }
let infcx = self.fields.infcx;
use middle::ty_fold;
use middle::ty_fold::{TypeFolder, TypeFoldable};
use middle::ty_relate::{self, Relate, RelateResult, TypeRelation};
-use util::ppaux::Repr;
use syntax::ast;
use syntax::codemap::Span;
Some(e) => e,
};
- debug!("instantiate(a_ty={} dir={:?} b_vid={})",
- a_ty.repr(),
+ debug!("instantiate(a_ty={:?} dir={:?} b_vid={:?})",
+ a_ty,
dir,
- b_vid.repr());
+ b_vid);
// Check whether `vid` has been instantiated yet. If not,
// make a generalized form of `ty` and instantiate with
EqTo => self.generalize(a_ty, b_vid, false),
BiTo | SupertypeOf | SubtypeOf => self.generalize(a_ty, b_vid, true),
});
- debug!("instantiate(a_ty={}, dir={:?}, \
- b_vid={}, generalized_ty={})",
- a_ty.repr(), dir, b_vid.repr(),
- generalized_ty.repr());
+ debug!("instantiate(a_ty={:?}, dir={:?}, \
+ b_vid={:?}, generalized_ty={:?})",
+ a_ty, dir, b_vid,
+ generalized_ty);
self.infcx.type_variables
.borrow_mut()
.instantiate_and_push(
ty::ReEarlyBound(..) => {
self.tcx().sess.span_bug(
self.span,
- &format!("Encountered early bound region when generalizing: {}",
- r.repr()));
+ &format!("Encountered early bound region when generalizing: {:?}",
+ r));
}
// Always make a fresh region variable for skolemized regions;
use middle::ty::{self, Ty};
use middle::ty::TyVar;
use middle::ty_relate::{Relate, RelateResult, TypeRelation};
-use util::ppaux::{Repr};
pub struct Equate<'a, 'tcx: 'a> {
fields: CombineFields<'a, 'tcx>
}
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
- debug!("{}.tys({}, {})", self.tag(),
- a.repr(), b.repr());
+ debug!("{}.tys({:?}, {:?})", self.tag(),
+ a, b);
if a == b { return Ok(a); }
let infcx = self.fields.infcx;
}
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
- debug!("{}.regions({}, {})",
+ debug!("{}.regions({:?}, {:?})",
self.tag(),
- a.repr(),
- b.repr());
+ a,
+ b);
let origin = Subtype(self.fields.trace.clone());
self.fields.infcx.region_vars.make_eqregion(origin, a, b);
Ok(a)
use middle::subst;
use middle::ty::{self, Ty};
use middle::ty::{Region, ReFree};
+
use std::cell::{Cell, RefCell};
use std::char::from_u32;
-use std::string::String;
+use std::fmt;
use syntax::ast;
use syntax::ast_util::name_to_dummy_lifetime;
use syntax::owned_slice::OwnedSlice;
use syntax::print::pprust;
use syntax::ptr::P;
-// Note: only import UserString, not Repr, since user-facing error
-// messages shouldn't include debug serializations.
-use util::ppaux::UserString;
-
pub fn note_and_explain_region(tcx: &ty::ctxt,
prefix: &str,
region: ty::Region,
ty::BrFresh(_) => "an anonymous lifetime defined on".to_owned(),
_ => {
format!("the lifetime {} as defined on",
- fr.bound_region.user_string())
+ fr.bound_region)
}
};
fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<String>;
- fn expected_found_str<T: UserString + Resolvable<'tcx>>(
+ fn expected_found_str<T: fmt::Display + Resolvable<'tcx>>(
&self,
exp_found: &ty::expected_found<T>)
-> Option<String>;
}
}
- fn expected_found_str<T: UserString + Resolvable<'tcx>>(
+ fn expected_found_str<T: fmt::Display + Resolvable<'tcx>>(
&self,
exp_found: &ty::expected_found<T>)
-> Option<String>
}
Some(format!("expected `{}`, found `{}`",
- expected.user_string(),
- found.user_string()))
+ expected,
+ found))
}
fn report_generic_bound_failure(&self,
let labeled_user_string = match bound_kind {
GenericKind::Param(ref p) =>
- format!("the parameter type `{}`", p.user_string()),
+ format!("the parameter type `{}`", p),
GenericKind::Projection(ref p) =>
- format!("the associated type `{}`", p.user_string()),
+ format!("the associated type `{}`", p),
};
match sub {
origin.span(),
&format!(
"consider adding an explicit lifetime bound `{}: {}`...",
- bound_kind.user_string(),
- sub.user_string()));
+ bound_kind,
+ sub));
}
ty::ReStatic => {
origin.span(),
&format!(
"consider adding an explicit lifetime bound `{}: 'static`...",
- bound_kind.user_string()));
+ bound_kind));
}
_ => {
origin.span(),
&format!(
"consider adding an explicit lifetime bound for `{}`",
- bound_kind.user_string()));
+ bound_kind));
note_and_explain_region(
self.tcx,
&format!("{} must be valid for ", labeled_user_string),
fn report_inference_failure(&self,
var_origin: RegionVariableOrigin) {
let br_string = |br: ty::BoundRegion| {
- let mut s = br.user_string();
+ let mut s = br.to_string();
if !s.is_empty() {
s.push_str(" ");
}
use middle::ty::{self, Ty};
use middle::ty_relate::{Relate, RelateResult, TypeRelation};
-use util::ppaux::Repr;
/// "Greatest lower bound" (common subtype)
pub struct Glb<'a, 'tcx: 'a> {
}
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
- debug!("{}.regions({}, {})",
+ debug!("{}.regions({:?}, {:?})",
self.tag(),
- a.repr(),
- b.repr());
+ a,
+ b);
let origin = Subtype(self.fields.trace.clone());
Ok(self.fields.infcx.region_vars.glb_regions(origin, a, b))
use middle::ty_relate::{Relate, RelateResult, TypeRelation};
use syntax::codemap::Span;
use util::nodemap::{FnvHashMap, FnvHashSet};
-use util::ppaux::Repr;
pub trait HigherRankedRelations<'a,'tcx> {
fn higher_ranked_sub<T>(&self, a: &Binder<T>, b: &Binder<T>) -> RelateResult<'tcx, Binder<T>>
-> RelateResult<'tcx, Binder<T>>
where T: Relate<'a,'tcx>
{
- debug!("higher_ranked_sub(a={}, b={})",
- a.repr(), b.repr());
+ debug!("higher_ranked_sub(a={:?}, b={:?})",
+ a, b);
// 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
let (b_prime, skol_map) =
self.infcx.skolemize_late_bound_regions(b, snapshot);
- debug!("a_prime={}", a_prime.repr());
- debug!("b_prime={}", b_prime.repr());
+ debug!("a_prime={:?}", a_prime);
+ debug!("b_prime={:?}", b_prime);
// Compare types now that bound regions have been replaced.
let result = try!(self.sub().relate(&a_prime, &b_prime));
}
}
- debug!("higher_ranked_sub: OK result={}",
- result.repr());
+ debug!("higher_ranked_sub: OK result={:?}",
+ result);
Ok(ty::Binder(result))
});
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());
+ debug!("lub result0 = {:?}", result0);
// Generalize the regions appearing in result0 if possible
let new_vars = self.infcx.region_vars_confined_to_snapshot(snapshot);
|r, debruijn| generalize_region(self.infcx, span, snapshot, debruijn,
&new_vars, &a_map, r));
- debug!("lub({},{}) = {}",
- a.repr(),
- b.repr(),
- result1.repr());
+ debug!("lub({:?},{:?}) = {:?}",
+ a,
+ b,
+ result1);
Ok(ty::Binder(result1))
});
fn higher_ranked_glb<T>(&self, a: &Binder<T>, b: &Binder<T>) -> RelateResult<'tcx, Binder<T>>
where T: Relate<'a,'tcx>
{
- debug!("higher_ranked_glb({}, {})",
- a.repr(), b.repr());
+ debug!("higher_ranked_glb({:?}, {:?})",
+ a, b);
// Make a snapshot so we can examine "all bindings that were
// created as part of this type comparison".
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());
+ debug!("glb result0 = {:?}", result0);
// Generalize the regions appearing in result0 if possible
let new_vars = self.infcx.region_vars_confined_to_snapshot(snapshot);
&a_map, &a_vars, &b_vars,
r));
- debug!("glb({},{}) = {}",
- a.repr(),
- b.repr(),
- result1.repr());
+ debug!("glb({:?},{:?}) = {:?}",
+ a,
+ b,
+ result1);
Ok(ty::Binder(result1))
});
!escaping_region_vars.contains(&r)
});
- debug!("region_vars_confined_to_snapshot: region_vars={} escaping_types={}",
- region_vars.repr(),
- escaping_types.repr());
+ debug!("region_vars_confined_to_snapshot: region_vars={:?} escaping_types={:?}",
+ region_vars,
+ escaping_types);
region_vars
}
infcx.region_vars.new_skolemized(br, &snapshot.region_vars_snapshot)
});
- debug!("skolemize_bound_regions(binder={}, result={}, map={})",
- binder.repr(),
- result.repr(),
- map.repr());
+ debug!("skolemize_bound_regions(binder={:?}, result={:?}, map={:?})",
+ binder,
+ result,
+ map);
(result, map)
}
* hold. See `README.md` for more details.
*/
- debug!("leak_check: skol_map={}",
- skol_map.repr());
+ debug!("leak_check: skol_map={:?}",
+ skol_map);
let new_vars = infcx.region_vars_confined_to_snapshot(snapshot);
for (&skol_br, &skol) in skol_map {
}
};
- debug!("{} (which replaced {}) is tainted by {}",
- skol.repr(),
- skol_br.repr(),
- tainted_region.repr());
+ debug!("{:?} (which replaced {:?}) is tainted by {:?}",
+ skol,
+ skol_br,
+ tainted_region);
// A is not as polymorphic as B:
return Err((skol_br, tainted_region));
{
debug_assert!(leak_check(infcx, &skol_map, snapshot).is_ok());
- debug!("plug_leaks(skol_map={}, value={})",
- skol_map.repr(),
- value.repr());
+ debug!("plug_leaks(skol_map={:?}, value={:?})",
+ skol_map,
+ value);
// Compute a mapping from the "taint set" of each skolemized
// region back to the `ty::BoundRegion` that it originally
})
.collect();
- debug!("plug_leaks: inv_skol_map={}",
- inv_skol_map.repr());
+ debug!("plug_leaks: inv_skol_map={:?}",
+ inv_skol_map);
// Remove any instantiated type variables from `value`; those can hide
// references to regions from the `fold_regions` code below.
}
});
- debug!("plug_leaks: result={}",
- result.repr());
+ debug!("plug_leaks: result={:?}",
+ result);
result
}
use middle::ty::TyVar;
use middle::ty::{self, Ty};
use middle::ty_relate::{RelateResult, TypeRelation};
-use util::ppaux::Repr;
pub trait LatticeDir<'f,'tcx> : TypeRelation<'f,'tcx> {
fn infcx(&self) -> &'f InferCtxt<'f, 'tcx>;
-> RelateResult<'tcx, Ty<'tcx>>
where 'tcx: 'a
{
- debug!("{}.lattice_tys({}, {})",
+ debug!("{}.lattice_tys({:?}, {:?})",
this.tag(),
- a.repr(),
- b.repr());
+ a,
+ b);
if a == b {
return Ok(a);
use middle::ty::{self, Ty};
use middle::ty_relate::{Relate, RelateResult, TypeRelation};
-use util::ppaux::Repr;
/// "Least upper bound" (common supertype)
pub struct Lub<'a, 'tcx: 'a> {
}
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
- debug!("{}.regions({}, {})",
+ debug!("{}.regions({:?}, {:?})",
self.tag(),
- a.repr(),
- b.repr());
+ a,
+ b);
let origin = Subtype(self.fields.trace.clone());
Ok(self.fields.infcx.region_vars.lub_regions(origin, a, b))
use syntax::codemap;
use syntax::codemap::Span;
use util::nodemap::FnvHashMap;
-use util::ppaux::{Repr, UserString};
use self::combine::CombineFields;
use self::region_inference::{RegionVarBindings, RegionSnapshot};
b: Ty<'tcx>)
-> Ty<'tcx>
{
- debug!("common_supertype({}, {})",
- a.repr(), b.repr());
+ debug!("common_supertype({:?}, {:?})",
+ a, b);
let trace = TypeTrace {
origin: origin,
b: Ty<'tcx>)
-> UnitResult<'tcx>
{
- debug!("mk_subty({} <: {})", a.repr(), b.repr());
+ debug!("mk_subty({:?} <: {:?})", a, b);
cx.sub_types(a_is_expected, origin, a, b)
}
a: Ty<'tcx>,
b: Ty<'tcx>)
-> UnitResult<'tcx> {
- debug!("can_mk_subty({} <: {})", a.repr(), b.repr());
+ debug!("can_mk_subty({:?} <: {:?})", a, b);
cx.probe(|_| {
let trace = TypeTrace {
origin: Misc(codemap::DUMMY_SP),
origin: SubregionOrigin<'tcx>,
a: ty::Region,
b: ty::Region) {
- debug!("mk_subr({} <: {})", a.repr(), b.repr());
+ debug!("mk_subr({:?} <: {:?})", a, b);
let snapshot = cx.region_vars.start_snapshot();
cx.region_vars.make_subregion(origin, a, b);
cx.region_vars.commit(snapshot);
b: Ty<'tcx>)
-> UnitResult<'tcx>
{
- debug!("mk_eqty({} <: {})", a.repr(), b.repr());
+ debug!("mk_eqty({:?} <: {:?})", a, b);
cx.commit_if_ok(|_| cx.eq_types(a_is_expected, origin, a, b))
}
b: ty::PolyTraitRef<'tcx>)
-> UnitResult<'tcx>
{
- debug!("mk_sub_trait_refs({} <: {})",
- a.repr(), b.repr());
+ debug!("mk_sub_trait_refs({:?} <: {:?})",
+ a, b);
cx.commit_if_ok(|_| cx.sub_poly_trait_refs(a_is_expected, origin, a.clone(), b.clone()))
}
b: Ty<'tcx>)
-> UnitResult<'tcx>
{
- debug!("sub_types({} <: {})", a.repr(), b.repr());
+ debug!("sub_types({:?} <: {:?})", a, b);
self.commit_if_ok(|_| {
let trace = TypeTrace::types(origin, a_is_expected, a, b);
self.sub(a_is_expected, trace).relate(&a, &b).map(|_| ())
b: ty::TraitRef<'tcx>)
-> UnitResult<'tcx>
{
- debug!("sub_trait_refs({} <: {})",
- a.repr(),
- b.repr());
+ debug!("sub_trait_refs({:?} <: {:?})",
+ a,
+ b);
self.commit_if_ok(|_| {
let trace = TypeTrace {
origin: origin,
b: ty::PolyTraitRef<'tcx>)
-> UnitResult<'tcx>
{
- debug!("sub_poly_trait_refs({} <: {})",
- a.repr(),
- b.repr());
+ debug!("sub_poly_trait_refs({:?} <: {:?})",
+ a,
+ b);
self.commit_if_ok(|_| {
let trace = TypeTrace {
origin: origin,
}
pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
- self.resolve_type_vars_if_possible(&t).user_string()
+ self.resolve_type_vars_if_possible(&t).to_string()
}
pub fn tys_to_string(&self, ts: &[Ty<'tcx>]) -> String {
}
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.resolve_type_vars_if_possible(t).to_string()
}
pub fn shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx> {
kind: GenericKind<'tcx>,
a: ty::Region,
bs: Vec<ty::Region>) {
- debug!("verify_generic_bound({}, {} <: {})",
- kind.repr(),
- a.repr(),
- bs.repr());
+ debug!("verify_generic_bound({:?}, {:?} <: {:?})",
+ kind,
+ a,
+ bs);
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
+ where T: Relate<'b,'tcx> + fmt::Debug
{
- debug!("can_equate({}, {})", a.repr(), b.repr());
+ debug!("can_equate({:?}, {:?})", a, b);
self.probe(|_| {
// Gin up a dummy trace, since this won't be committed
// anyhow. We should make this typetrace stuff more
use middle::infer::SubregionOrigin;
use middle::infer::region_inference::RegionVarBindings;
use util::nodemap::{FnvHashMap, FnvHashSet};
-use util::ppaux::Repr;
use std::borrow::Cow;
use std::collections::hash_map::Entry::Vacant;
Node::RegionVid(n_vid) =>
dot::LabelText::label(format!("{:?}", n_vid)),
Node::Region(n_rgn) =>
- dot::LabelText::label(format!("{}", n_rgn.repr())),
+ dot::LabelText::label(format!("{:?}", n_rgn)),
}
}
fn edge_label(&self, e: &Edge) -> dot::LabelText {
match *e {
Edge::Constraint(ref c) =>
- dot::LabelText::label(format!("{}", self.map.get(c).unwrap().repr())),
+ dot::LabelText::label(format!("{:?}", self.map.get(c).unwrap())),
Edge::EnclScope(..) =>
dot::LabelText::label(format!("(enclosed)")),
}
use middle::ty_relate::RelateResult;
use util::common::indenter;
use util::nodemap::{FnvHashMap, FnvHashSet};
-use util::ppaux::Repr;
use std::cell::{Cell, RefCell};
use std::cmp::Ordering::{self, Less, Greater, Equal};
if self.in_snapshot() {
self.undo_log.borrow_mut().push(AddVar(vid));
}
- debug!("created new region variable {:?} with origin {}",
- vid, origin.repr());
+ debug!("created new region variable {:?} with origin {:?}",
+ vid, origin);
return vid;
}
// cannot add constraints once regions are resolved
assert!(self.values_are_none());
- debug!("RegionVarBindings: add_constraint({})",
- constraint.repr());
+ debug!("RegionVarBindings: add_constraint({:?})",
+ constraint);
if self.constraints.borrow_mut().insert(constraint, origin).is_none() {
if self.in_snapshot() {
// cannot add verifys once regions are resolved
assert!(self.values_are_none());
- debug!("RegionVarBindings: add_verify({})",
- verify.repr());
+ debug!("RegionVarBindings: add_verify({:?})",
+ verify);
let mut verifys = self.verifys.borrow_mut();
let index = verifys.len();
let mut givens = self.givens.borrow_mut();
if givens.insert((sub, sup)) {
- debug!("add_given({} <= {:?})",
- sub.repr(),
+ debug!("add_given({:?} <= {:?})",
+ sub,
sup);
self.undo_log.borrow_mut().push(AddGiven(sub, sup));
// cannot add constraints once regions are resolved
assert!(self.values_are_none());
- debug!("RegionVarBindings: make_subregion({}, {}) due to {}",
- sub.repr(),
- sup.repr(),
- origin.repr());
+ debug!("RegionVarBindings: make_subregion({:?}, {:?}) due to {:?}",
+ sub,
+ sup,
+ origin);
match (sub, sup) {
(ReEarlyBound(..), ReEarlyBound(..)) => {
(_, ReLateBound(..)) => {
self.tcx.sess.span_bug(
origin.span(),
- &format!("cannot relate bound region: {} <= {}",
- sub.repr(),
- sup.repr()));
+ &format!("cannot relate bound region: {:?} <= {:?}",
+ sub,
+ sup));
}
(_, ReStatic) => {
// all regions are subregions of static, so we can ignore this
// cannot add constraints once regions are resolved
assert!(self.values_are_none());
- debug!("RegionVarBindings: lub_regions({}, {})",
- a.repr(),
- b.repr());
+ debug!("RegionVarBindings: lub_regions({:?}, {:?})",
+ a,
+ b);
match (a, b) {
(ReStatic, _) | (_, ReStatic) => {
ReStatic // nothing lives longer than static
// cannot add constraints once regions are resolved
assert!(self.values_are_none());
- debug!("RegionVarBindings: glb_regions({}, {})",
- a.repr(),
- b.repr());
+ debug!("RegionVarBindings: glb_regions({:?}, {:?})",
+ a,
+ b);
match (a, b) {
(ReStatic, r) | (r, ReStatic) => {
// static lives longer than everything else
}
Some(ref values) => {
let r = lookup(values, rid);
- debug!("resolve_var({:?}) = {}", rid, r.repr());
+ debug!("resolve_var({:?}) = {:?}", rid, r);
r
}
}
/// 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());
+ debug!("tainted(mark={:?}, r0={:?})", mark, r0);
let _indenter = indenter();
// `result_set` acts as a worklist: we explore all outgoing
(ReEarlyBound(..), _) |
(_, ReEarlyBound(..)) => {
self.tcx.sess.bug(
- &format!("cannot relate bound region: LUB({}, {})",
- a.repr(),
- b.repr()));
+ &format!("cannot relate bound region: LUB({:?}, {:?})",
+ a,
+ b));
}
(ReStatic, _) | (_, ReStatic) => {
(ReEarlyBound(..), _) |
(_, ReEarlyBound(..)) => {
self.tcx.sess.bug(
- &format!("cannot relate bound region: GLB({}, {})",
- a.repr(),
- b.repr()));
+ &format!("cannot relate bound region: GLB({:?}, {:?})",
+ a,
+ b));
}
(ReStatic, r) | (r, ReStatic) => {
fn dump_constraints(&self) {
debug!("----() Start constraint listing ()----");
for (idx, (constraint, _)) in self.constraints.borrow().iter().enumerate() {
- debug!("Constraint {} => {}", idx, constraint.repr());
+ debug!("Constraint {} => {:?}", idx, constraint);
}
}
fn expansion(&self, free_regions: &FreeRegionMap, var_data: &mut [VarData]) {
self.iterate_until_fixed_point("Expansion", |constraint| {
- debug!("expansion: constraint={} origin={}",
- constraint.repr(),
+ debug!("expansion: constraint={:?} origin={:?}",
+ constraint,
self.constraints.borrow()
.get(constraint)
.unwrap()
- .repr());
+ );
match *constraint {
ConstrainRegSubVar(a_region, b_vid) => {
let b_data = &mut var_data[b_vid.index as usize];
b_data: &mut VarData)
-> bool
{
- debug!("expand_node({}, {:?} == {})",
- a_region.repr(),
+ debug!("expand_node({:?}, {:?} == {:?})",
+ a_region,
b_vid,
- b_data.value.repr());
+ b_data.value);
// Check if this relationship is implied by a given.
match a_region {
b_data.classification = Expanding;
match b_data.value {
NoValue => {
- debug!("Setting initial value of {:?} to {}",
- b_vid, a_region.repr());
+ debug!("Setting initial value of {:?} to {:?}",
+ b_vid, a_region);
b_data.value = Value(a_region);
return true;
return false;
}
- debug!("Expanding value of {:?} from {} to {}",
+ debug!("Expanding value of {:?} from {:?} to {:?}",
b_vid,
- cur_region.repr(),
- lub.repr());
+ cur_region,
+ lub);
b_data.value = Value(lub);
return true;
free_regions: &FreeRegionMap,
var_data: &mut [VarData]) {
self.iterate_until_fixed_point("Contraction", |constraint| {
- debug!("contraction: constraint={} origin={}",
- constraint.repr(),
+ debug!("contraction: constraint={:?} origin={:?}",
+ constraint,
self.constraints.borrow()
.get(constraint)
.unwrap()
- .repr());
+ );
match *constraint {
ConstrainRegSubVar(..) => {
// This is an expansion constraint. Ignore.
a_data: &mut VarData,
b_region: Region)
-> bool {
- debug!("contract_node({:?} == {}/{:?}, {})",
- a_vid, a_data.value.repr(),
- a_data.classification, b_region.repr());
+ debug!("contract_node({:?} == {:?}/{:?}, {:?})",
+ a_vid, a_data.value,
+ a_data.classification, b_region);
return match a_data.value {
NoValue => {
-> bool
{
if !free_regions.is_subregion_of(this.tcx, a_region, b_region) {
- debug!("Setting {:?} to ErrorValue: {} not subregion of {}",
+ debug!("Setting {:?} to ErrorValue: {:?} not subregion of {:?}",
a_vid,
- a_region.repr(),
- b_region.repr());
+ a_region,
+ b_region);
a_data.value = ErrorValue;
}
false
if glb == a_region {
false
} else {
- debug!("Contracting value of {:?} from {} to {}",
+ debug!("Contracting value of {:?} from {:?} to {:?}",
a_vid,
- a_region.repr(),
- glb.repr());
+ a_region,
+ glb);
a_data.value = Value(glb);
true
}
}
Err(_) => {
- debug!("Setting {:?} to ErrorValue: no glb of {}, {}",
+ debug!("Setting {:?} to ErrorValue: no glb of {:?}, {:?}",
a_vid,
- a_region.repr(),
- b_region.repr());
+ a_region,
+ b_region);
a_data.value = ErrorValue;
false
}
continue;
}
- debug!("ConcreteFailure: !(sub <= sup): sub={}, sup={}",
- sub.repr(),
- sup.repr());
+ debug!("ConcreteFailure: !(sub <= sup): sub={:?}, sup={:?}",
+ sub,
+ sup);
errors.push(ConcreteFailure((*origin).clone(), sub, sup));
}
self.tcx.sess.span_bug(
(*self.var_origins.borrow())[node_idx.index as usize].span(),
&format!("collect_error_for_expanding_node() could not find error \
- for var {:?}, lower_bounds={}, upper_bounds={}",
+ for var {:?}, lower_bounds={:?}, upper_bounds={:?}",
node_idx,
- lower_bounds.repr(),
- upper_bounds.repr()));
+ lower_bounds,
+ upper_bounds));
}
fn collect_error_for_contracting_node(
self.tcx.sess.span_bug(
(*self.var_origins.borrow())[node_idx.index as usize].span(),
&format!("collect_error_for_contracting_node() could not find error \
- for var {:?}, upper_bounds={}",
+ for var {:?}, upper_bounds={:?}",
node_idx,
- upper_bounds.repr()));
+ upper_bounds));
}
fn collect_concrete_regions(&self,
for (constraint, _) in self.constraints.borrow().iter() {
let edge_changed = body(constraint);
if edge_changed {
- debug!("Updated due to constraint {}",
- constraint.repr());
+ debug!("Updated due to constraint {:?}",
+ constraint);
changed = true;
}
}
impl<'tcx> fmt::Debug for RegionAndOrigin<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "RegionAndOrigin({},{})",
- self.region.repr(),
- self.origin.repr())
+ write!(f, "RegionAndOrigin({:?},{:?})",
+ self.region,
+ self.origin)
}
}
use super::{InferCtxt, fixup_err, fres, unresolved_ty, unresolved_int_ty, unresolved_float_ty};
use middle::ty::{self, Ty};
use middle::ty_fold::{self, TypeFoldable};
-use util::ppaux::Repr;
///////////////////////////////////////////////////////////////////////////
// OPPORTUNISTIC TYPE RESOLVER
}
ty::TyInfer(_) => {
self.infcx.tcx.sess.bug(
- &format!("Unexpected type in full type resolver: {}",
- t.repr()));
+ &format!("Unexpected type in full type resolver: {:?}",
+ t));
}
_ => {
ty_fold::super_fold_ty(self, t)
use middle::ty::{self, Ty};
use middle::ty::TyVar;
use middle::ty_relate::{Relate, RelateResult, TypeRelation};
-use util::ppaux::{Repr};
/// "Greatest lower bound" (common subtype)
pub struct Sub<'a, 'tcx: 'a> {
}
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
- debug!("{}.tys({}, {})", self.tag(), a.repr(), b.repr());
+ debug!("{}.tys({:?}, {:?})", self.tag(), a, b);
if a == b { return Ok(a); }
}
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
- debug!("{}.regions({}, {})",
+ debug!("{}.regions({:?}, {:?})",
self.tag(),
- a.repr(),
- b.repr());
+ a,
+ b);
let origin = Subtype(self.fields.trace.clone());
self.fields.infcx.region_vars.make_subregion(origin, a, b);
Ok(a)
use middle::subst::{Subst, Substs, EnumeratedItems};
use middle::ty::{TransmuteRestriction, ctxt, TyBareFn};
use middle::ty::{self, Ty};
-use util::ppaux::Repr;
use std::fmt;
match types_in_scope.next() {
None => {
- debug!("with_each_combination(substs={})",
- substs.repr());
+ debug!("with_each_combination(substs={:?})",
+ substs);
callback(substs);
}
Some((space, index, ¶m_ty)) => {
- debug!("with_each_combination: space={:?}, index={}, param_ty={}",
- space, index, param_ty.repr());
+ debug!("with_each_combination: space={:?}, index={}, param_ty={:?}",
+ space, index, param_ty);
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");
}
fn push_transmute_restriction(&self, restriction: TransmuteRestriction<'tcx>) {
- debug!("Pushing transmute restriction: {}", restriction.repr());
+ debug!("Pushing transmute restriction: {:?}", restriction);
self.tcx.transmute_restrictions.borrow_mut().push(restriction);
}
}
use middle::region;
use middle::ty::{self, Ty};
use util::nodemap::NodeMap;
-use util::ppaux::{Repr, UserString};
use syntax::ast::{MutImmutable, MutMutable};
use syntax::ast;
use syntax::codemap::Span;
-use syntax::print::pprust;
use std::cell::RefCell;
use std::fmt;
}
_ => base_ty,
};
- debug!("pat_ty(pat={}) base_ty={} ret_ty={}",
- pat.repr(), base_ty.repr(), ret_ty.repr());
+ debug!("pat_ty(pat={:?}) base_ty={:?} ret_ty={:?}",
+ pat, base_ty, ret_ty);
Ok(ret_ty)
}
ty::AdjustReifyFnPointer |
ty::AdjustUnsafeFnPointer |
ty::AdjustDerefRef(_) => {
- debug!("cat_expr({}): {}",
- adjustment.repr(),
- expr.repr());
+ debug!("cat_expr({:?}): {:?}",
+ adjustment,
+ expr);
// Result is an rvalue.
let expr_ty = try!(self.expr_ty_adjusted(expr));
Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
autoderefs: usize)
-> McResult<cmt<'tcx>> {
let mut cmt = try!(self.cat_expr_unadjusted(expr));
- debug!("cat_expr_autoderefd: autoderefs={}, cmt={}",
+ debug!("cat_expr_autoderefd: autoderefs={}, cmt={:?}",
autoderefs,
- cmt.repr());
+ cmt);
for deref in 1..autoderefs + 1 {
cmt = try!(self.cat_deref(expr, cmt, deref, None));
}
}
pub fn cat_expr_unadjusted(&self, expr: &ast::Expr) -> McResult<cmt<'tcx>> {
- debug!("cat_expr: id={} expr={}", expr.id, expr.repr());
+ debug!("cat_expr: id={} expr={:?}", expr.id, expr);
let expr_ty = try!(self.expr_ty(expr));
match expr.node {
ast::ExprField(ref base, f_name) => {
let base_cmt = try!(self.cat_expr(&**base));
- debug!("cat_expr(cat_field): id={} expr={} base={}",
+ debug!("cat_expr(cat_field): id={} expr={:?} base={:?}",
expr.id,
- expr.repr(),
- base_cmt.repr());
+ expr,
+ base_cmt);
Ok(self.cat_field(expr, base_cmt, f_name.node.name, expr_ty))
}
let elem_ty = match ret_ty.sty {
ty::TyRef(_, mt) => mt.ty,
_ => {
- debug!("cat_expr_unadjusted: return type of overloaded index is {}?",
- ret_ty.repr());
+ debug!("cat_expr_unadjusted: return type of overloaded index is {:?}?",
+ ret_ty);
return Err(());
}
};
expr_ty: Ty<'tcx>,
def: def::Def)
-> McResult<cmt<'tcx>> {
- debug!("cat_def: id={} expr={} def={:?}",
- id, expr_ty.repr(), def);
+ debug!("cat_def: id={} expr={:?} def={:?}",
+ id, expr_ty, def);
match def {
def::DefStruct(..) | def::DefVariant(..) | def::DefConst(..) |
_ => {
self.tcx().sess.span_bug(
span,
- &format!("Upvar of non-closure {} - {}",
+ &format!("Upvar of non-closure {} - {:?}",
fn_node_id,
- ty.repr()));
+ ty));
}
}
}
};
let ret = Rc::new(cmt_result);
- debug!("cat_upvar ret={}", ret.repr());
+ debug!("cat_upvar ret={:?}", ret);
Ok(ret)
}
note: NoteClosureEnv(upvar_id)
};
- debug!("env_deref ret {}", ret.repr());
+ debug!("env_deref ret {:?}", ret);
ret
}
ty::ReStatic
};
let ret = self.cat_rvalue(id, span, re, expr_ty);
- debug!("cat_rvalue_node ret {}", ret.repr());
+ debug!("cat_rvalue_node ret {:?}", ret);
ret
}
ty:expr_ty,
note: NoteNone
});
- debug!("cat_rvalue ret {}", ret.repr());
+ debug!("cat_rvalue ret {:?}", ret);
ret
}
ty: f_ty,
note: NoteNone
});
- debug!("cat_field ret {}", ret.repr());
+ debug!("cat_field ret {:?}", ret);
ret
}
ty: f_ty,
note: NoteNone
});
- debug!("cat_tup_field ret {}", ret.repr());
+ debug!("cat_tup_field ret {:?}", ret);
ret
}
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()));
+ method_call, method_ty.map(|ty| ty));
let base_cmt = match method_ty {
Some(method_ty) => {
mt.ty,
deref_context,
/* implicit: */ false);
- debug!("cat_deref ret {}", ret.repr());
+ debug!("cat_deref ret {:?}", ret);
ret
}
None => {
- debug!("Explicit deref of non-derefable type: {}",
- base_cmt_ty.repr());
+ debug!("Explicit deref of non-derefable type: {:?}",
+ base_cmt_ty);
return Err(());
}
}
ty: deref_ty,
note: NoteNone
});
- debug!("cat_deref_common ret {}", ret.repr());
+ debug!("cat_deref_common ret {:?}", ret);
Ok(ret)
}
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());
+ debug!("cat_index ret {:?}", ret);
return Ok(ret);
fn interior<'tcx, N: ast_node>(elt: &N,
base_cmt
}
};
- debug!("deref_vec ret {}", ret.repr());
+ debug!("deref_vec ret {:?}", ret);
Ok(ret)
}
ty: interior_ty,
note: NoteNone
});
- debug!("cat_imm_interior ret={}", ret.repr());
+ debug!("cat_imm_interior ret={:?}", ret);
ret
}
ty: downcast_ty,
note: NoteNone
});
- debug!("cat_downcast ret={}", ret.repr());
+ debug!("cat_downcast ret={:?}", ret);
ret
}
// step out of sync again. So you'll see below that we always
// get the type of the *subpattern* and use that.
- debug!("cat_pattern: id={} pat={} cmt={}",
- pat.id, pprust::pat_to_string(pat),
- cmt.repr());
+ debug!("cat_pattern: {:?} cmt={:?}",
+ pat,
+ cmt);
(*op)(self, cmt.clone(), pat);
let upvar = self.upvar();
match upvar.as_ref().map(|i| &i.cat) {
Some(&cat_upvar(ref var)) => {
- var.user_string()
+ var.to_string()
}
Some(_) => unreachable!(),
None => {
"pattern-bound indexed content".to_string()
}
cat_upvar(ref var) => {
- var.user_string()
+ var.to_string()
}
cat_downcast(ref cmt, _) => {
cmt.descriptive_string(tcx)
use syntax::visit::{FnKind, Visitor};
use syntax::feature_gate::emit_feature_err;
use util::nodemap::{DefIdMap, FnvHashSet, FnvHashMap};
-use util::ppaux::Repr;
use std::mem::replace;
tcx.sess.span_bug(e.span,
&format!("stability::check_expr: struct construction \
of non-struct, type {:?}",
- type_.repr()));
+ type_));
}
}
}
}
fn lookup_uncached<'tcx>(tcx: &ty::ctxt<'tcx>, id: DefId) -> Option<&'tcx Stability> {
- debug!("lookup(id={})", id.repr());
+ debug!("lookup(id={:?})", id);
// is this definition the implementation of a trait method?
match ty::trait_item_of_item(tcx, id) {
use middle::ty::{self, Ty};
use middle::ty_fold::{self, TypeFoldable, TypeFolder};
-use util::ppaux::Repr;
use std::fmt;
use std::iter::IntoIterator;
self.tcx().sess.span_bug(
span,
&format!("Type parameter out of range \
- when substituting in region {} (root type={}) \
+ when substituting in region {} (root type={:?}) \
(space={:?}, index={})",
- data.name.as_str(),
- self.root_ty.repr(),
+ data.name,
+ self.root_ty,
data.space,
data.index));
}
let span = self.span.unwrap_or(DUMMY_SP);
self.tcx().sess.span_bug(
span,
- &format!("Type parameter `{}` ({}/{:?}/{}) out of range \
- when substituting (root type={}) substs={}",
- p.repr(),
- source_ty.repr(),
+ &format!("Type parameter `{:?}` ({:?}/{:?}/{}) out of range \
+ when substituting (root type={:?}) substs={:?}",
+ p,
+ source_ty,
p.space,
p.idx,
- self.root_ty.repr(),
- self.substs.repr()));
+ self.root_ty,
+ self.substs));
}
};
/// 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.region_binders_passed, ty::type_has_escaping_regions(ty));
+ ty, 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());
+ debug!("shift_regions: shifted result = {:?}", result);
result
}
use middle::infer::{self, InferCtxt};
use syntax::ast;
use syntax::codemap::{DUMMY_SP, Span};
-use util::ppaux::Repr;
#[derive(Copy, Clone)]
struct InferIsLocal(bool);
-> bool
{
debug!("impl_can_satisfy(\
- impl1_def_id={}, \
- impl2_def_id={})",
- impl1_def_id.repr(),
- impl2_def_id.repr());
+ impl1_def_id={:?}, \
+ impl2_def_id={:?})",
+ impl1_def_id,
+ impl2_def_id);
let param_env = &ty::empty_parameter_environment(infcx.tcx);
let selcx = &mut SelectionContext::intercrate(infcx, param_env);
b_def_id: ast::DefId)
-> bool
{
- debug!("overlap(a_def_id={}, b_def_id={})",
- a_def_id.repr(),
- b_def_id.repr());
+ debug!("overlap(a_def_id={:?}, b_def_id={:?})",
+ a_def_id,
+ b_def_id);
let (a_trait_ref, a_obligations) = impl_trait_ref_and_oblig(selcx,
a_def_id,
b_def_id,
util::fresh_type_vars_for_impl);
- debug!("overlap: a_trait_ref={}", a_trait_ref.repr());
+ debug!("overlap: a_trait_ref={:?}", a_trait_ref);
- debug!("overlap: b_trait_ref={}", b_trait_ref.repr());
+ debug!("overlap: b_trait_ref={:?}", b_trait_ref);
// Does `a <: b` hold? If not, no overlap.
if let Err(_) = infer::mk_sub_poly_trait_refs(selcx.infcx(),
.find(|o| !selcx.evaluate_obligation(o));
if let Some(failing_obligation) = opt_failing_obligation {
- debug!("overlap: obligation unsatisfiable {}", failing_obligation.repr());
+ debug!("overlap: obligation unsatisfiable {:?}", failing_obligation);
return false
}
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());
+ debug!("trait_ref_is_knowable(trait_ref={:?})", trait_ref);
// if the orphan rules pass, that means that no ancestor crate can
// impl this, so it's up to us.
impl_def_id: ast::DefId)
-> Result<(), OrphanCheckErr<'tcx>>
{
- debug!("orphan_check({})", impl_def_id.repr());
+ debug!("orphan_check({:?})", impl_def_id);
// 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());
+ debug!("orphan_check: trait_ref={:?}", trait_ref);
// 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());
+ debug!("trait {:?} is local to current crate",
+ trait_ref.def_id);
return Ok(());
}
infer_is_local: InferIsLocal)
-> Result<(), OrphanCheckErr<'tcx>>
{
- debug!("orphan_check_trait_ref(trait_ref={}, infer_is_local={})",
- trait_ref.repr(), infer_is_local.0);
+ debug!("orphan_check_trait_ref(trait_ref={:?}, infer_is_local={})",
+ trait_ref, infer_is_local.0);
// First, create an ordered iterator over all the type parameters to the trait, with the self
// type appearing first.
// 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());
+ debug!("orphan_check_trait_ref: ty_is_local `{:?}`", input_ty);
// 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());
+ debug!("orphan_check_trait_ref: uncovered type `{:?}`", param);
return Err(OrphanCheckErr::UncoveredTy(param));
}
}
// 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());
+ debug!("orphan_check_trait_ref: uncovered type `{:?}`", param);
return Err(OrphanCheckErr::UncoveredTy(param));
}
}
infer_is_local: InferIsLocal)
-> bool
{
- debug!("ty_is_local_constructor({})", ty.repr());
+ debug!("ty_is_local_constructor({:?})", ty);
match ty.sty {
ty::TyBool |
ty::TyClosure(..) |
ty::TyError => {
tcx.sess.bug(
- &format!("ty_is_local invoked on unexpected type: {}",
- ty.repr()))
+ &format!("ty_is_local invoked on unexpected type: {:?}",
+ ty))
}
}
}
use middle::ty::{self, AsPredicate, ReferencesError, ToPolyTraitRef, TraitRef};
use middle::ty_fold::TypeFoldable;
use std::collections::HashMap;
+use std::fmt;
use syntax::codemap::{DUMMY_SP, Span};
use syntax::attr::{AttributeMethods, AttrMetaMethods};
-use util::ppaux::{Repr, UserString};
pub fn report_fulfillment_errors<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
errors: &Vec<FulfillmentError<'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(),
+ predicate,
error.err);
note_obligation_cause(infcx, obligation);
}
item.meta().span
};
let def = ty::lookup_trait_def(infcx.tcx, def_id);
- let trait_str = def.trait_ref.user_string();
+ let trait_str = def.trait_ref.to_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())
+ .to_string())
}).collect::<HashMap<String, String>>();
generic_map.insert("Self".to_string(),
- trait_ref.self_ty().user_string());
+ trait_ref.self_ty().to_string());
let parser = Parser::new(&istring);
let mut errored = false;
let err: String = parser.filter_map(|p| {
pub fn report_overflow_error<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
obligation: &Obligation<'tcx, T>)
-> !
- where T: UserString + TypeFoldable<'tcx>
+ where T: fmt::Display + 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());
+ predicate);
suggest_new_overflow_limit(infcx.tcx, obligation.cause.span);
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());;
+ obligation.predicate);;
}
_ => {
match obligation.predicate {
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(),
- trait_ref.self_ty().user_string());
+ trait_ref,
+ trait_ref.self_ty());
// 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,
&predicate).err().unwrap();
span_err!(infcx.tcx.sess, obligation.cause.span, E0278,
"the requirement `{}` is not satisfied (`{}`)",
- predicate.user_string(),
+ predicate,
err);
}
&predicate).err().unwrap();
span_err!(infcx.tcx.sess, obligation.cause.span, E0279,
"the requirement `{}` is not satisfied (`{}`)",
- predicate.user_string(),
+ predicate,
err);
}
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());
+ predicate);
}
}
}
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(),
- expected_trait_ref.user_string(),
- actual_trait_ref.user_string(),
+ expected_trait_ref.self_ty(),
+ expected_trait_ref,
+ actual_trait_ref,
e);
note_obligation_cause(infcx, obligation);
}
infcx.tcx.sess.span_note(
obligation.cause.span,
&format!("method `{}` has no receiver",
- method.name.user_string()));
+ method.name));
}
ObjectSafetyViolation::Method(method,
obligation.cause.span,
&format!("method `{}` references the `Self` type \
in its arguments or return type",
- method.name.user_string()));
+ method.name));
}
ObjectSafetyViolation::Method(method,
infcx.tcx.sess.span_note(
obligation.cause.span,
&format!("method `{}` has generic type parameters",
- method.name.user_string()));
+ method.name));
}
}
}
let predicate = infcx.resolve_type_vars_if_possible(&obligation.predicate);
- debug!("maybe_report_ambiguity(predicate={}, obligation={})",
- predicate.repr(),
- obligation.repr());
+ debug!("maybe_report_ambiguity(predicate={:?}, obligation={:?})",
+ predicate,
+ obligation);
match predicate {
ty::Predicate::Trait(ref data) => {
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());
+ self_ty);
} else {
span_err!(infcx.tcx.sess, obligation.cause.span, E0283,
"type annotations required: cannot resolve `{}`",
- predicate.user_string());;
+ predicate);;
note_obligation_cause(infcx, obligation);
}
}
"coherence failed to report ambiguity: \
cannot locate the impl of the trait `{}` for \
the type `{}`",
- trait_ref.user_string(),
- self_ty.user_string()));
+ trait_ref,
+ self_ty));
}
}
if !infcx.tcx.sess.has_errors() {
span_err!(infcx.tcx.sess, obligation.cause.span, E0284,
"type annotations required: cannot resolve `{}`",
- predicate.user_string());;
+ predicate);;
note_obligation_cause(infcx, obligation);
}
}
fn note_obligation_cause<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
obligation: &Obligation<'tcx, T>)
- where T: UserString
+ where T: fmt::Display
{
note_obligation_cause_code(infcx,
&obligation.predicate,
predicate: &T,
cause_span: Span,
cause_code: &ObligationCauseCode<'tcx>)
- where T: UserString
+ where T: fmt::Display
{
let tcx = infcx.tcx;
match *cause_code {
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());
+ parent_trait_ref.0.self_ty());
let parent_predicate = parent_trait_ref.as_predicate();
note_obligation_cause_code(infcx, &parent_predicate, cause_span, &*data.parent_code);
}
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(),
- parent_trait_ref.0.self_ty().user_string());
+ parent_trait_ref,
+ parent_trait_ref.0.self_ty());
let parent_predicate = parent_trait_ref.as_predicate();
note_obligation_cause_code(infcx, &parent_predicate, cause_span, &*data.parent_code);
}
span_note!(tcx.sess, cause_span,
"the requirement `{}` appears on the impl method \
but not on the corresponding trait method",
- predicate.user_string());
+ predicate);
}
}
}
use std::fmt;
use syntax::ast;
use util::common::ErrorReported;
-use util::ppaux::Repr;
use util::nodemap::NodeMap;
use super::CodeAmbiguity;
cause: ObligationCause<'tcx>)
-> Ty<'tcx>
{
- debug!("normalize_associated_type(projection_ty={})",
- projection_ty.repr());
+ debug!("normalize_associated_type(projection_ty={:?})",
+ projection_ty);
assert!(!projection_ty.has_escaping_regions());
self.register_predicate_obligation(infcx, obligation);
}
- debug!("normalize_associated_type: result={}", normalized.value.repr());
+ debug!("normalize_associated_type: result={:?}", normalized.value);
normalized.value
}
assert!(!obligation.has_escaping_regions());
if self.is_duplicate_or_add(infcx.tcx, &obligation.predicate) {
- debug!("register_predicate({}) -- already seen, skip", obligation.repr());
+ debug!("register_predicate({:?}) -- already seen, skip", obligation);
return;
}
- debug!("register_predicate({})", obligation.repr());
+ debug!("register_predicate({:?})", obligation);
self.predicates.push(obligation);
}
true
}
Err(selection_err) => {
- debug!("predicate: {} error: {}",
- obligation.repr(),
- selection_err.repr());
+ debug!("predicate: {:?} error: {:?}",
+ obligation,
+ selection_err);
errors.push(
FulfillmentError::new(
obligation.clone(),
ty::Predicate::Projection(ref data) => {
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(),
- result.repr());
+ debug!("process_predicate: poly_project_and_unify_type({:?}) returned {:?}",
+ project_obligation,
+ result);
match result {
Ok(Some(obligations)) => {
new_obligations.extend(obligations);
sub_region: r_b,
cause: cause };
- debug!("register_region_obligation({})",
- region_obligation.repr());
+ debug!("register_region_obligation({:?})",
+ region_obligation);
region_obligations.entry(region_obligation.cause.body_id).or_insert(vec![])
.push(region_obligation);
use std::rc::Rc;
use syntax::ast;
use syntax::codemap::{Span, DUMMY_SP};
-use util::ppaux::Repr;
pub use self::error_reporting::report_fulfillment_errors;
pub use self::error_reporting::report_overflow_error;
span: Span)
-> bool
{
- debug!("type_known_to_meet_builtin_bound(ty={}, bound={:?})",
- ty.repr(),
+ debug!("type_known_to_meet_builtin_bound(ty={:?}, bound={:?})",
+ ty,
bound);
let mut fulfill_cx = FulfillmentContext::new(false);
// assume it is move; linear is always ok.
match fulfill_cx.select_all_or_error(infcx, typer) {
Ok(()) => {
- debug!("type_known_to_meet_builtin_bound: ty={} bound={:?} success",
- ty.repr(),
+ debug!("type_known_to_meet_builtin_bound: ty={:?} bound={:?} success",
+ ty,
bound);
true
}
Err(e) => {
- debug!("type_known_to_meet_builtin_bound: ty={} bound={:?} errors={}",
- ty.repr(),
+ debug!("type_known_to_meet_builtin_bound: ty={:?} bound={:?} errors={:?}",
+ ty,
bound,
- e.repr());
+ e);
false
}
}
let span = cause.span;
let body_id = cause.body_id;
- debug!("normalize_param_env_or_error(unnormalized_env={})",
- unnormalized_env.repr());
+ debug!("normalize_param_env_or_error(unnormalized_env={:?})",
+ unnormalized_env);
let predicates: Vec<_> =
util::elaborate_predicates(tcx, unnormalized_env.caller_bounds.clone())
// constructed, but I am not currently doing so out of laziness.
// -nmatsakis
- debug!("normalize_param_env_or_error: elaborated-predicates={}",
- predicates.repr());
+ debug!("normalize_param_env_or_error: elaborated-predicates={:?}",
+ predicates);
let elaborated_env = unnormalized_env.with_caller_bounds(predicates);
-> Result<T, Vec<FulfillmentError<'tcx>>>
where T : TypeFoldable<'tcx> + HasProjectionTypes
{
- debug!("normalize_param_env(value={})", value.repr());
+ debug!("normalize_param_env(value={:?})", value);
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(),
- obligations.repr());
+ debug!("normalize_param_env: normalized_value={:?} obligations={:?}",
+ normalized_value,
+ obligations);
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());
+ debug!("normalize_param_env: resolved_value={:?}", resolved_value);
Ok(resolved_value)
}
use middle::ty::{self, ToPolyTraitRef, Ty};
use std::rc::Rc;
use syntax::ast;
-use util::ppaux::Repr;
#[derive(Debug)]
pub enum ObjectSafetyViolation<'tcx> {
result
});
- debug!("is_object_safe({}) = {}", trait_def_id.repr(), result);
+ debug!("is_object_safe({:?}) = {}", trait_def_id, result);
result
}
violations.push(ObjectSafetyViolation::SupertraitSelf);
}
- debug!("object_safety_violations_for_trait(trait_def_id={}) = {}",
- trait_def_id.repr(),
- violations.repr());
+ debug!("object_safety_violations_for_trait(trait_def_id={:?}) = {:?}",
+ trait_def_id,
+ violations);
violations
}
use middle::ty_fold::{self, TypeFoldable, TypeFolder};
use syntax::parse::token;
use util::common::FN_OUTPUT_NAME;
-use util::ppaux::Repr;
use std::fmt;
obligation: &PolyProjectionObligation<'tcx>)
-> Result<Option<Vec<PredicateObligation<'tcx>>>, MismatchedProjectionTypes<'tcx>>
{
- debug!("poly_project_and_unify_type(obligation={})",
- obligation.repr());
+ debug!("poly_project_and_unify_type(obligation={:?})",
+ obligation);
let infcx = selcx.infcx();
infcx.commit_if_ok(|snapshot| {
obligation: &ProjectionObligation<'tcx>)
-> Result<Option<Vec<PredicateObligation<'tcx>>>, MismatchedProjectionTypes<'tcx>>
{
- debug!("project_and_unify_type(obligation={})",
- obligation.repr());
+ debug!("project_and_unify_type(obligation={:?})",
+ obligation);
let Normalized { value: normalized_ty, obligations } =
match opt_normalize_projection_type(selcx,
}
};
- debug!("project_and_unify_type: normalized_ty={} obligations={}",
- normalized_ty.repr(),
- obligations.repr());
+ debug!("project_and_unify_type: normalized_ty={:?} obligations={:?}",
+ normalized_ty,
+ obligations);
let infcx = selcx.infcx();
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext<'cx,'tcx>,
obligation: &ProjectionObligation<'tcx>) {
- debug!("consider_unification_despite_ambiguity(obligation={})",
- obligation.repr());
+ debug!("consider_unification_despite_ambiguity(obligation={:?})",
+ obligation);
let def_id = obligation.predicate.projection_ty.trait_ref.def_id;
match selcx.tcx().lang_items.fn_trait_kind(def_id) {
&ty::Binder(ret_type));
debug!("consider_unification_despite_ambiguity: ret_type={:?}",
- ret_type.repr());
+ ret_type);
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
let obligation_ty = obligation.predicate.ty;
match infer::mk_eqty(infcx, true, origin, obligation_ty, ret_type) {
-> Option<NormalizedTy<'tcx>>
{
debug!("normalize_projection_type(\
- projection_ty={}, \
+ projection_ty={:?}, \
depth={})",
- projection_ty.repr(),
+ projection_ty,
depth);
let obligation = Obligation::with_depth(cause.clone(), depth, projection_ty.clone());
// an impl, where-clause etc) and hence we must
// re-normalize it
- debug!("normalize_projection_type: projected_ty={} depth={} obligations={}",
- projected_ty.repr(),
+ debug!("normalize_projection_type: projected_ty={:?} depth={} obligations={:?}",
+ projected_ty,
depth,
- obligations.repr());
+ obligations);
if ty::type_has_projection(projected_ty) {
let mut normalizer = AssociatedTypeNormalizer::new(selcx, cause, depth);
let normalized_ty = normalizer.fold(&projected_ty);
- debug!("normalize_projection_type: normalized_ty={} depth={}",
- normalized_ty.repr(),
+ debug!("normalize_projection_type: normalized_ty={:?} depth={}",
+ normalized_ty,
depth);
obligations.extend(normalizer.obligations);
}
}
Ok(ProjectedTy::NoProgress(projected_ty)) => {
- debug!("normalize_projection_type: projected_ty={} no progress",
- projected_ty.repr());
+ debug!("normalize_projection_type: projected_ty={:?} no progress",
+ projected_ty);
Some(Normalized {
value: projected_ty,
obligations: vec!()
obligation: &ProjectionTyObligation<'tcx>)
-> Result<ProjectedTy<'tcx>, ProjectionTyError<'tcx>>
{
- debug!("project(obligation={})",
- obligation.repr());
+ debug!("project(obligation={:?})",
+ obligation);
let recursion_limit = selcx.tcx().sess.recursion_limit.get();
if obligation.recursion_depth >= recursion_limit {
let obligation_trait_ref =
selcx.infcx().resolve_type_vars_if_possible(&obligation.predicate.trait_ref);
- debug!("project: obligation_trait_ref={}", obligation_trait_ref.repr());
+ debug!("project: obligation_trait_ref={:?}", obligation_trait_ref);
if obligation_trait_ref.references_error() {
return Ok(ProjectedTy::Progress(selcx.tcx().types.err, vec!()));
env_predicates: I)
where I: Iterator<Item=ty::Predicate<'tcx>>
{
- debug!("assemble_candidates_from_predicates(obligation={})",
- obligation.repr());
+ debug!("assemble_candidates_from_predicates(obligation={:?})",
+ obligation);
let infcx = selcx.infcx();
for predicate in env_predicates {
- debug!("assemble_candidates_from_predicates: predicate={}",
- predicate.repr());
+ debug!("assemble_candidates_from_predicates: predicate={:?}",
+ predicate);
match predicate {
ty::Predicate::Projection(ref data) => {
let same_name = data.item_name() == obligation.predicate.item_name;
obligation_poly_trait_ref).is_ok()
});
- debug!("assemble_candidates_from_predicates: candidate {} is_match {} same_name {}",
- data.repr(),
- is_match,
- same_name);
+ debug!("assemble_candidates_from_predicates: candidate={:?} \
+ is_match={} same_name={}",
+ data, is_match, same_name);
if is_match {
candidate_set.vec.push(
candidate_set: &mut ProjectionTyCandidateSet<'tcx>,
object_ty: Ty<'tcx>)
{
- debug!("assemble_candidates_from_object_type(object_ty={})",
- object_ty.repr());
+ debug!("assemble_candidates_from_object_type(object_ty={:?})",
+ object_ty);
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()));
+ &format!("assemble_candidates_from_object_type called with non-object: {:?}",
+ object_ty));
}
};
let projection_bounds = data.projection_bounds_with_self_ty(selcx.tcx(), object_ty);
return Ok(());
}
Err(e) => {
- debug!("assemble_candidates_from_impls: selection error {}",
- e.repr());
+ debug!("assemble_candidates_from_impls: selection error {:?}",
+ e);
return Err(e);
}
};
match vtable {
super::VtableImpl(data) => {
- debug!("assemble_candidates_from_impls: impl candidate {}",
- data.repr());
+ debug!("assemble_candidates_from_impls: impl candidate {:?}",
+ data);
candidate_set.vec.push(
ProjectionTyCandidate::Impl(data));
// These traits have no associated types.
selcx.tcx().sess.span_bug(
obligation.cause.span,
- &format!("Cannot project an associated type from `{}`",
- vtable.repr()));
+ &format!("Cannot project an associated type from `{:?}`",
+ vtable));
}
}
candidate: ProjectionTyCandidate<'tcx>)
-> (Ty<'tcx>, Vec<PredicateObligation<'tcx>>)
{
- debug!("confirm_candidate(candidate={}, obligation={})",
- candidate.repr(),
- obligation.repr());
+ debug!("confirm_candidate(candidate={:?}, obligation={:?})",
+ candidate,
+ obligation);
match candidate {
ProjectionTyCandidate::ParamEnv(poly_projection) => {
{
let tcx = selcx.tcx();
- debug!("confirm_callable_candidate({},{})",
- obligation.repr(),
- fn_sig.repr());
+ debug!("confirm_callable_candidate({:?},{:?})",
+ obligation,
+ fn_sig);
// the `Output` associated type is declared on `FnOnce`
let fn_once_def_id = tcx.lang_items.fn_once_trait().unwrap();
Err(e) => {
selcx.tcx().sess.span_bug(
obligation.cause.span,
- &format!("Failed to unify `{}` and `{}` in projection: {}",
- obligation.repr(),
- projection.repr(),
+ &format!("Failed to unify `{:?}` and `{:?}` in projection: {}",
+ obligation,
+ projection,
e));
}
}
}
selcx.tcx().sess.span_bug(obligation.cause.span,
- &format!("No associated type for {}",
- trait_ref.repr()));
+ &format!("No associated type for {:?}",
+ trait_ref));
}
impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Normalized<'tcx, T> {
use syntax::{abi, ast};
use util::common::ErrorReported;
use util::nodemap::FnvHashMap;
-use util::ppaux::Repr;
pub struct SelectionContext<'cx, 'tcx:'cx> {
infcx: &'cx InferCtxt<'cx, 'tcx>,
/// type environment by performing unification.
pub fn select(&mut self, obligation: &TraitObligation<'tcx>)
-> SelectionResult<'tcx, Selection<'tcx>> {
- debug!("select({})", obligation.repr());
+ debug!("select({:?})", obligation);
assert!(!obligation.predicate.has_escaping_regions());
let stack = self.push_stack(TraitObligationStackList::empty(), obligation);
obligation: &PredicateObligation<'tcx>)
-> bool
{
- debug!("evaluate_obligation({})",
- obligation.repr());
+ debug!("evaluate_obligation({:?})",
+ obligation);
self.evaluate_predicate_recursively(TraitObligationStackList::empty(), obligation)
.may_apply()
obligation: &PredicateObligation<'tcx>)
-> EvaluationResult<'tcx>
{
- debug!("evaluate_predicate_recursively({})",
- obligation.repr());
+ debug!("evaluate_predicate_recursively({:?})",
+ obligation);
// Check the cache from the tcx of predicates that we know
// have been proven elsewhere. This cache only contains
obligation: &TraitObligation<'tcx>)
-> EvaluationResult<'tcx>
{
- debug!("evaluate_obligation_recursively({})",
- obligation.repr());
+ debug!("evaluate_obligation_recursively({:?})",
+ obligation);
let stack = self.push_stack(previous_stack, obligation);
|prev| self.match_fresh_trait_refs(&stack.fresh_trait_ref,
&prev.fresh_trait_ref)))
{
- debug!("evaluate_stack({}) --> unbound argument, recursion --> ambiguous",
- stack.fresh_trait_ref.repr());
+ debug!("evaluate_stack({:?}) --> unbound argument, recursion --> ambiguous",
+ stack.fresh_trait_ref);
return EvaluatedToAmbig;
}
.skip(1) // skip top-most frame
.any(|prev| stack.fresh_trait_ref == prev.fresh_trait_ref)
{
- debug!("evaluate_stack({}) --> recursive",
- stack.fresh_trait_ref.repr());
+ debug!("evaluate_stack({:?}) --> recursive",
+ stack.fresh_trait_ref);
return EvaluatedToOk;
}
obligation: &TraitObligation<'tcx>)
-> bool
{
- debug!("evaluate_impl(impl_def_id={}, obligation={})",
- impl_def_id.repr(),
- obligation.repr());
+ debug!("evaluate_impl(impl_def_id={:?}, obligation={:?})",
+ impl_def_id,
+ obligation);
self.infcx.probe(|snapshot| {
match self.match_impl(impl_def_id, obligation, snapshot) {
// with fresh skolemized types starting from index 0.
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(),
- stack.repr());
+ debug!("candidate_from_obligation(cache_fresh_trait_pred={:?}, obligation={:?})",
+ cache_fresh_trait_pred,
+ stack);
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(),
- c.repr());
+ debug!("CACHE HIT: cache_fresh_trait_pred={:?}, candidate={:?}",
+ cache_fresh_trait_pred,
+ c);
return c;
}
None => { }
let candidate = self.candidate_from_obligation_no_cache(stack);
if self.should_update_candidate_cache(&cache_fresh_trait_pred, &candidate) {
- debug!("CACHE MISS: cache_fresh_trait_pred={}, candidate={}",
- cache_fresh_trait_pred.repr(), candidate.repr());
+ debug!("CACHE MISS: cache_fresh_trait_pred={:?}, candidate={:?}",
+ cache_fresh_trait_pred, candidate);
self.insert_candidate_cache(cache_fresh_trait_pred, candidate.clone());
}
let mut candidates = candidate_set.vec;
- debug!("assembled {} candidates for {}: {}",
+ debug!("assembled {} candidates for {:?}: {:?}",
candidates.len(),
- stack.repr(),
- candidates.repr());
+ stack,
+ candidates);
// At this point, we know that each of the entries in the
// candidate set is *individually* applicable. Now we have to
.any(|j| self.candidate_should_be_dropped_in_favor_of(&candidates[i],
&candidates[j]));
if is_dup {
- debug!("Dropping candidate #{}/{}: {}",
- i, candidates.len(), candidates[i].repr());
+ debug!("Dropping candidate #{}/{}: {:?}",
+ i, candidates.len(), candidates[i]);
candidates.swap_remove(i);
} else {
- debug!("Retaining candidate #{}/{}: {}",
- i, candidates.len(), candidates[i].repr());
+ debug!("Retaining candidate #{}/{}: {:?}",
+ i, candidates.len(), candidates[i]);
i += 1;
}
}
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());
+ debug!("obligation self ty is {:?}",
+ obligation.predicate.0.self_ty());
// User-defined copy impls are permitted, but only for
// structs and enums.
let poly_trait_predicate =
self.infcx().resolve_type_vars_if_possible(&obligation.predicate);
- debug!("assemble_candidates_for_projected_tys({},{})",
- obligation.repr(),
- poly_trait_predicate.repr());
+ debug!("assemble_candidates_for_projected_tys({:?},{:?})",
+ obligation,
+ poly_trait_predicate);
// FIXME(#20297) -- just examining the self-type is very simplistic
_ => { return; }
};
- debug!("assemble_candidates_for_projected_tys: trait_def_id={}",
- trait_def_id.repr());
+ debug!("assemble_candidates_for_projected_tys: trait_def_id={:?}",
+ trait_def_id);
let result = self.infcx.probe(|snapshot| {
self.match_projection_obligation_against_bounds_from_trait(obligation,
let (skol_trait_predicate, skol_map) =
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(),
- skol_map.repr());
+ skol_trait_predicate={:?} skol_map={:?}",
+ skol_trait_predicate,
+ skol_map);
let projection_trait_ref = match skol_trait_predicate.trait_ref.self_ty().sty {
ty::TyProjection(ref data) => &data.trait_ref,
self.tcx().sess.span_bug(
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()));
+ but self-ty not a projection: {:?}",
+ skol_trait_predicate.trait_ref.self_ty()));
}
};
debug!("match_projection_obligation_against_bounds_from_trait: \
- projection_trait_ref={}",
- projection_trait_ref.repr());
+ projection_trait_ref={:?}",
+ projection_trait_ref);
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());
+ bounds={:?}",
+ bounds);
let matching_bound =
util::elaborate_predicates(self.tcx(), bounds.predicates.into_vec())
snapshot)));
debug!("match_projection_obligation_against_bounds_from_trait: \
- matching_bound={}",
- matching_bound.repr());
+ matching_bound={:?}",
+ matching_bound);
match matching_bound {
None => false,
Some(bound) => {
candidates: &mut SelectionCandidateSet<'tcx>)
-> Result<(),SelectionError<'tcx>>
{
- debug!("assemble_candidates_from_caller_bounds({})",
- stack.obligation.repr());
+ debug!("assemble_candidates_from_caller_bounds({:?})",
+ stack.obligation);
let all_bounds =
self.param_env().caller_bounds
_ => { return Ok(()); }
};
- debug!("assemble_unboxed_candidates: self_ty={} kind={:?} obligation={}",
- self_ty.repr(),
+ debug!("assemble_unboxed_candidates: self_ty={:?} kind={:?} obligation={:?}",
+ self_ty,
kind,
- obligation.repr());
+ obligation);
match self.closure_typer.closure_kind(closure_def_id) {
Some(closure_kind) => {
candidates: &mut SelectionCandidateSet<'tcx>)
-> Result<(), SelectionError<'tcx>>
{
- debug!("assemble_candidates_from_impls(obligation={})", obligation.repr());
+ debug!("assemble_candidates_from_impls(obligation={:?})", obligation);
let def = ty::lookup_trait_def(self.tcx(), obligation.predicate.def_id());
{
// 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());
+ debug!("assemble_candidates_from_default_impls(self_ty={:?})", self_ty);
let def_id = obligation.predicate.def_id();
obligation: &TraitObligation<'tcx>,
candidates: &mut SelectionCandidateSet<'tcx>)
{
- debug!("assemble_candidates_from_object_ty(self_ty={})",
- self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()).repr());
+ debug!("assemble_candidates_from_object_ty(self_ty={:?})",
+ self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()));
// Object-safety candidates are only applicable to object-safe
// traits. Including this check is useful because it helps
}
};
- debug!("assemble_candidates_from_object_ty: poly_trait_ref={}",
- poly_trait_ref.repr());
+ debug!("assemble_candidates_from_object_ty: poly_trait_ref={:?}",
+ poly_trait_ref);
// 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);
let source = self.infcx.shallow_resolve(self_ty);
let target = self.infcx.shallow_resolve(obligation.predicate.0.input_types()[0]);
- debug!("assemble_candidates_for_unsizing(source={}, target={})",
- source.repr(), target.repr());
+ debug!("assemble_candidates_for_unsizing(source={:?}, target={:?})",
+ source, target);
let may_apply = match (&source.sty, &target.sty) {
// Trait+Kx+'a -> Trait+Ky+'b (upcasts).
candidate: &SelectionCandidate<'tcx>)
-> EvaluationResult<'tcx>
{
- debug!("winnow_candidate: candidate={}", candidate.repr());
+ debug!("winnow_candidate: candidate={:?}", candidate);
let result = self.infcx.probe(|_| {
let candidate = (*candidate).clone();
match self.confirm_candidate(stack.obligation, candidate) {
{
match self.builtin_bound(bound, stack.obligation) {
Ok(If(..)) => {
- debug!("builtin_bound: bound={}",
- bound.repr());
+ debug!("builtin_bound: bound={:?}",
+ bound);
candidates.vec.push(BuiltinCandidate(bound));
Ok(())
}
| ty::TyInfer(ty::FreshFloatTy(_)) => {
self.tcx().sess.bug(
&format!(
- "asked to assemble builtin bounds of unexpected type: {}",
- self_ty.repr()));
+ "asked to assemble builtin bounds of unexpected type: {:?}",
+ self_ty));
}
};
ty::TyInfer(ty::FreshFloatTy(_)) => {
self.tcx().sess.bug(
&format!(
- "asked to assemble constituent types of unexpected type: {}",
- t.repr()));
+ "asked to assemble constituent types of unexpected type: {:?}",
+ t));
}
ty::TyBox(referent_ty) => { // Box<T>
candidate: SelectionCandidate<'tcx>)
-> Result<Selection<'tcx>,SelectionError<'tcx>>
{
- debug!("confirm_candidate({}, {})",
- obligation.repr(),
- candidate.repr());
+ debug!("confirm_candidate({:?}, {:?})",
+ obligation,
+ candidate);
match candidate {
BuiltinCandidate(builtin_bound) => {
param: ty::PolyTraitRef<'tcx>)
-> Vec<PredicateObligation<'tcx>>
{
- debug!("confirm_param_candidate({},{})",
- obligation.repr(),
- param.repr());
+ debug!("confirm_param_candidate({:?},{:?})",
+ obligation,
+ param);
// During evaluation, we already checked that this
// where-clause trait-ref could be unified with the obligation
Ok(obligations) => obligations,
Err(()) => {
self.tcx().sess.bug(
- &format!("Where clause `{}` was applicable to `{}` but now is not",
- param.repr(),
- obligation.repr()));
+ &format!("Where clause `{:?}` was applicable to `{:?}` but now is not",
+ param,
+ obligation));
}
}
}
-> Result<VtableBuiltinData<PredicateObligation<'tcx>>,
SelectionError<'tcx>>
{
- debug!("confirm_builtin_candidate({})",
- obligation.repr());
+ debug!("confirm_builtin_candidate({:?})",
+ obligation);
match try!(self.builtin_bound(bound, obligation)) {
If(nested) => Ok(self.vtable_builtin_data(obligation, bound, nested)),
AmbiguousBuiltin | ParameterBuiltin => {
self.tcx().sess.span_bug(
obligation.cause.span,
- &format!("builtin bound for {} was ambig",
- obligation.repr()));
+ &format!("builtin bound for {:?} was ambig",
+ obligation));
}
}
}
let obligations = self.collect_predicates_for_types(obligation, trait_def, nested);
- debug!("vtable_builtin_data: obligations={}",
- obligations.repr());
+ debug!("vtable_builtin_data: obligations={:?}",
+ obligations);
VtableBuiltinData { nested: obligations }
}
trait_def_id: ast::DefId)
-> VtableDefaultImplData<PredicateObligation<'tcx>>
{
- debug!("confirm_default_impl_candidate({}, {})",
- obligation.repr(),
- trait_def_id.repr());
+ debug!("confirm_default_impl_candidate({:?}, {:?})",
+ obligation,
+ trait_def_id);
// binder is moved below
let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
None => {
self.tcx().sess.bug(
&format!(
- "asked to confirm default implementation for ambiguous type: {}",
- self_ty.repr()));
+ "asked to confirm default implementation for ambiguous type: {:?}",
+ self_ty));
}
}
}
trait_def_id: ast::DefId)
-> VtableDefaultImplData<PredicateObligation<'tcx>>
{
- debug!("confirm_default_impl_object_candidate({}, {})",
- obligation.repr(),
- trait_def_id.repr());
+ debug!("confirm_default_impl_object_candidate({:?}, {:?})",
+ obligation,
+ trait_def_id);
assert!(ty::has_attr(self.tcx(), trait_def_id, "rustc_reflect_like"));
_ => {
self.tcx().sess.bug(
&format!(
- "asked to confirm default object implementation for non-object type: {}",
- self_ty.repr()));
+ "asked to confirm default object implementation for non-object type: {:?}",
+ self_ty));
}
}
}
nested: ty::Binder<Vec<Ty<'tcx>>>)
-> VtableDefaultImplData<PredicateObligation<'tcx>>
{
- debug!("vtable_default_impl_data: nested={}", nested.repr());
+ debug!("vtable_default_impl_data: nested={:?}", nested);
let mut obligations = self.collect_predicates_for_types(obligation,
trait_def_id,
// no Errors in that code above
obligations.append(&mut trait_obligations.unwrap());
- debug!("vtable_default_impl_data: obligations={}", obligations.repr());
+ debug!("vtable_default_impl_data: obligations={:?}", obligations);
VtableDefaultImplData {
trait_def_id: trait_def_id,
-> Result<VtableImplData<'tcx, PredicateObligation<'tcx>>,
SelectionError<'tcx>>
{
- debug!("confirm_impl_candidate({},{})",
- obligation.repr(),
- impl_def_id.repr());
+ debug!("confirm_impl_candidate({:?},{:?})",
+ obligation,
+ impl_def_id);
// First, create the substitutions by matching the impl again,
// this time not in a probe.
let (substs, skol_map) =
self.rematch_impl(impl_def_id, obligation,
snapshot);
- debug!("confirm_impl_candidate substs={}", substs.repr());
+ debug!("confirm_impl_candidate substs={:?}", substs);
Ok(self.vtable_impl(impl_def_id, substs, obligation.cause.clone(),
obligation.recursion_depth + 1, skol_map, snapshot))
})
snapshot: &infer::CombinedSnapshot)
-> VtableImplData<'tcx, PredicateObligation<'tcx>>
{
- debug!("vtable_impl(impl_def_id={}, substs={}, recursion_depth={}, skol_map={})",
- impl_def_id.repr(),
- substs.repr(),
+ debug!("vtable_impl(impl_def_id={:?}, substs={:?}, recursion_depth={}, skol_map={:?})",
+ impl_def_id,
+ substs,
recursion_depth,
- skol_map.repr());
+ skol_map);
let mut impl_obligations =
self.impl_or_trait_obligations(cause,
skol_map,
snapshot);
- debug!("vtable_impl: impl_def_id={} impl_obligations={}",
- impl_def_id.repr(),
- impl_obligations.repr());
+ debug!("vtable_impl: impl_def_id={:?} impl_obligations={:?}",
+ impl_def_id,
+ impl_obligations);
impl_obligations.append(&mut substs.obligations);
obligation: &TraitObligation<'tcx>)
-> VtableObjectData<'tcx>
{
- debug!("confirm_object_candidate({})",
- obligation.repr());
+ debug!("confirm_object_candidate({:?})",
+ obligation);
// FIXME skipping binder here seems wrong -- we should
// probably flatten the binder from the obligation and the
obligation: &TraitObligation<'tcx>)
-> Result<ty::Ty<'tcx>,SelectionError<'tcx>>
{
- debug!("confirm_fn_pointer_candidate({})",
- obligation.repr());
+ debug!("confirm_fn_pointer_candidate({:?})",
+ obligation);
// ok to skip binder; it is reintroduced below
let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
-> Result<VtableClosureData<'tcx, PredicateObligation<'tcx>>,
SelectionError<'tcx>>
{
- debug!("confirm_closure_candidate({},{},{})",
- obligation.repr(),
- closure_def_id.repr(),
- substs.repr());
+ debug!("confirm_closure_candidate({:?},{:?},{:?})",
+ obligation,
+ closure_def_id,
+ substs);
let Normalized {
value: trait_ref,
obligations
} = self.closure_trait_ref(obligation, closure_def_id, substs);
- debug!("confirm_closure_candidate(closure_def_id={}, trait_ref={}, obligations={})",
- closure_def_id.repr(),
- trait_ref.repr(),
- obligations.repr());
+ debug!("confirm_closure_candidate(closure_def_id={:?}, trait_ref={:?}, obligations={:?})",
+ closure_def_id,
+ trait_ref,
+ obligations);
try!(self.confirm_poly_trait_refs(obligation.cause.clone(),
obligation.predicate.to_poly_trait_ref(),
ty::no_late_bound_regions(tcx, &obligation.self_ty()).unwrap());
let target = self.infcx.shallow_resolve(obligation.predicate.0.input_types()[0]);
- debug!("confirm_builtin_unsize_candidate(source={}, target={})",
- source.repr(), target.repr());
+ debug!("confirm_builtin_unsize_candidate(source={:?}, target={:?})",
+ source, target);
let mut nested = vec![];
match (&source.sty, &target.sty) {
Ok((substs, skol_map)) => (substs, skol_map),
Err(()) => {
self.tcx().sess.bug(
- &format!("Impl {} was matchable against {} but now is not",
- impl_def_id.repr(),
- obligation.repr()));
+ &format!("Impl {:?} was matchable against {:?} but now is not",
+ impl_def_id,
+ obligation));
}
}
}
obligation.recursion_depth + 1,
&impl_trait_ref);
- debug!("match_impl(impl_def_id={}, obligation={}, \
- impl_trait_ref={}, skol_obligation_trait_ref={})",
- impl_def_id.repr(),
- obligation.repr(),
- impl_trait_ref.repr(),
- skol_obligation_trait_ref.repr());
+ debug!("match_impl(impl_def_id={:?}, obligation={:?}, \
+ impl_trait_ref={:?}, skol_obligation_trait_ref={:?})",
+ impl_def_id,
+ obligation,
+ impl_trait_ref,
+ skol_obligation_trait_ref);
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
if let Err(e) = self.infcx.sub_trait_refs(false,
return Err(());
}
- debug!("match_impl: success impl_substs={}", impl_substs.repr());
+ debug!("match_impl: success impl_substs={:?}", impl_substs);
Ok((Normalized {
value: impl_substs,
obligations: impl_trait_ref.obligations
poly_trait_ref: ty::PolyTraitRef<'tcx>)
-> Result<(),()>
{
- debug!("match_poly_trait_ref: obligation={} poly_trait_ref={}",
- obligation.repr(),
- poly_trait_ref.repr());
+ debug!("match_poly_trait_ref: obligation={:?} poly_trait_ref={:?}",
+ obligation,
+ poly_trait_ref);
let origin = infer::RelateOutputImplTypes(obligation.cause.span);
match self.infcx.sub_poly_trait_refs(false,
let impl_self_ty = ty::lookup_item_type(self.tcx(), impl_def_id).ty;
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(),
- impl_self_ty.repr());
+ debug!("match_impl_self_types(obligation_self_ty={:?}, impl_self_ty={:?})",
+ obligation_self_ty,
+ impl_self_ty);
match self.match_self_types(obligation_cause,
impl_self_ty,
obligation_self_ty) {
Ok(()) => {
- debug!("Matched impl_substs={}", impl_substs.repr());
+ debug!("Matched impl_substs={:?}", impl_substs);
Ok(impl_substs)
}
Err(()) => {
snapshot: &infer::CombinedSnapshot)
-> Vec<PredicateObligation<'tcx>>
{
- debug!("impl_or_trait_obligations(def_id={})", def_id.repr());
+ debug!("impl_or_trait_obligations(def_id={:?})", def_id);
let predicates = ty::lookup_predicates(self.tcx(), def_id);
let predicates = predicates.instantiate(self.tcx(), substs);
fn upcast(&mut self, obj_trait_ref: ty::PolyTraitRef<'tcx>, obligation: &TraitObligation<'tcx>)
-> Vec<ty::PolyTraitRef<'tcx>>
{
- debug!("upcast(obj_trait_ref={}, obligation={})",
- obj_trait_ref.repr(),
- obligation.repr());
+ debug!("upcast(obj_trait_ref={:?}, obligation={:?})",
+ obj_trait_ref,
+ obligation);
let obligation_def_id = obligation.predicate.def_id();
let mut upcast_trait_refs = util::upcast(self.tcx(), obj_trait_ref, obligation_def_id);
self.infcx.probe(|_| self.match_poly_trait_ref(obligation, upcast_trait_ref)).is_ok()
});
- debug!("upcast: upcast_trait_refs={}", upcast_trait_refs.repr());
+ debug!("upcast: upcast_trait_refs={:?}", upcast_trait_refs);
upcast_trait_refs
}
}
use syntax::codemap::Span;
use util::common::ErrorReported;
use util::nodemap::FnvHashSet;
-use util::ppaux::Repr;
use super::{Obligation, ObligationCause, PredicateObligation,
VtableImpl, VtableParam, VtableImplData, VtableDefaultImplData};
.map(|p| p.subst_supertrait(self.tcx, &data.to_poly_trait_ref()))
.collect();
- debug!("super_predicates: data={} predicates={}",
- data.repr(), predicates.repr());
+ debug!("super_predicates: data={:?} predicates={:?}",
+ data, predicates);
// Only keep those bounds that we haven't already
// seen. This is necessary to prevent infinite
generic_bounds: &ty::InstantiatedPredicates<'tcx>)
-> Vec<PredicateObligation<'tcx>>
{
- debug!("predicates_for_generics(generic_bounds={})",
- generic_bounds.repr());
+ debug!("predicates_for_generics(generic_bounds={:?})",
+ generic_bounds);
generic_bounds.predicates.iter().map(|predicate| {
Obligation { cause: cause.clone(),
use middle::ty;
use middle::ty_fold::{self, TypeFoldable, TypeFolder};
use middle::ty_walk::{self, TypeWalker};
-use util::ppaux::{Repr, UserString};
use util::common::{memoized, ErrorReported};
use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet};
use util::nodemap::FnvHashMap;
tcx: &ctxt<'tcx>,
impl_def_id: DefId,
impl_trait_ref: TraitRef<'tcx>) {
- debug!("TraitDef::record_impl for {}, from {}",
- self.repr(), impl_trait_ref.repr());
+ debug!("TraitDef::record_impl for {:?}, from {:?}",
+ self, impl_trait_ref);
// 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.
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())),
+ ty)),
}
}
let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, ty, bound, span);
- debug!("type_impls_bound({}, {:?}) = {:?}",
- ty.repr(),
+ debug!("type_impls_bound({:?}, {:?}) = {:?}",
+ ty,
bound,
is_impld);
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(), ty.repr());
+ debug!("type_requires({:?}, {:?})?",
+ r_ty, ty);
let r = r_ty == ty || subtypes_require(cx, seen, r_ty, ty);
- debug!("type_requires({}, {})? {:?}",
- r_ty.repr(), ty.repr(), r);
+ debug!("type_requires({:?}, {:?})? {:?}",
+ r_ty, ty, 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(), ty.repr());
+ debug!("subtypes_require({:?}, {:?})?",
+ r_ty, ty);
let r = match ty.sty {
// fixed length vectors need special treatment compared to
}
};
- debug!("subtypes_require({}, {})? {:?}",
- r_ty.repr(), ty.repr(), r);
+ debug!("subtypes_require({:?}, {:?})? {:?}",
+ r_ty, ty, r);
return r;
}
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());
+ debug!("is_type_structurally_recursive: {:?}", ty);
match ty.sty {
TyStruct(did, _) | TyEnum(did, _) => {
match iter.next() {
Some(&seen_type) => {
if same_struct_or_enum_def_id(seen_type, did) {
- debug!("SelfRecursive: {} contains {}",
- seen_type.repr(),
- ty.repr());
+ debug!("SelfRecursive: {:?} contains {:?}",
+ seen_type,
+ ty);
return SelfRecursive;
}
}
for &seen_type in iter {
if same_type(ty, seen_type) {
- debug!("ContainsRecursive: {} contains {}",
- seen_type.repr(),
- ty.repr());
+ debug!("ContainsRecursive: {:?} contains {:?}",
+ seen_type,
+ ty);
return ContainsRecursive;
}
}
}
}
- debug!("is_type_representable: {}", ty.repr());
+ debug!("is_type_representable: {:?}", ty);
// 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(), r);
+ debug!("is_type_representable: {:?} is {:?}", ty, r);
r
}
_ => {
cx.sess.bug(
&format!("AdjustReifyFnPointer adjustment on non-fn-item: \
- {}", unadjusted_ty.repr()));
+ {:?}", unadjusted_ty));
}
}
}
span,
&format!("the {}th autoderef failed: {}",
i,
- adjusted_ty.user_string())
+ adjusted_ty)
);
}
}
pub fn ty_sort_string(cx: &ctxt, ty: Ty) -> String {
match ty.sty {
TyBool | TyChar | TyInt(_) |
- TyUint(_) | TyFloat(_) | TyStr => ty.user_string(),
- TyTuple(ref tys) if tys.is_empty() => ty.user_string(),
+ TyUint(_) | TyFloat(_) | TyStr => ty.to_string(),
+ TyTuple(ref tys) if tys.is_empty() => ty.to_string(),
TyEnum(id, _) => format!("enum `{}`", item_path_str(cx, id)),
TyBox(_) => "box".to_string(),
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();
+ let repr_type = repr_type.to_ty(cx);
span_err!(cx.sess, variant_span, E0370,
"enum discriminant overflowed on value after {}: {}; \
set explicitly via {} = {} if that is desired outcome",
-> Vec<ty::Region>
{
debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})",
- erased_self_ty.repr(),
- predicates.repr());
+ erased_self_ty,
+ predicates);
assert!(!erased_self_ty.has_escaping_regions());
return;
}
- debug!("populate_implementations_for_trait_if_necessary: searching for {}", def.repr());
+ debug!("populate_implementations_for_trait_if_necessary: searching for {:?}", def);
if csearch::is_defaulted_trait(&tcx.sess.cstore, trait_id) {
record_trait_has_default_impl(tcx, trait_id);
defs: &[TypeParameterDef<'tcx>]) {
for def in defs {
debug!("construct_parameter_environment(): push_types_from_defs: def={:?}",
- def.repr());
+ def);
let ty = ty::mk_param_from_def(tcx, def);
types.push(def.space, ty);
}
debug!("construct_parameter_environment: free_id={:?} free_subst={:?} predicates={:?}",
free_id,
- free_substs.repr(),
- predicates.repr());
+ free_substs,
+ predicates);
//
// Finally, we have to normalize the bounds in the environment, in
use syntax::ast;
use syntax::owned_slice::OwnedSlice;
use util::nodemap::FnvHashMap;
-use util::ppaux::Repr;
///////////////////////////////////////////////////////////////////////////
// Two generic traits
fn fold_region(&mut self, r: ty::Region) -> ty::Region {
match r {
ty::ReLateBound(debruijn, _) if debruijn.depth < self.current_depth => {
- debug!("RegionFolder.fold_region({}) skipped bound region (current depth={})",
- r.repr(), self.current_depth);
+ debug!("RegionFolder.fold_region({:?}) skipped bound region (current depth={})",
+ r, self.current_depth);
r
}
_ => {
- debug!("RegionFolder.fold_region({}) folding free region (current_depth={})",
- r.repr(), self.current_depth);
+ debug!("RegionFolder.fold_region({:?}) folding free region (current_depth={})",
+ r, self.current_depth);
(self.fld_r)(r, self.current_depth)
}
}
where F : FnMut(ty::BoundRegion) -> ty::Region,
T : TypeFoldable<'tcx>,
{
- debug!("replace_late_bound_regions({})", value.repr());
+ debug!("replace_late_bound_regions({:?})", value);
let mut replacer = RegionReplacer::new(tcx, &mut f);
let result = value.skip_binder().fold_with(&mut replacer);
(result, replacer.map)
fn fold_region(&mut self, r: ty::Region) -> ty::Region {
match r {
ty::ReLateBound(debruijn, br) if debruijn.depth == self.current_depth => {
- debug!("RegionReplacer.fold_region({}) folding region (current_depth={})",
- r.repr(), self.current_depth);
+ debug!("RegionReplacer.fold_region({:?}) folding region (current_depth={})",
+ r, 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 {
pub fn shift_regions<'tcx, T:TypeFoldable<'tcx>>(tcx: &ty::ctxt<'tcx>,
amount: u32, value: &T) -> T {
- debug!("shift_regions(value={}, amount={})",
- value.repr(), amount);
+ debug!("shift_regions(value={:?}, amount={})",
+ value, amount);
value.fold_with(&mut RegionFolder::new(tcx, &mut |region, _current_depth| {
shift_region(region, amount)
use middle::ty::{self, Ty};
use middle::ty_relate::{self, Relate, TypeRelation, RelateResult};
-use util::ppaux::Repr;
/// A type "A" *matches* "B" if the fresh types in B could be
/// substituted with values so as to make it equal to A. Matching is
}
fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
- debug!("{}.regions({}, {})",
+ debug!("{}.regions({:?}, {:?})",
self.tag(),
- a.repr(),
- b.repr());
+ a,
+ b);
Ok(a)
}
fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
- debug!("{}.tys({}, {})", self.tag(),
- a.repr(), b.repr());
+ debug!("{}.tys({:?}, {:?})", self.tag(),
+ a, b);
if a == b { return Ok(a); }
match (&a.sty, &b.sty) {
use std::rc::Rc;
use syntax::abi;
use syntax::ast;
-use util::ppaux::Repr;
pub type RelateResult<'tcx, T> = Result<T, ty::type_err<'tcx>>;
-> RelateResult<'tcx, ty::mt<'tcx>>
where R: TypeRelation<'a,'tcx>
{
- debug!("{}.mts({}, {})",
+ debug!("{}.mts({:?}, {:?})",
relation.tag(),
- a.repr(),
- b.repr());
+ a,
+ b);
if a.mutbl != b.mutbl {
Err(ty::terr_mutability)
} else {
-> RelateResult<'tcx, Substs<'tcx>>
where R: TypeRelation<'a,'tcx>
{
- debug!("substs: item_def_id={} a_subst={} b_subst={}",
- item_def_id.repr(),
- a_subst.repr(),
- b_subst.repr());
+ debug!("substs: item_def_id={:?} a_subst={:?} b_subst={:?}",
+ item_def_id,
+ a_subst,
+ b_subst);
let variances;
let opt_variances = if relation.tcx().variance_computed.get() {
{
let num_region_params = a_rs.len();
- debug!("relate_region_params(a_rs={}, \
- b_rs={}, variances={})",
- a_rs.repr(),
- b_rs.repr(),
- variances.repr());
+ debug!("relate_region_params(a_rs={:?}, \
+ b_rs={:?}, variances={:?})",
+ a_rs,
+ b_rs,
+ variances);
assert_eq!(num_region_params,
variances.map_or(num_region_params,
use syntax::parse::token;
use syntax::{ast, ast_util};
-/// Produces a string suitable for debugging output.
-pub trait Repr {
- fn repr(&self) -> String;
-}
-
-/// Produces a string suitable for showing to the user.
-pub trait UserString {
- fn user_string(&self) -> String;
-}
-
-impl<T: fmt::Debug> Repr for T {
- fn repr(&self) -> String {
- format!("{:?}", *self)
- }
-}
-
-impl<T: fmt::Display> UserString for T {
- fn user_string(&self) -> String {
- format!("{}", *self)
- }
-}
-
pub fn verbose() -> bool {
ty::tls::with(|tcx| tcx.sess.verbose())
}
subst::NonerasedRegions(ref regions) => {
for &r in regions {
try!(start_or_continue(f, "<", ", "));
- let s = r.user_string();
+ let s = r.to_string();
if s.is_empty() {
// This happens when the value of the region
// parameter is not easily serialized. This may be
// Region, if not obviously implied by builtin bounds.
if bounds.region_bound != ty::ReStatic {
// Region bound is implied by builtin bounds:
- let bound = bounds.region_bound.user_string();
+ let bound = bounds.region_bound.to_string();
if !bound.is_empty() {
try!(write!(f, " + {}", bound));
}
}
};
- let region_str = self.region_bound.repr();
+ let region_str = format!("{:?}", self.region_bound);
if !region_str.is_empty() {
try!(maybe_continue(f));
try!(write!(f, "{}", region_str));
}
TyRef(r, ref tm) => {
try!(write!(f, "&"));
- let s = r.user_string();
+ let s = r.to_string();
try!(write!(f, "{}", s));
if !s.is_empty() {
try!(write!(f, " "));
use rustc::middle::mem_categorization as mc;
use rustc::middle::region;
use rustc::middle::ty;
-use rustc::util::ppaux::Repr;
use syntax::ast;
use syntax::codemap::Span;
consume_span: Span,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume(consume_id={}, cmt={}, mode={:?})",
- consume_id, cmt.repr(), mode);
+ debug!("consume(consume_id={}, cmt={:?}, mode={:?})",
+ consume_id, cmt, mode);
self.consume_common(consume_id, consume_span, cmt, mode);
}
consume_pat: &ast::Pat,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})",
- consume_pat.repr(),
- cmt.repr(),
+ debug!("consume_pat(consume_pat={:?}, cmt={:?}, mode={:?})",
+ consume_pat,
+ cmt,
mode);
self.consume_common(consume_pat.id, consume_pat.span, cmt, mode);
bk: ty::BorrowKind,
loan_cause: euv::LoanCause)
{
- debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \
+ debug!("borrow(borrow_id={}, cmt={:?}, loan_region={:?}, \
bk={:?}, loan_cause={:?})",
- borrow_id, cmt.repr(), loan_region,
+ borrow_id, cmt, loan_region,
bk, loan_cause);
match opt_loan_path(&cmt) {
assignee_cmt: mc::cmt<'tcx>,
mode: euv::MutateMode)
{
- debug!("mutate(assignment_id={}, assignee_cmt={})",
- assignment_id, assignee_cmt.repr());
+ debug!("mutate(assignment_id={}, assignee_cmt={:?})",
+ assignment_id, assignee_cmt);
match opt_loan_path(&assignee_cmt) {
Some(lp) => {
//! Checks whether `old_loan` and `new_loan` can safely be issued
//! simultaneously.
- debug!("report_error_if_loans_conflict(old_loan={}, new_loan={})",
- old_loan.repr(),
- new_loan.repr());
+ debug!("report_error_if_loans_conflict(old_loan={:?}, new_loan={:?})",
+ old_loan,
+ new_loan);
// 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,
//! prohibit `loan2`. Returns false if an error is reported.
debug!("report_error_if_loan_conflicts_with_restriction(\
- loan1={}, loan2={})",
- loan1.repr(),
- loan2.repr());
+ loan1={:?}, loan2={:?})",
+ loan1,
+ loan2);
if compatible_borrow_kinds(loan1.kind, loan2.kind) {
return true;
use_path: &LoanPath<'tcx>,
borrow_kind: ty::BorrowKind)
-> UseError<'tcx> {
- debug!("analyze_restrictions_on_use(expr_id={}, use_path={})",
+ debug!("analyze_restrictions_on_use(expr_id={}, use_path={:?})",
self.tcx().map.node_to_string(expr_id),
- use_path.repr());
+ use_path);
let mut ret = UseOk;
span: Span,
use_kind: MovedValueUseKind,
lp: &Rc<LoanPath<'tcx>>) {
- debug!("check_if_path_is_moved(id={}, use_kind={:?}, lp={})",
- id, use_kind, lp.repr());
+ debug!("check_if_path_is_moved(id={}, use_kind={:?}, lp={:?})",
+ id, use_kind, lp);
// FIXME (22079): if you find yourself tempted to cut and paste
// the body below and then specializing the error reporting,
assignment_span: Span,
assignee_cmt: mc::cmt<'tcx>,
mode: euv::MutateMode) {
- debug!("check_assignment(assignee_cmt={})", assignee_cmt.repr());
+ debug!("check_assignment(assignee_cmt={:?})", assignee_cmt);
// Mutable values can be assigned, as long as they obey loans
// and aliasing restrictions:
//! `used_mut_nodes` table here.
loop {
- debug!("mark_variable_as_used_mut(cmt={})", cmt.repr());
+ debug!("mark_variable_as_used_mut(cmt={:?})", cmt);
match cmt.cat.clone() {
mc::cat_upvar(mc::Upvar { id: ty::UpvarId { var_id: id, .. }, .. }) |
mc::cat_local(id) => {
//! Safety checks related to writes to aliasable, mutable locations
let guarantor = cmt.guarantor();
- debug!("check_for_aliasable_mutable_writes(cmt={}, guarantor={})",
- cmt.repr(), guarantor.repr());
+ debug!("check_for_aliasable_mutable_writes(cmt={:?}, guarantor={:?})",
+ cmt, guarantor);
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());
use borrowck::move_data::{MoveData, MovePathIndex};
use rustc::middle::ty;
use rustc::middle::mem_categorization as mc;
-use rustc::util::ppaux::{Repr, UserString};
+
use std::mem;
use std::rc::Rc;
use syntax::ast;
impl Fragment {
fn loan_path_repr(&self, move_data: &MoveData) -> String {
- let repr = |mpi| move_data.path_loan_path(mpi).repr();
+ let lp = |mpi| move_data.path_loan_path(mpi);
match *self {
- Just(mpi) => repr(mpi),
- AllButOneFrom(mpi) => format!("$(allbutone {})", repr(mpi)),
+ Just(mpi) => format!("{:?}", lp(mpi)),
+ AllButOneFrom(mpi) => format!("$(allbutone {:?})", lp(mpi)),
}
}
fn loan_path_user_string(&self, move_data: &MoveData) -> String {
- let user_string = |mpi| move_data.path_loan_path(mpi).user_string();
+ let lp = |mpi| move_data.path_loan_path(mpi);
match *self {
- Just(mpi) => user_string(mpi),
- AllButOneFrom(mpi) => format!("$(allbutone {})", user_string(mpi)),
+ Just(mpi) => lp(mpi).to_string(),
+ AllButOneFrom(mpi) => format!("$(allbutone {})", lp(mpi)),
}
}
}
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();
+ let lp = || this.path_loan_path(*mpi);
if span_err {
- tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render()));
+ tcx.sess.span_err(sp, &format!("{}: `{}`", kind, lp()));
}
if print {
- println!("id:{} {}[{}] `{}`", id, kind, i, render());
+ println!("id:{} {}[{}] `{}`", id, kind, i, lp());
}
}
};
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()).collect()
+ mpis.iter().map(|mpi| format!("{:?}", this.path_loan_path(*mpi))).collect()
};
let frag_lps = |fs: &[Fragment]| -> Vec<String> {
let tuple_idx = match *origin_field_name {
mc::PositionalField(tuple_idx) => tuple_idx,
mc::NamedField(_) =>
- panic!("tuple type {} should not have named fields.",
- parent_ty.repr()),
+ panic!("tuple type {:?} should not have named fields.",
+ parent_ty),
};
let tuple_len = v.len();
for i in 0..tuple_len {
}
ref sty_and_variant_info => {
- let msg = format!("type {} ({:?}) is not fragmentable",
- parent_ty.repr(), sty_and_variant_info);
+ let msg = format!("type {:?} ({:?}) is not fragmentable",
+ parent_ty, 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[..])
}
};
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(), origin_lp.repr());
+ debug!("add_fragment_sibling_core(new_lp={:?}, origin_lp={:?})",
+ new_lp, origin_lp);
let mp = this.move_path(tcx, Rc::new(new_lp));
// Do not worry about checking for duplicates here; we will sort
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::InteriorOffsetKind as Kind;
use rustc::middle::ty;
-use rustc::util::ppaux::Repr;
+
use std::rc::Rc;
use syntax::ast;
use syntax::codemap::Span;
cmt: mc::cmt<'tcx>,
mode: euv::MatchMode) {
let tcx = bccx.tcx;
- debug!("gather_match_variant(move_pat={}, cmt={}, mode={:?})",
- move_pat.id, cmt.repr(), mode);
+ debug!("gather_match_variant(move_pat={}, cmt={:?}, mode={:?})",
+ move_pat.id, cmt, mode);
let opt_lp = opt_loan_path(&cmt);
match opt_lp {
move_data: &MoveData<'tcx>,
move_error_collector: &MoveErrorCollector<'tcx>,
move_info: GatherMoveInfo<'tcx>) {
- debug!("gather_move(move_id={}, cmt={})",
- move_info.id, move_info.cmt.repr());
+ debug!("gather_move(move_id={}, cmt={:?})",
+ move_info.id, move_info.cmt);
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());
+ debug!("illegal_move_origin={:?}", illegal_move_origin);
let error = MoveError::with_move_info(illegal_move_origin,
move_info.span_path_opt);
move_error_collector.add_error(error);
use rustc::middle::mem_categorization as mc;
use rustc::middle::region;
use rustc::middle::ty;
-use rustc::util::ppaux::Repr;
+
use syntax::ast;
use syntax::codemap::Span;
//! Reports error if `loan_region` is larger than S
//! where S is `item_scope` if `cmt` is an upvar,
//! and is scope of `cmt` otherwise.
- debug!("guarantee_lifetime(cmt={}, loan_region={})",
- cmt.repr(), loan_region.repr());
+ debug!("guarantee_lifetime(cmt={:?}, loan_region={:?})",
+ cmt, loan_region);
let ctxt = GuaranteeLifetimeContext {bccx: bccx,
item_scope: item_scope,
span: span,
//! Main routine. Walks down `cmt` until we find the
//! "guarantor". Reports an error if `self.loan_region` is
//! larger than scope of `cmt`.
- debug!("guarantee_lifetime.check(cmt={}, loan_region={})",
- cmt.repr(),
- self.loan_region.repr());
+ debug!("guarantee_lifetime.check(cmt={:?}, loan_region={:?})",
+ cmt,
+ self.loan_region);
match cmt.cat {
mc::cat_rvalue(..) |
use rustc::middle::mem_categorization as mc;
use rustc::middle::region;
use rustc::middle::ty;
-use rustc::util::ppaux::Repr;
+
use syntax::ast;
use syntax::codemap::Span;
use syntax::visit;
_consume_span: Span,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume(consume_id={}, cmt={}, mode={:?})",
- consume_id, cmt.repr(), mode);
+ debug!("consume(consume_id={}, cmt={:?}, mode={:?})",
+ consume_id, cmt, mode);
match mode {
euv::Move(move_reason) => {
matched_pat: &ast::Pat,
cmt: mc::cmt<'tcx>,
mode: euv::MatchMode) {
- debug!("matched_pat(matched_pat={}, cmt={}, mode={:?})",
- matched_pat.repr(),
- cmt.repr(),
+ debug!("matched_pat(matched_pat={:?}, cmt={:?}, mode={:?})",
+ matched_pat,
+ cmt,
mode);
if let mc::cat_downcast(..) = cmt.cat {
consume_pat: &ast::Pat,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})",
- consume_pat.repr(),
- cmt.repr(),
+ debug!("consume_pat(consume_pat={:?}, cmt={:?}, mode={:?})",
+ consume_pat,
+ cmt,
mode);
match mode {
bk: ty::BorrowKind,
loan_cause: euv::LoanCause)
{
- debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \
+ debug!("borrow(borrow_id={}, cmt={:?}, loan_region={:?}, \
bk={:?}, loan_cause={:?})",
- borrow_id, cmt.repr(), loan_region,
+ borrow_id, cmt, loan_region,
bk, loan_cause);
self.guarantee_valid(borrow_id,
mode: euv::MutateMode)
{
let opt_lp = opt_loan_path(&assignee_cmt);
- debug!("mutate(assignment_id={}, assignee_cmt={}) opt_lp={:?}",
- assignment_id, assignee_cmt.repr(), opt_lp);
+ debug!("mutate(assignment_id={}, assignee_cmt={:?}) opt_lp={:?}",
+ assignment_id, assignee_cmt, opt_lp);
match opt_lp {
Some(lp) => {
req_kind: ty::BorrowKind,
loan_region: ty::Region,
cause: euv::LoanCause) {
- debug!("guarantee_valid(borrow_id={}, cmt={}, \
+ debug!("guarantee_valid(borrow_id={}, cmt={:?}, \
req_mutbl={:?}, loan_region={:?})",
borrow_id,
- cmt.repr(),
+ cmt,
req_kind,
loan_region);
}
};
- debug!("guarantee_valid(borrow_id={}), loan={}",
- borrow_id, loan.repr());
+ debug!("guarantee_valid(borrow_id={}), loan={:?}",
+ borrow_id, loan);
// let loan_path = loan.loan_path;
// let loan_gen_scope = loan.gen_scope;
req_kind: ty::BorrowKind)
-> Result<(),()> {
//! Implements the M-* rules in README.md.
- debug!("check_mutability(cause={:?} cmt={} req_kind={:?}",
- cause, cmt.repr(), req_kind);
+ debug!("check_mutability(cause={:?} cmt={:?} req_kind={:?}",
+ cause, cmt, req_kind);
match req_kind {
ty::UniqueImmBorrow | ty::ImmBorrow => {
match cmt.mutbl {
pub fn gather_loans_in_static_initializer(bccx: &mut BorrowckCtxt, expr: &ast::Expr) {
- debug!("gather_loans_in_static_initializer(expr={})", expr.repr());
+ debug!("gather_loans_in_static_initializer(expr={:?})", expr);
let mut sicx = StaticInitializerCtxt {
bccx: bccx
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::InteriorOffsetKind as Kind;
use rustc::middle::ty;
-use rustc::util::ppaux::UserString;
use std::cell::RefCell;
use syntax::ast;
use syntax::codemap;
bccx.span_err(move_from.span,
&format!("cannot move out of type `{}`, \
a non-copy fixed-size array",
- b.ty.user_string()));
+ b.ty));
}
}
move_from.span,
&format!("cannot move out of type `{}`, \
which defines the `Drop` trait",
- b.ty.user_string()));
+ b.ty));
},
_ => {
bccx.span_bug(move_from.span, "this path should not cause illegal move")
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::ty;
-use rustc::util::ppaux::Repr;
use syntax::codemap::Span;
use borrowck::ToInteriorKind;
impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> {
fn restrict(&self,
cmt: mc::cmt<'tcx>) -> RestrictionResult<'tcx> {
- debug!("restrict(cmt={})", cmt.repr());
+ debug!("restrict(cmt={:?})", cmt);
let new_lp = |v: LoanPathKind<'tcx>| Rc::new(LoanPath::new(v, cmt.ty));
use rustc::middle::mem_categorization as mc;
use rustc::middle::region;
use rustc::middle::ty::{self, Ty};
-use rustc::util::ppaux::{Repr, UserString};
use std::fmt;
use std::mem;
which is {}",
ol,
moved_lp_msg,
- expr_ty.user_string(),
+ expr_ty,
suggestion));
} else {
self.tcx.sess.span_note(
&format!("`{}` moved here{} because it has type `{}`, which is {}",
ol,
moved_lp_msg,
- expr_ty.user_string(),
+ expr_ty,
suggestion));
}
}
which is moved by default",
ol,
moved_lp_msg,
- pat_ty.user_string()));
+ pat_ty));
self.tcx.sess.fileline_help(span,
"use `ref` to override");
}
has type `{}`, which is {}",
ol,
moved_lp_msg,
- expr_ty.user_string(),
+ expr_ty,
suggestion));
self.tcx.sess.fileline_help(expr_span, help);
}
let variant_str = if variant_def_id.krate == ast::LOCAL_CRATE {
ty::tls::with(|tcx| ty::item_path_str(tcx, variant_def_id))
} else {
- variant_def_id.repr()
+ format!("{:?}", variant_def_id)
};
write!(f, "({:?}{}{})", lp, DOWNCAST_PRINTED_OPERATOR, variant_str)
}
let variant_str = if variant_def_id.krate == ast::LOCAL_CRATE {
ty::tls::with(|tcx| ty::item_path_str(tcx, variant_def_id))
} else {
- variant_def_id.repr()
+ format!("{:?}", variant_def_id)
};
write!(f, "({}{}{})", lp, DOWNCAST_PRINTED_OPERATOR, variant_str)
}
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::ty;
use rustc::util::nodemap::{FnvHashMap, NodeSet};
-use rustc::util::ppaux::Repr;
+
use std::cell::RefCell;
use std::rc::Rc;
use std::usize;
}
};
- debug!("move_path(lp={}, index={:?})",
- lp.repr(),
+ debug!("move_path(lp={:?}, index={:?})",
+ lp,
index);
assert_eq!(index.get(), self.paths.borrow().len() - 1);
lp: Rc<LoanPath<'tcx>>,
id: ast::NodeId,
kind: MoveKind) {
- debug!("add_move(lp={}, id={}, kind={:?})",
- lp.repr(),
+ debug!("add_move(lp={:?}, id={}, kind={:?})",
+ lp,
id,
kind);
span: Span,
assignee_id: ast::NodeId,
mode: euv::MutateMode) {
- debug!("add_assignment(lp={}, assign_id={}, assignee_id={}",
- lp.repr(), assign_id, assignee_id);
+ debug!("add_assignment(lp={:?}, assign_id={}, assignee_id={}",
+ lp, assign_id, assignee_id);
let path_index = self.move_path(tcx, lp.clone());
};
if self.is_var_path(path_index) {
- debug!("add_assignment[var](lp={}, assignment={}, path_index={:?})",
- lp.repr(), self.var_assignments.borrow().len(), path_index);
+ debug!("add_assignment[var](lp={:?}, assignment={}, path_index={:?})",
+ lp, self.var_assignments.borrow().len(), path_index);
self.var_assignments.borrow_mut().push(assignment);
} else {
- debug!("add_assignment[path](lp={}, path_index={:?})",
- lp.repr(), path_index);
+ debug!("add_assignment[path](lp={:?}, path_index={:?})",
+ lp, path_index);
self.path_assignments.borrow_mut().push(assignment);
}
pattern_id: ast::NodeId,
base_lp: Rc<LoanPath<'tcx>>,
mode: euv::MatchMode) {
- debug!("add_variant_match(lp={}, pattern_id={})",
- lp.repr(), pattern_id);
+ debug!("add_variant_match(lp={:?}, pattern_id={})",
+ lp, pattern_id);
let path_index = self.move_path(tcx, lp.clone());
let base_path_index = self.move_path(tcx, base_lp.clone());
use rustc::middle::cfg::graphviz::LabelledCFG;
use rustc::session::Session;
use rustc::session::config::Input;
-use rustc::util::ppaux::UserString;
use rustc_borrowck as borrowck;
use rustc_borrowck::graphviz as borrowck_dot;
use rustc_resolve as resolve;
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()));
+ &ty::expr_ty(self.tcx, expr).to_string()));
s.pclose()
}
_ => Ok(())
use rustc_typeck::middle::infer::lub::Lub;
use rustc_typeck::middle::infer::glb::Glb;
use rustc_typeck::middle::infer::sub::Sub;
-use rustc_typeck::util::ppaux::{Repr, UserString};
use rustc::ast_map;
use rustc::session::{self,config};
use syntax::{abi, ast};
-> Option<ast::NodeId> {
assert!(idx < names.len());
for item in &m.items {
- if item.ident.user_string() == names[idx] {
+ if item.ident.to_string() == names[idx] {
return search(this, &**item, idx+1, names);
}
}
pub fn assert_subtype(&self, a: Ty<'tcx>, b: Ty<'tcx>) {
if !self.is_subtype(a, b) {
- panic!("{} is not a subtype of {}, but it should be",
- self.ty_to_string(a),
- self.ty_to_string(b));
+ panic!("{} is not a subtype of {}, but it should be", a, b);
}
}
self.assert_subtype(b, a);
}
- pub fn ty_to_string(&self, a: Ty<'tcx>) -> String {
- a.user_string()
- }
-
pub fn t_fn(&self,
input_tys: &[Ty<'tcx>],
output_ty: Ty<'tcx>)
match self.sub().relate(&t1, &t2) {
Ok(_) => { }
Err(ref e) => {
- panic!("unexpected error computing sub({},{}): {}",
- t1.repr(),
- t2.repr(),
+ panic!("unexpected error computing sub({:?},{:?}): {}",
+ t1,
+ t2,
e);
}
}
match self.sub().relate(&t1, &t2) {
Err(_) => { }
Ok(_) => {
- panic!("unexpected success computing sub({},{})",
- t1.repr(),
- t2.repr());
+ panic!("unexpected success computing sub({:?},{:?})",
+ t1,
+ t2);
}
}
}
/// Checks that `GLB(t1,t2) == t_glb`
pub fn check_glb(&self, t1: Ty<'tcx>, t2: Ty<'tcx>, t_glb: Ty<'tcx>) {
- debug!("check_glb(t1={}, t2={}, t_glb={})",
- self.ty_to_string(t1),
- self.ty_to_string(t2),
- self.ty_to_string(t_glb));
+ debug!("check_glb(t1={}, t2={}, t_glb={})", t1, t2, t_glb);
match self.glb().relate(&t1, &t2) {
Err(e) => {
panic!("unexpected error computing LUB: {:?}", e)
let t_resolve1 = env.infcx.shallow_resolve(t_infer1);
match t_resolve1.sty {
ty::TyRef(..) => { }
- _ => { panic!("t_resolve1={}", t_resolve1.repr()); }
+ _ => { panic!("t_resolve1={:?}", t_resolve1); }
}
})
}
env.t_fn(&[t_ptr_bound2], env.t_nil())
};
- debug!("subst_bound: t_source={} substs={} t_substituted={} t_expected={}",
- t_source.repr(),
- substs.repr(),
- t_substituted.repr(),
- t_expected.repr());
+ debug!("subst_bound: t_source={:?} substs={:?} t_substituted={:?} t_expected={:?}",
+ t_source,
+ substs,
+ t_substituted,
+ t_expected);
assert_eq!(t_substituted, t_expected);
})
env.t_pair(t_rptr_bound1, env.t_fn(&[t_rptr_bound2], env.t_nil()))
};
- debug!("subst_bound: t_source={} substs={} t_substituted={} t_expected={}",
- t_source.repr(),
- substs.repr(),
- t_substituted.repr(),
- t_expected.repr());
+ debug!("subst_bound: t_source={:?} substs={:?} t_substituted={:?} t_expected={:?}",
+ t_source,
+ substs,
+ t_substituted,
+ t_expected);
assert_eq!(t_substituted, t_expected);
})
env.t_fn(&[t_rptr_bound2], env.t_nil())
};
- debug!("subst_bound: t_source={} substs={} t_substituted={} t_expected={}",
- t_source.repr(),
- substs.repr(),
- t_substituted.repr(),
- t_expected.repr());
+ debug!("subst_bound: t_source={:?} substs={:?} t_substituted={:?} t_expected={:?}",
+ t_source,
+ substs,
+ t_substituted,
+ t_expected);
assert_eq!(t_substituted, t_expected);
})
use middle::cfg;
use rustc::ast_map;
use util::nodemap::{FnvHashMap, NodeSet};
-use util::ppaux::UserString;
use lint::{Level, Context, LintPass, LintArray, Lint};
use std::collections::{HashSet, BitSet};
});
if n_uniq > 0 {
- let s = ty.user_string();
- let m = format!("type uses owned (Box type) pointers: {}", s);
+ let m = format!("type uses owned (Box type) pointers: {}", ty);
cx.span_lint(BOX_POINTERS, span, &m[..]);
}
}
use rustc::ast_map::{PathElem, PathElems, PathName};
use trans::{CrateContext, CrateTranslation, gensym_name};
use util::common::time;
-use util::ppaux::UserString;
use util::sha2::{Digest, Sha256};
use util::fs::fix_windows_verbatim_for_gcc;
use rustc_back::tempdir::TempDir;
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())),
+ let path = [PathName(token::intern(&t.to_string())),
gensym_name(name)];
let hash = get_symbol_hash(ccx, t);
mangle(path.iter().cloned(), Some(&hash[..]))
use super::span_utils::SpanUtils;
use super::recorder::{Recorder, FmtStrs};
-use util::ppaux::UserString;
-
macro_rules! down_cast_data {
($id:ident, $kind:ident, $this:ident, $sp:expr) => {
let $id = if let super::Data::$kind(data) = $id {
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();
+ let typ = self.tcx.node_types().get(&id).unwrap().to_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,
"<mutable>".to_string()
};
let types = self.tcx.node_types();
- let typ = types.get(&id).unwrap().user_string();
+ let typ = types.get(&id).unwrap().to_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);
use syntax::visit::{self, Visitor};
use syntax::print::pprust::ty_to_string;
-use util::ppaux::UserString;
-
use self::span_utils::SpanUtils;
self.tcx.map.path_to_string(parent),
name);
let typ = self.tcx.node_types().get(&field.node.id).unwrap()
- .user_string();
+ .to_string();
let sub_span = self.span_utils.sub_span_before_token(field.span, token::Colon);
Some(Data::VariableData(VariableData {
id: field.node.id,
use session::config::{NoDebugInfo, FullDebugInfo};
use util::common::indenter;
use util::nodemap::FnvHashMap;
-use util::ppaux::{self, Repr};
+use util::ppaux;
use std;
use std::cmp::Ordering;
col: usize,
val: ValueRef)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
- debug!("expand_nested_bindings(bcx={}, m={}, col={}, val={})",
+ debug!("expand_nested_bindings(bcx={}, m={:?}, col={}, val={})",
bcx.to_str(),
- m.repr(),
+ m,
col,
bcx.val_to_string(val));
let _indenter = indenter();
-> Vec<Match<'a, 'p, 'blk, 'tcx>> where
F: FnMut(&[&'p ast::Pat]) -> Option<Vec<&'p ast::Pat>>,
{
- debug!("enter_match(bcx={}, m={}, col={}, val={})",
+ debug!("enter_match(bcx={}, m={:?}, col={}, val={})",
bcx.to_str(),
- m.repr(),
+ m,
col,
bcx.val_to_string(val));
let _indenter = indenter();
col: usize,
val: ValueRef)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
- debug!("enter_default(bcx={}, m={}, col={}, val={})",
+ debug!("enter_default(bcx={}, m={:?}, col={}, val={})",
bcx.to_str(),
- m.repr(),
+ m,
col,
bcx.val_to_string(val));
let _indenter = indenter();
variant_size: usize,
val: ValueRef)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
- debug!("enter_opt(bcx={}, m={}, opt={:?}, col={}, val={})",
+ debug!("enter_opt(bcx={}, m={:?}, opt={:?}, col={}, val={})",
bcx.to_str(),
- m.repr(),
+ m,
*opt,
col,
bcx.val_to_string(val));
-> Result<'blk, 'tcx> {
let did = langcall(cx,
None,
- &format!("comparison of `{}`",
- cx.ty_to_string(rhs_t)),
+ &format!("comparison of `{}`", rhs_t),
StrEqFnLangItem);
let t = ty::mk_str_slice(cx.tcx(), cx.tcx().mk_region(ty::ReStatic), ast::MutImmutable);
// The comparison function gets the slices by value, so we have to make copies here. Even
chk: &FailureHandler,
has_genuine_default: bool)
-> Block<'blk, 'tcx> {
- debug!("compile_guard(bcx={}, guard_expr={}, m={}, vals=[{}])",
+ debug!("compile_guard(bcx={}, guard_expr={:?}, m={:?}, vals=[{}])",
bcx.to_str(),
- bcx.expr_to_string(guard_expr),
- m.repr(),
+ guard_expr,
+ m,
vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().connect(", "));
let _indenter = indenter();
vals: &[ValueRef],
chk: &FailureHandler,
has_genuine_default: bool) {
- debug!("compile_submatch(bcx={}, m={}, vals=[{}])",
+ debug!("compile_submatch(bcx={}, m={:?}, vals=[{}])",
bcx.to_str(),
- m.repr(),
+ m,
vals.iter().map(|v| bcx.val_to_string(*v)).collect::<Vec<_>>().connect(", "));
let _indenter = indenter();
let _icx = push_ctxt("match::compile_submatch");
val: ValueRef,
cleanup_scope: cleanup::ScopeId)
-> Block<'blk, 'tcx> {
- debug!("bind_irrefutable_pat(bcx={}, pat={})",
+ debug!("bind_irrefutable_pat(bcx={}, pat={:?})",
bcx.to_str(),
- pat.repr());
+ pat);
if bcx.sess().asm_comments() {
- add_comment(bcx, &format!("bind_irrefutable_pat(pat={})",
- pat.repr()));
+ add_comment(bcx, &format!("bind_irrefutable_pat(pat={:?})",
+ pat));
}
let _indenter = indenter();
use trans::monomorphize;
use trans::type_::Type;
use trans::type_of;
-use util::ppaux::Repr as PrettyPrintRepr;
type Hint = attr::ReprAttr;
pub fn represent_type<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
t: Ty<'tcx>)
-> Rc<Repr<'tcx>> {
- debug!("Representing: {}", t.repr());
+ debug!("Representing: {}", t);
match cx.adt_reprs().borrow().get(&t) {
Some(repr) => return repr.clone(),
None => {}
General(ity, fields, dtor_to_init_u8(dtor))
}
- _ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}",
- t.repr()))
+ _ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}", t))
}
}
use trans::type_of::*;
use trans::value::Value;
use util::common::indenter;
-use util::ppaux::Repr;
use util::sha2::Sha256;
use util::nodemap::NodeMap;
match bcx.tcx().lang_items.require(it) {
Ok(id) => id,
Err(s) => {
- bcx.sess().fatal(&format!("allocation of `{}` {}",
- bcx.ty_to_string(info_ty),
- s));
+ bcx.sess().fatal(&format!("allocation of `{}` {}", info_ty, s));
}
}
}
}
}
_ => {
- cx.sess().unimpl(&format!("type in iter_structural_ty: {}",
- t.repr()))
+ cx.sess().unimpl(&format!("type in iter_structural_ty: {}", t))
}
}
return cx;
(res, false)
}
_ => {
- cx.sess().bug(&format!("fail-if-zero on unexpected type: {}",
- rhs_t.repr()));
+ cx.sess().bug(&format!("fail-if-zero on unexpected type: {}", rhs_t));
}
};
let bcx = with_cond(cx, is_zero, |bcx| {
-> FunctionContext<'a, 'tcx> {
common::validate_substs(param_substs);
- debug!("new_fn_ctxt(path={}, id={}, param_substs={})",
+ debug!("new_fn_ctxt(path={}, id={}, param_substs={:?})",
if id == !0 {
"".to_string()
} else {
ccx.tcx().map.path_to_string(id).to_string()
},
- id, param_substs.repr());
+ id, param_substs);
let uses_outptr = match output_type {
ty::FnConverging(output_type) => {
let _icx = push_ctxt("trans_closure");
attributes::emit_uwtable(llfndecl, true);
- debug!("trans_closure(..., param_substs={})",
- param_substs.repr());
+ debug!("trans_closure(..., param_substs={:?})",
+ param_substs);
let has_env = match closure_env {
closure::ClosureEnv::Closure(_) => true,
}
};
for monomorphized_arg_type in &monomorphized_arg_types {
- debug!("trans_closure: monomorphized_arg_type: {}",
- monomorphized_arg_type.repr());
+ debug!("trans_closure: monomorphized_arg_type: {:?}",
+ monomorphized_arg_type);
}
debug!("trans_closure: function lltype: {}",
bcx.fcx.ccx.tn().val_to_string(bcx.fcx.llfn));
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());
+ debug!("trans_fn(param_substs={:?})", param_substs);
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));
_ => ccx.sess().bug(
&format!("trans_enum_variant_constructor: \
unexpected ctor return type {}",
- ctor_ty.repr()))
+ ctor_ty))
};
// Get location to store the result. If the user does not care about
_ => ccx.sess().bug(
&format!("trans_enum_variant_or_tuple_like_struct: \
unexpected ctor return type {}",
- ctor_ty.repr()))
+ ctor_ty))
};
let (arena, fcx): (TypedArena<_>, FunctionContext);
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
use rustc::ast_map;
-use util::ppaux::Repr;
use syntax::abi as synabi;
use syntax::ast;
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());
+ debug!("callee::trans(expr={:?})", expr);
// pick out special kinds of expressions that can be called:
match expr.node {
bcx.tcx().sess.span_bug(
expr.span,
&format!("type of callee is neither bare-fn nor closure: {}",
- bcx.ty_to_string(datum.ty)));
+ datum.ty));
}
}
}
def: def::Def,
ref_expr: &ast::Expr)
-> Callee<'blk, 'tcx> {
- debug!("trans_def(def={}, ref_expr={})", def.repr(), ref_expr.repr());
+ debug!("trans_def(def={:?}, ref_expr={:?})", def, ref_expr);
let expr_ty = common::node_id_type(bcx, ref_expr.id);
match def {
def::DefFn(did, _) if {
let _icx = push_ctxt("trans_fn_ref");
let substs = common::node_id_substs(ccx, node, param_substs);
- debug!("trans_fn_ref(def_id={}, node={:?}, substs={})",
- def_id.repr(),
+ debug!("trans_fn_ref(def_id={:?}, node={:?}, substs={:?})",
+ def_id,
node,
- substs.repr());
+ substs);
trans_fn_ref_with_substs(ccx, def_id, node, param_substs, substs)
}
None => { }
}
- debug!("trans_fn_pointer_shim(bare_fn_ty={})",
- bare_fn_ty.repr());
+ debug!("trans_fn_pointer_shim(bare_fn_ty={:?})",
+ bare_fn_ty);
// 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.
_ => {
tcx.sess.bug(&format!("trans_fn_pointer_shim invoked on invalid type: {}",
- bare_fn_ty.repr()));
+ bare_fn_ty));
}
};
let sig = ty::erase_late_bound_regions(tcx, sig);
output: sig.output,
variadic: false
})}));
- debug!("tuple_fn_ty: {}", tuple_fn_ty.repr());
+ debug!("tuple_fn_ty: {:?}", tuple_fn_ty);
//
let function_name = link::mangle_internal_name_by_type_and_seq(ccx, bare_fn_ty,
let _icx = push_ctxt("trans_fn_ref_with_substs");
let tcx = ccx.tcx();
- debug!("trans_fn_ref_with_substs(def_id={}, node={:?}, \
- param_substs={}, substs={})",
- def_id.repr(),
+ debug!("trans_fn_ref_with_substs(def_id={:?}, node={:?}, \
+ param_substs={:?}, substs={:?})",
+ def_id,
node,
- param_substs.repr(),
- substs.repr());
+ param_substs,
+ substs);
assert!(substs.types.all(|t| !ty::type_needs_infer(*t)));
assert!(substs.types.all(|t| !ty::type_has_escaping_regions(*t)));
let new_substs = tcx.mk_substs(first_subst.subst(tcx, &substs));
debug!("trans_fn_with_vtables - default method: \
- substs = {}, trait_subst = {}, \
- first_subst = {}, new_subst = {}",
- substs.repr(), trait_ref.substs.repr(),
- first_subst.repr(), new_substs.repr());
+ substs = {:?}, trait_subst = {:?}, \
+ first_subst = {:?}, new_subst = {:?}",
+ substs, trait_ref.substs,
+ first_subst, new_substs);
(true, source_id, new_substs)
}
false
};
- debug!("trans_fn_ref_with_substs({}) must_monomorphise: {}",
- def_id.repr(), must_monomorphise);
+ debug!("trans_fn_ref_with_substs({:?}) must_monomorphise: {}",
+ def_id, must_monomorphise);
// Create a monomorphic version of generic functions
if must_monomorphise {
dest: expr::Dest)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_method_call");
- debug!("trans_method_call(call_expr={})", call_expr.repr());
+ debug!("trans_method_call(call_expr={:?})", call_expr);
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 {
let mut bcx = bcx;
let ccx = bcx.ccx();
- debug!("trans_arg_datum({})",
- formal_arg_ty.repr());
+ debug!("trans_arg_datum({:?})",
+ formal_arg_ty);
let arg_datum_ty = arg_datum.ty;
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(),
- formal_arg_ty.repr());
+ debug!("Rust types: {:?}; {:?}", arg_datum_ty,
+ formal_arg_ty);
val = PointerCast(bcx, val, llformal_arg_ty);
}
use middle::ty::{self, Ty};
use std::fmt;
use syntax::ast;
-use util::ppaux::Repr;
pub struct CleanupScope<'blk, 'tcx: 'blk> {
// The id of this cleanup scope. If the id is None,
skip_dtor: false,
};
- debug!("schedule_drop_mem({:?}, val={}, ty={}) fill_on_drop={} skip_dtor={}",
+ debug!("schedule_drop_mem({:?}, val={}, ty={:?}) fill_on_drop={} skip_dtor={}",
cleanup_scope,
self.ccx.tn().val_to_string(val),
- ty.repr(),
+ ty,
drop.fill_on_drop,
drop.skip_dtor);
skip_dtor: false,
};
- debug!("schedule_drop_and_fill_mem({:?}, val={}, ty={}, fill_on_drop={}, skip_dtor={})",
+ debug!("schedule_drop_and_fill_mem({:?}, val={}, ty={:?}, fill_on_drop={}, skip_dtor={})",
cleanup_scope,
self.ccx.tn().val_to_string(val),
- ty.repr(),
+ ty,
drop.fill_on_drop,
drop.skip_dtor);
skip_dtor: true,
};
- debug!("schedule_drop_adt_contents({:?}, val={}, ty={}) fill_on_drop={} skip_dtor={}",
+ debug!("schedule_drop_adt_contents({:?}, val={}, ty={:?}) fill_on_drop={} skip_dtor={}",
cleanup_scope,
self.ccx.tn().val_to_string(val),
- ty.repr(),
+ ty,
drop.fill_on_drop,
drop.skip_dtor);
debug!("schedule_drop_immediate({:?}, val={}, ty={:?}) fill_on_drop={} skip_dtor={}",
cleanup_scope,
self.ccx.tn().val_to_string(val),
- ty.repr(),
+ ty,
drop.fill_on_drop,
drop.skip_dtor);
use middle::ty::{self, ClosureTyper};
use middle::subst::Substs;
use session::config::FullDebugInfo;
-use util::ppaux::Repr;
use syntax::abi::RustCall;
use syntax::ast;
llreffn: ValueRef)
-> ValueRef
{
- debug!("trans_fn_once_adapter_shim(closure_def_id={}, substs={}, llreffn={})",
- closure_def_id.repr(),
- substs.repr(),
+ debug!("trans_fn_once_adapter_shim(closure_def_id={:?}, substs={:?}, llreffn={})",
+ closure_def_id,
+ substs,
ccx.tn().val_to_string(llreffn));
let tcx = ccx.tcx();
abi: abi,
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());
+ debug!("trans_fn_once_adapter_shim: llref_fn_ty={:?}",
+ llref_fn_ty);
// Make a version of the closure type with the same arguments, but
// with argument #0 being by value.
let input_tys = match sig.inputs[1].sty {
ty::TyTuple(ref tys) => &**tys,
_ => bcx.sess().bug(&format!("trans_fn_once_adapter_shim: not rust-call! \
- closure_def_id={}",
- closure_def_id.repr()))
+ closure_def_id={:?}",
+ closure_def_id))
};
let llargs: Vec<_> =
input_tys.iter()
use middle::ty_fold;
use middle::ty_fold::{TypeFolder, TypeFoldable};
use rustc::ast_map::{PathElem, PathName};
-use util::ppaux::Repr;
use util::nodemap::{FnvHashMap, NodeMap};
use arena::TypedArena;
where T : TypeFoldable<'tcx>
{
let value1 = value.fold_with(&mut RegionEraser(cx));
- debug!("erase_regions({}) = {}",
- value.repr(), value1.repr());
+ debug!("erase_regions({:?}) = {:?}",
+ value, value1);
return value1;
struct RegionEraser<'a, 'tcx: 'a>(&'a 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(), contents);
+ debug!("type_needs_drop ty={:?} contents={:?}", ty, contents);
contents.needs_drop(cx)
}
self.tcx().map.node_to_string(id).to_string()
}
- pub fn expr_to_string(&self, e: &ast::Expr) -> String {
- e.repr()
- }
-
pub fn def(&self, nid: ast::NodeId) -> def::Def {
match self.tcx().def_map.borrow().get(&nid) {
Some(v) => v.full_def(),
self.ccx().tn().type_to_string(ty)
}
- pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
- t.repr()
- }
-
pub fn to_str(&self) -> String {
format!("[block {:p}]", self)
}
// First check the cache.
match ccx.trait_cache().borrow().get(&trait_ref) {
Some(vtable) => {
- info!("Cache hit: {}", trait_ref.repr());
+ info!("Cache hit: {:?}", trait_ref);
return (*vtable).clone();
}
None => { }
}
- debug!("trans fulfill_obligation: trait_ref={} def_id={:?}",
- trait_ref.repr(), trait_ref.def_id());
+ debug!("trans fulfill_obligation: trait_ref={:?} def_id={:?}",
+ trait_ref, trait_ref.def_id());
ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id());
let infcx = infer::new_infer_ctxt(tcx);
// leading to an ambiguous result. So report this as an
// overflow bug, since I believe this is the only case
// where ambiguity can result.
- debug!("Encountered ambiguity selecting `{}` during trans, \
+ debug!("Encountered ambiguity selecting `{:?}` during trans, \
presuming due to overflow",
- trait_ref.repr());
+ trait_ref);
ccx.sess().span_fatal(
span,
"reached the recursion limit during monomorphization");
Err(e) => {
tcx.sess.span_bug(
span,
- &format!("Encountered error `{}` selecting `{}` during trans",
- e.repr(),
- trait_ref.repr()))
+ &format!("Encountered error `{:?}` selecting `{:?}` during trans",
+ e,
+ trait_ref))
}
};
});
let vtable = drain_fulfillment_cx_or_panic(span, &infcx, &mut fulfill_cx, &vtable);
- info!("Cache miss: {}", trait_ref.repr());
+ info!("Cache miss: {:?}", trait_ref);
ccx.trait_cache().borrow_mut().insert(trait_ref,
vtable.clone());
predicates: Vec<ty::Predicate<'tcx>>)
-> bool
{
- debug!("normalize_and_test_predicates(predicates={})",
- predicates.repr());
+ debug!("normalize_and_test_predicates(predicates={:?})",
+ predicates);
let tcx = ccx.tcx();
let infcx = infer::new_infer_ctxt(tcx);
Err(errors) => {
infcx.tcx.sess.span_bug(
span,
- &format!("Encountered errors `{}` fulfilling during trans",
- errors.repr()));
+ &format!("Encountered errors `{:?}` fulfilling during trans",
+ errors));
}
}
}
-> StdResult<T,Vec<traits::FulfillmentError<'tcx>>>
where T : TypeFoldable<'tcx>
{
- debug!("drain_fulfillment_cx(result={})",
- result.repr());
+ debug!("drain_fulfillment_cx(result={:?})",
+ result);
// In principle, we only need to do this so long as `result`
// contains unbound type parameters. It could be a slight
if substs.types.any(|t| ty::type_needs_infer(*t)) {
tcx.sess.bug(&format!("type parameters for node {:?} include inference types: {:?}",
- node, substs.repr()));
+ node, substs));
}
monomorphize::apply_param_substs(tcx,
use middle::cast::{CastTy,IntTy};
use middle::subst::Substs;
use middle::ty::{self, Ty};
-use util::ppaux::Repr;
use util::nodemap::NodeMap;
use std::iter::repeat;
C_integral(Type::uint_from_ty(cx, t), i as u64, false)
}
_ => cx.sess().span_bug(lit.span,
- &format!("integer literal has type {} (expected int \
+ &format!("integer literal has type {:?} (expected int \
or usize)",
- lit_int_ty.repr()))
+ lit_int_ty))
}
}
ast::LitFloat(ref fs, t) => {
}
}
None => {
- cx.sess().bug(&format!("unexpected dereferenceable type {}",
- ty.repr()))
+ cx.sess().bug(&format!("unexpected dereferenceable type {:?}",
+ ty))
}
}
}
llvm::LLVMDumpValue(llconst);
llvm::LLVMDumpValue(C_undef(llty));
}
- cx.sess().bug(&format!("const {} of type {} has size {} instead of {}",
- e.repr(), ety_adjusted.repr(),
+ cx.sess().bug(&format!("const {:?} of type {:?} has size {} instead of {}",
+ e, ety_adjusted,
csize, tsize));
}
(llconst, ety_adjusted)
fn_args: FnArgMap)
-> ValueRef
{
- debug!("const_expr_unadjusted(e={}, ety={}, param_substs={})",
- e.repr(),
- ety.repr(),
- param_substs.repr());
+ debug!("const_expr_unadjusted(e={:?}, ety={:?}, param_substs={:?})",
+ e,
+ ety,
+ param_substs);
let map_list = |exprs: &[P<ast::Expr>]| -> Vec<ValueRef> {
exprs.iter()
/* Neither type is bottom, and we expect them to be unified
* already, so the following is safe. */
let (te1, ty) = const_expr(cx, &**e1, param_substs, fn_args);
- debug!("const_expr_unadjusted: te1={}, ty={}",
+ debug!("const_expr_unadjusted: te1={}, ty={:?}",
cx.tn().val_to_string(te1),
- ty.repr());
+ ty);
let is_simd = ty::type_is_simd(cx.tcx(), ty);
let intype = if is_simd {
ty::simd_type(cx.tcx(), ty)
},
_ => cx.sess().span_bug(base.span,
&format!("index-expr base must be a vector \
- or string type, found {}",
- bt.repr()))
+ or string type, found {:?}",
+ bt))
},
_ => cx.sess().span_bug(base.span,
&format!("index-expr base must be a vector \
- or string type, found {}",
- bt.repr()))
+ or string type, found {:?}",
+ bt))
};
let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
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(), t_cast.repr());
+ debug!("trans_const_cast({:?} as {:?})", t_expr, t_cast);
if expr::cast_is_noop(cx.tcx(), base, t_expr, t_cast) {
return v;
}
use middle::ty::{self, Ty};
use session::config::NoDebugInfo;
use session::Session;
-use util::ppaux::Repr;
use util::sha2::Sha256;
use util::nodemap::{NodeMap, NodeSet, DefIdMap, FnvHashMap, FnvHashSet};
pub fn report_overbig_object(&self, obj: Ty<'tcx>) -> ! {
self.sess().fatal(
- &format!("the type `{}` is too big for the current architecture",
- obj.repr()))
+ &format!("the type `{:?}` is too big for the current architecture",
+ obj))
}
pub fn check_overflow(&self) -> bool {
use trans::expr;
use trans;
use middle::ty;
-use util::ppaux::Repr;
use syntax::ast;
use syntax::ast_util;
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_stmt");
let fcx = cx.fcx;
- debug!("trans_stmt({})", s.repr());
+ debug!("trans_stmt({:?})", s);
if cx.unreachable.get() {
return cx;
}
if cx.sess().asm_comments() {
- add_span_comment(cx, s.span, &s.repr());
+ add_span_comment(cx, s.span, &format!("{:?}", s));
}
let mut bcx = cx;
els: Option<&ast::Expr>,
dest: expr::Dest)
-> Block<'blk, 'tcx> {
- debug!("trans_if(bcx={}, if_id={}, cond={}, thn={}, dest={})",
- bcx.to_str(), if_id, bcx.expr_to_string(cond), thn.id,
+ debug!("trans_if(bcx={}, if_id={}, cond={:?}, thn={}, dest={})",
+ bcx.to_str(), if_id, cond, thn.id,
dest.to_string(bcx.ccx()));
let _icx = push_ctxt("trans_if");
use trans::tvec;
use trans::type_of;
use middle::ty::{self, Ty};
-use util::ppaux::Repr;
use std::fmt;
use syntax::ast;
#[allow(dead_code)] // useful for debugging
pub fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String {
- format!("Datum({}, {}, {:?})",
+ format!("Datum({}, {:?}, {:?})",
ccx.tn().val_to_string(self.val),
- self.ty.repr(),
+ self.ty,
self.kind)
}
use middle::ty::{self, Ty, ClosureTyper};
use session::config::{self, FullDebugInfo};
use util::nodemap::FnvHashMap;
-use util::ppaux::{Repr, UserString};
use util::common::path2cstr;
use libc::{c_uint, c_longlong};
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()));
+ type_));
}
}
&mut unique_type_id);
},
_ => {
- cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
- type_.repr(), type_.sty))
+ cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {:?}",
+ type_))
}
};
if type_map.find_metadata_for_unique_id(unique_type_id).is_none() ||
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())
+ '{:?}' was not found in TypeMap!",
+ unfinished_type)
);
}
}
ty::TyTrait(ref data) => data.principal_def_id(),
_ => {
cx.sess().bug(&format!("debuginfo: Unexpected trait-object type in \
- trait_pointer_metadata(): {}",
- trait_type.repr()));
+ trait_pointer_metadata(): {:?}",
+ trait_type));
}
};
the debuginfo::TypeMap but it \
was not. (Ty = {})",
&unique_type_id_str[..],
- t.user_string());
+ t);
cx.sess().span_bug(usage_site_span, &error_message[..]);
}
};
debuginfo::TypeMap. \
UniqueTypeId={}, Ty={}",
&unique_type_id_str[..],
- t.user_string());
+ t);
cx.sess().span_bug(usage_site_span, &error_message[..]);
}
}
use trans::common::CrateContext;
use middle::subst::{self, Substs};
use middle::ty::{self, Ty, ClosureTyper};
-use util::ppaux::Repr;
use syntax::ast;
use syntax::parse::token;
ty::TyProjection(..) |
ty::TyParam(_) => {
cx.sess().bug(&format!("debuginfo: Trying to create type name for \
- unexpected type: {}", t.repr()));
+ unexpected type: {:?}", t));
}
}
use trans::monomorphize;
use trans::type_::Type;
use trans::type_of;
-use util::ppaux::Repr;
use std::ffi::CString;
use libc::c_uint;
/// update the declaration and return existing ValueRef instead.
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());
+ debug!("declare_rust_fn(name={:?}, fn_type={:?})", name,
+ fn_type);
let fn_type = monomorphize::normalize_associated_type(ccx.tcx(), &fn_type);
- debug!("declare_rust_fn (after normalised associated types) fn_type={}",
- fn_type.repr());
+ debug!("declare_rust_fn (after normalised associated types) fn_type={:?}",
+ fn_type);
let function_type; // placeholder so that the memory ownership works out ok
let (sig, abi, env) = match fn_type.sty {
function_type = typer.closure_type(closure_did, substs);
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(), self_type.repr());
+ debug!("declare_rust_fn function_type={:?} self_type={:?}",
+ function_type, self_type);
(&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());
+ debug!("declare_rust_fn (after region erasure) sig={:?}", sig);
let llfty = type_of::type_of_rust_fn(ccx, env, &sig, abi);
debug!("declare_rust_fn llfty={}", ccx.tn().type_to_string(llfty));
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
use util::common::indenter;
-use util::ppaux::Repr;
use trans::machine::{llsize_of, llsize_of_alloc};
use trans::type_::Type;
}
}
- debug!("trans_into() expr={}", expr.repr());
+ debug!("trans_into() expr={:?}", expr);
let cleanup_debug_loc = debuginfo::get_cleanup_debug_loc_for_ast_node(bcx.ccx(),
expr.id,
pub fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
expr: &ast::Expr)
-> DatumBlock<'blk, 'tcx, Expr> {
- debug!("trans(expr={})", bcx.expr_to_string(expr));
+ debug!("trans(expr={:?})", expr);
let mut bcx = bcx;
let fcx = bcx.fcx;
consts::ptrcast(meth::get_vtable(ccx, trait_ref, param_substs),
Type::vtable_ptr(ccx))
}
- _ => ccx.sess().bug(&format!("unsized_info: invalid unsizing {} -> {}",
- source.repr(),
- target.repr()))
+ _ => ccx.sess().bug(&format!("unsized_info: invalid unsizing {:?} -> {:?}",
+ source,
+ target))
}
}
}
Some(adj) => { adj }
};
- debug!("unadjusted datum for expr {}: {} adjustment={:?}",
- expr.repr(),
+ debug!("unadjusted datum for expr {:?}: {} adjustment={:?}",
+ expr,
datum.to_string(bcx.ccx()),
adjustment);
match adjustment {
ty::custom_coerce_unsized_kind(bcx.tcx(), impl_def_id)
}
vtable => {
- bcx.sess().span_bug(span, &format!("invalid CoerceUnsized vtable: {}",
- vtable.repr()));
+ bcx.sess().span_bug(span, &format!("invalid CoerceUnsized vtable: {:?}",
+ vtable));
}
};
}
}
}
- _ => bcx.sess().bug(&format!("coerce_unsized: invalid coercion {} -> {}",
- source.ty.repr(),
- target.ty.repr()))
+ _ => bcx.sess().bug(&format!("coerce_unsized: invalid coercion {:?} -> {:?}",
+ source.ty,
+ target.ty))
}
bcx
}
-> DatumBlock<'blk, 'tcx, Expr> {
let mut bcx = bcx;
- debug!("trans_unadjusted(expr={})", bcx.expr_to_string(expr));
+ debug!("trans_unadjusted(expr={:?})", expr);
let _indenter = indenter();
debuginfo::set_source_location(bcx.fcx, expr.id, expr.span);
}
_ => {
ccx.tcx().sess.span_bug(ref_expr.span, &format!(
- "trans_def_fn_unadjusted invoked on: {:?} for {}",
+ "trans_def_fn_unadjusted invoked on: {:?} for {:?}",
def,
- ref_expr.repr()));
+ ref_expr));
}
}
}
}
};
debug!("take_local(nid={}, v={}, ty={})",
- nid, bcx.val_to_string(datum.val), bcx.ty_to_string(datum.ty));
+ nid, bcx.val_to_string(datum.val), datum.ty);
datum
}
_ => {
match node_id_opt {
None => {
tcx.sess.bug(&format!(
- "cannot get field types from the enum type {} \
+ "cannot get field types from the enum type {:?} \
without a node ID",
- ty.repr()));
+ ty));
}
Some(node_id) => {
let def = tcx.def_map.borrow().get(&node_id).unwrap().full_def();
_ => {
tcx.sess.bug(&format!(
- "cannot get field types from the type {}",
- ty.repr()));
+ "cannot get field types from the type {:?}",
+ ty));
}
}
}
let t_in = expr_ty_adjusted(bcx, expr);
let t_out = node_id_type(bcx, id);
- debug!("trans_cast({} as {})", t_in.repr(), t_out.repr());
+ debug!("trans_cast({:?} as {:?})", t_in, t_out);
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
_ => ccx.sess().span_bug(expr.span,
&format!("translating unsupported cast: \
- {} -> {}",
- t_in.repr(),
- t_out.repr())
+ {:?} -> {:?}",
+ t_in,
+ t_out)
)
};
return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock();
let _icx = push_ctxt("trans_assign_op");
let mut bcx = bcx;
- debug!("trans_assign_op(expr={})", bcx.expr_to_string(expr));
+ debug!("trans_assign_op(expr={:?})", expr);
// User-defined operator methods cannot be used with `+=` etc right now
assert!(!bcx.tcx().method_map.borrow().contains_key(&MethodCall::expr(expr.id)));
-> DatumBlock<'blk, 'tcx, Expr> {
let ccx = bcx.ccx();
- debug!("deref_once(expr={}, datum={}, method_call={:?})",
- expr.repr(),
+ debug!("deref_once(expr={:?}, datum={}, method_call={:?})",
+ expr,
datum.to_string(ccx),
method_call);
_ => {
bcx.tcx().sess.span_bug(
expr.span,
- &format!("deref invoked on expr of illegal type {}",
- datum.ty.repr()));
+ &format!("deref invoked on expr of illegal type {:?}",
+ datum.ty));
}
};
use syntax::ast;
use syntax::attr;
use syntax::print::pprust;
-use util::ppaux::Repr;
///////////////////////////////////////////////////////////////////////////
// Type definitions
pub fn register_foreign_item_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
abi: Abi, fty: Ty<'tcx>,
name: &str) -> ValueRef {
- debug!("register_foreign_item_fn(abi={}, \
- ty={}, \
+ debug!("register_foreign_item_fn(abi={:?}, \
+ ty={:?}, \
name={})",
- abi.repr(),
- fty.repr(),
+ abi,
+ fty,
name);
let cc = llvm_calling_convention(ccx, abi);
{
let ccx = bcx.ccx();
- debug!("trans_native_call(callee_ty={}, \
+ debug!("trans_native_call(callee_ty={:?}, \
llfn={}, \
llretptr={})",
- callee_ty.repr(),
+ callee_ty,
ccx.tn().val_to_string(llfn),
ccx.tn().val_to_string(llretptr));
assert!(f.abi != Rust && f.abi != RustIntrinsic);
}
_ => {
- ccx.sess().bug(&format!("build_rust_fn: extern fn {} has ty {}, \
+ 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()));
+ t));
}
};
- debug!("build_rust_fn: path={} id={} t={}",
+ debug!("build_rust_fn: path={} id={} t={:?}",
ccx.tcx().map.path_to_string(id),
- id, t.repr());
+ id, t);
let llfn = declare::define_internal_rust_fn(ccx, &ps[..], t).unwrap_or_else(||{
ccx.sess().bug(&format!("symbol `{}` already defined", ps));
let _icx = push_ctxt(
"foreign::trans_rust_fn_with_foreign_abi::build_wrap_fn");
- debug!("build_wrap_fn(llrustfn={}, llwrapfn={}, t={})",
+ debug!("build_wrap_fn(llrustfn={}, llwrapfn={}, t={:?})",
ccx.tn().val_to_string(llrustfn),
ccx.tn().val_to_string(llwrapfn),
- t.repr());
+ t);
// Avoid all the Rust generation stuff and just generate raw
// LLVM here.
debug!("out pointer, \
allocad={}, \
llrust_ret_ty={}, \
- return_ty={}",
+ return_ty={:?}",
ccx.tn().val_to_string(slot),
ccx.tn().type_to_string(llrust_ret_ty),
- tys.fn_sig.output.repr());
+ tys.fn_sig.output);
llrust_args.push(slot);
return_alloca = Some(slot);
}
}
// Perform the call itself
- debug!("calling llrustfn = {}, t = {}",
- ccx.tn().val_to_string(llrustfn), t.repr());
+ debug!("calling llrustfn = {}, t = {:?}",
+ ccx.tn().val_to_string(llrustfn), t);
let attributes = attributes::from_fn_type(ccx, t);
let llrust_ret_val = builder.call(llrustfn, &llrust_args, Some(attributes));
llsig.llret_ty,
llsig.ret_def);
debug!("foreign_types_for_fn_ty(\
- ty={}, \
+ ty={:?}, \
llsig={} -> {}, \
fn_ty={} -> {}, \
ret_def={}",
- ty.repr(),
+ ty,
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<_>>()),
use trans::monomorphize;
use trans::type_of::{type_of, type_of_dtor, sizing_type_of, align_of};
use trans::type_::Type;
-use util::ppaux::Repr;
use arena::TypedArena;
use libc::c_uint;
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(), skip_dtor);
+ debug!("drop_ty_core(t={:?}, skip_dtor={})", t, skip_dtor);
let _icx = push_ctxt("drop_ty");
if bcx.fcx.type_needs_drop(t) {
let ccx = bcx.ccx();
fn get_drop_glue_core<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
g: DropGlueKind<'tcx>) -> ValueRef {
- debug!("make drop glue for {}", g.repr());
+ debug!("make drop glue for {:?}", g);
let g = g.map_ty(|t| get_drop_glue_type(ccx, t));
- debug!("drop glue type {}", g.repr());
+ debug!("drop glue type {:?}", g);
match ccx.drop_glues().borrow().get(&g) {
Some(&glue) => return glue,
_ => { }
});
ccx.available_drop_glues().borrow_mut().insert(g, fn_nm);
- let _s = StatRecorder::new(ccx, format!("drop {}", t.repr()));
+ let _s = StatRecorder::new(ccx, format!("drop {:?}", t));
let empty_substs = ccx.tcx().mk_substs(Substs::trans_empty());
let (arena, fcx): (TypedArena<_>, FunctionContext);
substs: &subst::Substs<'tcx>)
-> Block<'blk, 'tcx>
{
- debug!("trans_struct_drop t: {}", bcx.ty_to_string(t));
+ debug!("trans_struct_drop t: {}", t);
// Find and call the actual destructor
let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did, t, class_did, substs);
pub fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, info: ValueRef)
-> (ValueRef, ValueRef) {
debug!("calculate size of DST: {}; with lost info: {}",
- bcx.ty_to_string(t), bcx.val_to_string(info));
+ t, bcx.val_to_string(info));
if type_is_sized(bcx.tcx(), t) {
let sizing_type = sizing_type_of(bcx.ccx(), t);
let size = C_uint(bcx.ccx(), llsize_of_alloc(bcx.ccx(), sizing_type));
(Mul(bcx, info, C_uint(bcx.ccx(), unit_size), DebugLoc::None),
C_uint(bcx.ccx(), unit_align))
}
- _ => bcx.sess().bug(&format!("Unexpected unsized type, found {}",
- bcx.ty_to_string(t)))
+ _ => bcx.sess().bug(&format!("Unexpected unsized type, found {}", t))
}
}
// stupid and dangerous.
bcx.sess().warn(&format!("Ignoring drop flag in destructor for {}\
because the struct is unsized. See issue\
- #16758",
- bcx.ty_to_string(t)));
+ #16758", t));
trans_struct_drop(bcx, t, v0, dtor, did, substs)
}
}
use syntax::abi::RustIntrinsic;
use syntax::ast;
use syntax::parse::token;
-use util::ppaux::{Repr, UserString};
pub fn get_simple_intrinsic(ccx: &CrateContext, item: &ast::ForeignItem) -> Option<ValueRef> {
let name = match &token::get_ident(item.ident)[..] {
continue;
}
- debug!("transmute_restriction: {}", transmute_restriction.repr());
+ debug!("transmute_restriction: {:?}", transmute_restriction);
assert!(!ty::type_has_params(transmute_restriction.substituted_from));
assert!(!ty::type_has_params(transmute_restriction.substituted_to));
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(),
+ transmute_restriction.original_from,
from_type_size as usize,
if from_type_size == 1 {""} else {"s"},
- transmute_restriction.original_to.user_string(),
+ transmute_restriction.original_to,
to_type_size as usize,
if to_type_size == 1 {""} else {"s"}));
} else {
transmute_restriction.span,
&format!("transmute called on types with different sizes: \
{} ({} bit{}) to {} ({} bit{})",
- transmute_restriction.original_from.user_string(),
+ transmute_restriction.original_from,
from_type_size as usize,
if from_type_size == 1 {""} else {"s"},
- transmute_restriction.original_to.user_string(),
+ transmute_restriction.original_to,
to_type_size as usize,
if to_type_size == 1 {""} else {"s"}));
}
}
(_, "type_name") => {
let tp_ty = *substs.types.get(FnSpace, 0);
- let ty_name = token::intern_and_get_ident(&tp_ty.user_string());
+ let ty_name = token::intern_and_get_ident(&tp_ty.to_string());
C_str_slice(ccx, ty_name)
}
(_, "type_id") => {
use trans::type_of::*;
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
-use util::ppaux::Repr;
use syntax::abi::{Rust, RustCall};
use syntax::parse::token;
}) => {
let trait_ref = ty::Binder(bcx.monomorphize(trait_ref));
let span = bcx.tcx().map.span(method_call.expr_id);
- debug!("method_call={:?} trait_ref={} trait_ref id={:?} substs={:?}",
+ debug!("method_call={:?} trait_ref={:?} trait_ref id={:?} substs={:?}",
method_call,
- trait_ref.repr(),
+ trait_ref,
trait_ref.0.def_id,
trait_ref.0.substs);
let origin = fulfill_obligation(bcx.ccx(),
span,
trait_ref.clone());
- debug!("origin = {}", origin.repr());
+ debug!("origin = {:?}", origin);
trans_monomorphized_callee(bcx,
method_call,
trait_ref.def_id(),
rcvr_self,
Vec::new()));
let trait_substs = tcx.mk_substs(trait_substs);
- debug!("trait_substs={}", trait_substs.repr());
+ debug!("trait_substs={:?}", trait_substs);
let trait_ref = ty::Binder(ty::TraitRef { def_id: trait_id,
substs: trait_substs });
let vtbl = fulfill_obligation(ccx,
immediate_rvalue(llfn, ty)
}
_ => {
- tcx.sess.bug(&format!("static call to invalid vtable: {}",
- vtbl.repr()));
+ tcx.sess.bug(&format!("static call to invalid vtable: {:?}",
+ vtbl));
}
}
}
traits::VtableDefaultImpl(..) |
traits::VtableParam(..) => {
bcx.sess().bug(
- &format!("resolved vtable bad vtable {} in trans",
- vtable.repr()));
+ &format!("resolved vtable bad vtable {:?} in trans",
+ vtable));
}
}
}
let node_substs = node_id_substs(ccx, node, bcx.fcx.param_substs);
- debug!("rcvr_substs={}", rcvr_substs.repr());
- debug!("node_substs={}", node_substs.repr());
+ debug!("rcvr_substs={:?}", rcvr_substs);
+ debug!("node_substs={:?}", node_substs);
// Break apart the type parameters from the node and type
// parameters from the receiver.
// Load the data pointer from the object.
debug!("trans_trait_callee_from_llval(callee_ty={}, vtable_index={}, llpair={})",
- callee_ty.repr(),
+ callee_ty,
vtable_index,
bcx.val_to_string(llpair));
let llboxptr = GEPi(bcx, llpair, &[0, abi::FAT_PTR_ADDR]);
let tcx = ccx.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(),
- upcast_trait_ref.repr(),
+ debug!("trans_object_shim(object_ty={:?}, upcast_trait_ref={:?}, method_offset_in_trait={})",
+ object_ty,
+ upcast_trait_ref,
method_offset_in_trait);
let object_trait_ref =
data.principal_trait_ref_with_self_ty(tcx, object_ty)
}
_ => {
- tcx.sess.bug(&format!("trans_object_shim() called on non-object: {}",
- object_ty.repr()));
+ tcx.sess.bug(&format!("trans_object_shim() called on non-object: {:?}",
+ object_ty));
}
};
// 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());
+ debug!("trans_object_shim: object_substs={:?}", object_substs);
// 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) {
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(), method_ty.repr());
+ debug!("trans_object_shim: fty={:?} method_ty={:?}", fty, method_ty);
//
let shim_fn_ty = ty::mk_bare_fn(tcx, None, fty);
ty::TyTuple(ref tys) => &**tys,
_ => {
bcx.sess().bug(
- &format!("rust-call expects a tuple not {}",
- sig.inputs[1].repr()));
+ &format!("rust-call expects a tuple not {:?}",
+ sig.inputs[1]));
}
}
}
let tcx = ccx.tcx();
let _icx = push_ctxt("meth::get_vtable");
- debug!("get_vtable(trait_ref={})", trait_ref.repr());
+ debug!("get_vtable(trait_ref={:?})", trait_ref);
// Check the cache.
match ccx.vtables().borrow().get(&trait_ref) {
// an object type; this cannot happen because we
// cannot cast an unsized type into a trait object
tcx.sess.bug(
- &format!("cannot get vtable for an object type: {}",
- data.repr()));
+ &format!("cannot get vtable for an object type: {:?}",
+ data));
}
traits::VtableParam(..) => {
tcx.sess.bug(
- &format!("resolved vtable for {} to bad vtable {} in trans",
- trait_ref.repr(),
- vtable.repr()));
+ &format!("resolved vtable for {:?} to bad vtable {:?} in trans",
+ trait_ref,
+ vtable));
}
}
});
{
let tcx = ccx.tcx();
- debug!("emit_vtable_methods(impl_id={}, substs={}, param_substs={})",
- impl_id.repr(),
- substs.repr(),
- param_substs.repr());
+ debug!("emit_vtable_methods(impl_id={:?}, substs={:?}, param_substs={:?})",
+ impl_id,
+ substs,
+ param_substs);
let trt_id = match ty::impl_trait_ref(tcx, impl_id) {
Some(t_id) => t_id.def_id,
// method could never be called from this object, just supply
// null.
.map(|trait_method_def_id| {
- debug!("emit_vtable_methods: trait_method_def_id={}",
- trait_method_def_id.repr());
+ debug!("emit_vtable_methods: trait_method_def_id={:?}",
+ trait_method_def_id);
let trait_method_type = match ty::impl_or_trait_item(tcx, trait_method_def_id) {
ty::MethodTraitItem(m) => m,
return nullptr;
}
- debug!("emit_vtable_methods: trait_method_type={}",
- trait_method_type.repr());
+ debug!("emit_vtable_methods: trait_method_type={:?}",
+ trait_method_type);
// The substitutions we have are on the impl, so we grab
// the method type from the impl to substitute into.
_ => ccx.sess().bug("should be a method, not other assoc item"),
};
- debug!("emit_vtable_methods: impl_method_type={}",
- impl_method_type.repr());
+ debug!("emit_vtable_methods: impl_method_type={:?}",
+ impl_method_type);
// If this is a default method, it's possible that it
// relies on where clauses that do not hold for this
use trans::declare;
use trans::foreign;
use middle::ty::{self, HasProjectionTypes, Ty};
-use util::ppaux::Repr;
use syntax::abi;
use syntax::ast;
ref_id: Option<ast::NodeId>)
-> (ValueRef, Ty<'tcx>, bool) {
debug!("monomorphic_fn(\
- fn_id={}, \
- real_substs={}, \
+ fn_id={:?}, \
+ real_substs={:?}, \
ref_id={:?})",
- fn_id.repr(),
- psubsts.repr(),
+ fn_id,
+ psubsts,
ref_id);
assert!(psubsts.types.all(|t| {
let item_ty = ty::lookup_item_type(ccx.tcx(), fn_id).ty;
- debug!("monomorphic_fn about to subst into {}", item_ty.repr());
+ debug!("monomorphic_fn about to subst into {:?}", item_ty);
let mono_ty = item_ty.subst(ccx.tcx(), psubsts);
match ccx.monomorphized().borrow().get(&hash_id) {
}
debug!("monomorphic_fn(\
- fn_id={}, \
- psubsts={}, \
+ fn_id={:?}, \
+ psubsts={:?}, \
hash_id={:?})",
- fn_id.repr(),
- psubsts.repr(),
+ fn_id,
+ psubsts,
hash_id);
}
}
- debug!("mono_ty = {} (post-substitution)", mono_ty.repr());
+ debug!("mono_ty = {:?} (post-substitution)", mono_ty);
let mono_ty = normalize_associated_type(ccx.tcx(), &mono_ty);
- debug!("mono_ty = {} (post-normalization)", mono_ty.repr());
+ debug!("mono_ty = {:?} (post-normalization)", mono_ty);
ccx.stats().n_monos.set(ccx.stats().n_monos.get() + 1);
pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T
where T : TypeFoldable<'tcx> + HasProjectionTypes
{
- debug!("normalize_associated_type(t={})", value.repr());
+ debug!("normalize_associated_type(t={:?})", value);
let value = erase_regions(tcx, value);
let traits::Normalized { value: result, obligations } =
traits::normalize(&mut selcx, cause, &value);
- debug!("normalize_associated_type: result={} obligations={}",
- result.repr(),
- obligations.repr());
+ debug!("normalize_associated_type: result={:?} obligations={:?}",
+ result,
+ obligations);
let mut fulfill_cx = traits::FulfillmentContext::new(true);
for obligation in obligations {
use trans::type_::Type;
use trans::type_of;
use middle::ty::{self, Ty};
-use util::ppaux::UserString;
use syntax::ast;
use syntax::parse::token::InternedString;
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(),
+ self.unit_ty,
ccx.tn().type_to_string(self.llunit_ty))
}
}
// to store the array of the suitable size, so all we have to do is
// generate the content.
- debug!("trans_fixed_vstore(expr={}, dest={})",
- bcx.expr_to_string(expr), dest.to_string(bcx.ccx()));
+ debug!("trans_fixed_vstore(expr={:?}, dest={})",
+ expr, dest.to_string(bcx.ccx()));
let vt = vec_types_from_expr(bcx, expr);
let ccx = fcx.ccx;
let mut bcx = bcx;
- debug!("trans_slice_vec(slice_expr={})",
- bcx.expr_to_string(slice_expr));
+ debug!("trans_slice_vec(slice_expr={:?})",
+ slice_expr);
let vec_ty = node_id_type(bcx, slice_expr.id);
str_lit: InternedString,
dest: Dest)
-> Block<'blk, 'tcx> {
- debug!("trans_lit_str(lit_expr={}, dest={})",
- bcx.expr_to_string(lit_expr),
+ debug!("trans_lit_str(lit_expr={:?}, dest={})",
+ lit_expr,
dest.to_string(bcx.ccx()));
match dest {
let fcx = bcx.fcx;
let mut bcx = bcx;
- debug!("write_content(vt={}, dest={}, vstore_expr={})",
+ debug!("write_content(vt={}, dest={}, vstore_expr={:?})",
vt.to_string(bcx.ccx()),
dest.to_string(bcx.ccx()),
- bcx.expr_to_string(vstore_expr));
+ vstore_expr);
match content_expr.node {
ast::ExprLit(ref lit) => {
use trans::foreign;
use trans::machine;
use middle::ty::{self, RegionEscape, Ty};
-use util::ppaux::Repr;
use trans::type_::Type;
abi: abi::Abi)
-> Type
{
- debug!("type_of_rust_fn(sig={},abi={:?})",
- sig.repr(),
+ debug!("type_of_rust_fn(sig={:?},abi={:?})",
+ sig,
abi);
let sig = ty::erase_late_bound_regions(cx.tcx(), sig);
}
ty::TyProjection(..) | ty::TyInfer(..) | ty::TyParam(..) | ty::TyError(..) => {
- cx.sess().bug(&format!("fictitious type {} in sizing_type_of()",
- t.repr()))
+ cx.sess().bug(&format!("fictitious type {:?} in sizing_type_of()",
+ t))
}
ty::TySlice(_) | ty::TyTrait(..) | ty::TyStr => unreachable!()
};
None => ()
}
- debug!("type_of {} {:?}", t.repr(), t.sty);
+ debug!("type_of {:?}", t);
assert!(!t.has_escaping_regions());
if t != t_norm {
let llty = in_memory_type_of(cx, t_norm);
- debug!("--> normalized {} {:?} to {} {:?} llty={}",
- t.repr(),
+ debug!("--> normalized {:?} {:?} to {:?} {:?} llty={}",
t,
- t_norm.repr(),
+ t,
+ t_norm,
t_norm,
cx.tn().type_to_string(llty));
cx.lltypes().borrow_mut().insert(t, llty);
}
ty::TyTrait(_) => Type::vtable_ptr(cx),
_ => panic!("Unexpected type returned from \
- struct_tail: {} for ty={}",
- unsized_part.repr(), ty.repr())
+ struct_tail: {:?} for ty={:?}",
+ unsized_part, ty)
};
Type::struct_(cx, &[ptr_ty, info_ty], false)
}
ty::TyError(..) => cx.sess().bug("type_of with TyError"),
};
- debug!("--> mapped t={} {:?} to llty={}",
- t.repr(),
+ debug!("--> mapped t={:?} {:?} to llty={}",
+ t,
t,
cx.tn().type_to_string(llty));
tps: &[Ty<'tcx>])
-> String {
let base = ty::item_path_str(cx.tcx(), did);
- let strings: Vec<String> = tps.iter().map(|t| t.repr()).collect();
+ let strings: Vec<String> = tps.iter().map(|t| t.to_string()).collect();
let tstr = if strings.is_empty() {
base
} else {
ObjectLifetimeDefaultRscope, ShiftedRscope, BindingRscope};
use util::common::{ErrorReported, FN_OUTPUT_NAME};
use util::nodemap::FnvHashSet;
-use util::ppaux::{Repr, UserString};
use std::iter::repeat;
use std::slice;
}
};
- debug!("ast_region_to_region(lifetime={} id={}) yields {}",
- lifetime.repr(),
+ debug!("ast_region_to_region(lifetime={:?} id={}) yields {:?}",
+ lifetime,
lifetime.id,
- r.repr());
+ r);
r
}
}
};
- debug!("opt_ast_region_to_region(opt_lifetime={}) yields {}",
- opt_lifetime.repr(),
- r.repr());
+ debug!("opt_ast_region_to_region(opt_lifetime={:?}) yields {:?}",
+ opt_lifetime,
+ r);
r
}
{
let tcx = this.tcx();
- debug!("create_substs_for_ast_path(decl_generics={}, self_ty={}, \
- types_provided={}, region_substs={}",
- decl_generics.repr(), self_ty.repr(), types_provided.repr(),
- region_substs.repr());
+ debug!("create_substs_for_ast_path(decl_generics={:?}, self_ty={:?}, \
+ types_provided={:?}, region_substs={:?}",
+ decl_generics, self_ty, types_provided,
+ region_substs);
assert_eq!(region_substs.regions().len(TypeSpace), decl_generics.regions.len(TypeSpace));
assert!(region_substs.types.is_empty());
"the type parameter `{}` must be explicitly specified \
in an object type because its default value `{}` references \
the type `Self`",
- param.name.user_string(),
- default.user_string());
+ param.name,
+ default);
substs.types.push(TypeSpace, tcx.types.err);
} else {
// This is a default type parameter.
def::DefTrait(trait_def_id) => trait_def_id,
_ => {
span_fatal!(this.tcx().sess, path.span, E0245, "`{}` is not a trait",
- path.user_string());
+ path);
}
}
}
let candidate = try!(one_bound_for_assoc_type(tcx,
candidates,
- &trait_ref.user_string(),
+ &trait_ref.to_string(),
&token::get_name(binding.item_name),
binding.span));
bounds);
let result = make_object_type(this, span, trait_ref, existential_bounds);
- debug!("trait_ref_to_object_type: result={}",
- result.repr());
+ debug!("trait_ref_to_object_type: result={:?}",
+ result);
result
}
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(),
+ name,
ty::item_path_str(tcx, trait_def_id));
}
span_note!(tcx.sess, span,
"associated type `{}` could derive from `{}`",
ty_param_name,
- bound.user_string());
+ bound);
}
}
let tcx = this.tcx();
let assoc_name = item_segment.identifier.name;
- debug!("associated_path_def_to_ty: {}::{}", ty.repr(), token::get_name(assoc_name));
+ debug!("associated_path_def_to_ty: {:?}::{}", ty, assoc_name);
check_path_args(tcx, slice::ref_slice(item_segment), NO_TPS | NO_REGIONS);
_ => {
report_ambiguous_associated_type(tcx,
span,
- &ty.user_string(),
+ &ty.to_string(),
"Trait",
&token::get_name(assoc_name));
return (tcx.types.err, ty_path_def);
return tcx.types.err;
};
- debug!("qpath_to_ty: self_type={}", self_ty.repr());
+ debug!("qpath_to_ty: self_type={:?}", self_ty);
let trait_ref = ast_path_to_mono_trait_ref(this,
rscope,
Some(self_ty),
trait_segment);
- debug!("qpath_to_ty: trait_ref={}", trait_ref.repr());
+ debug!("qpath_to_ty: trait_ref={:?}", trait_ref);
this.projected_ty(span, trait_ref, item_segment.identifier.name)
}
ast_ty: &ast::Ty)
-> Ty<'tcx>
{
- debug!("ast_ty_to_ty(ast_ty={})",
- ast_ty.repr());
+ debug!("ast_ty_to_ty(ast_ty={:?})",
+ ast_ty);
let tcx = this.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());
+ debug!("TyRef r={:?}", r);
let rscope1 =
&ObjectLifetimeDefaultRscope::new(
rscope,
depth: path.segments.len()
}
} else {
- tcx.sess.span_bug(ast_ty.span,
- &format!("unbound path {}", ast_ty.repr()))
+ tcx.sess.span_bug(ast_ty.span, &format!("unbound path {:?}", ast_ty))
};
let def = path_res.base_def;
let base_ty_end = path.segments.len() - path_res.depth;
let impl_modifiers = count_modifiers(self_info.untransformed_self_ty);
let method_modifiers = count_modifiers(explicit_type);
- debug!("determine_explicit_self_category(self_info.untransformed_self_ty={} \
- explicit_type={} \
+ debug!("determine_explicit_self_category(self_info.untransformed_self_ty={:?} \
+ explicit_type={:?} \
modifiers=({},{})",
- self_info.untransformed_self_ty.repr(),
- explicit_type.repr(),
+ self_info.untransformed_self_ty,
+ explicit_type,
impl_modifiers,
method_modifiers);
expected_sig: Option<ty::FnSig<'tcx>>)
-> ty::ClosureTy<'tcx>
{
- debug!("ty_of_closure(expected_sig={})",
- expected_sig.repr());
+ debug!("ty_of_closure(expected_sig={:?})",
+ expected_sig);
// new region names that appear inside of the fn decl are bound to
// that function type
ast::NoReturn(..) => ty::FnDiverging
};
- debug!("ty_of_closure: input_tys={}", input_tys.repr());
- debug!("ty_of_closure: output_ty={}", output_ty.repr());
+ debug!("ty_of_closure: input_tys={:?}", input_tys);
+ debug!("ty_of_closure: output_ty={:?}", output_ty);
ty::ClosureTy {
unsafety: unsafety,
let tcx = this.tcx();
debug!("compute_opt_region_bound(explicit_region_bounds={:?}, \
- principal_trait_ref={}, builtin_bounds={})",
+ principal_trait_ref={:?}, builtin_bounds={:?})",
explicit_region_bounds,
- principal_trait_ref.repr(),
- builtin_bounds.repr());
+ principal_trait_ref,
+ builtin_bounds);
if explicit_region_bounds.len() > 1 {
span_err!(tcx.sess, explicit_region_bounds[1].span, E0226,
use check::{instantiate_path, resolve_ty_and_def_ufcs, structurally_resolved_type};
use require_same_types;
use util::nodemap::FnvHashMap;
-use util::ppaux::Repr;
use std::cmp::{self, Ordering};
use std::collections::hash_map::Entry::{Occupied, Vacant};
let fcx = pcx.fcx;
let tcx = pcx.fcx.ccx.tcx;
- debug!("check_pat(pat={},expected={})",
- pat.repr(),
- expected.repr());
+ debug!("check_pat(pat={:?},expected={:?})",
+ pat,
+ expected);
match pat.node {
ast::PatWild(_) => {
}
} else {
tcx.sess.span_bug(pat.span,
- &format!("unbound path {}", pat.repr()))
+ &format!("unbound path {:?}", pat))
};
if let Some((opt_ty, segments, def)) =
resolve_ty_and_def_ufcs(fcx, path_res, Some(self_ty),
use middle::ty_fold::TypeFoldable;
use syntax::ast;
use syntax::codemap::Span;
-use util::ppaux::Repr;
pub fn normalize_associated_types_in<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
typer: &(ty::ClosureTyper<'tcx>+'a),
-> T
where T : TypeFoldable<'tcx> + HasProjectionTypes
{
- debug!("normalize_associated_types_in(value={})", value.repr());
+ debug!("normalize_associated_types_in(value={:?})", value);
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(),
- obligations.repr());
+ debug!("normalize_associated_types_in: result={:?} predicates={:?}",
+ result,
+ obligations);
for obligation in obligations {
fulfillment_cx.register_predicate_obligation(infcx, obligation);
}
use syntax::codemap::Span;
use syntax::parse::token;
use syntax::ptr::P;
-use util::ppaux::Repr;
/// Check that it is legal to call methods of the trait corresponding
/// to `trait_id` (this only cares about the trait, not the specific
autoderefs: usize)
-> Option<CallStep<'tcx>>
{
- debug!("try_overloaded_call_step(call_expr={}, adjusted_ty={}, autoderefs={})",
- call_expr.repr(),
- adjusted_ty.repr(),
+ debug!("try_overloaded_call_step(call_expr={:?}, adjusted_ty={:?}, autoderefs={})",
+ call_expr,
+ adjusted_ty,
autoderefs);
// If the callee is a bare function or a closure, then we're all set.
impl<'tcx> DeferredCallResolution<'tcx> for CallResolution<'tcx> {
fn resolve<'a>(&mut self, fcx: &FnCtxt<'a,'tcx>) {
- debug!("DeferredCallResolution::resolve() {}",
- self.repr());
+ debug!("DeferredCallResolution::resolve() {:?}",
+ self);
// we should not be invoked until the closure kind has been
// determined by upvar inference
ty::no_late_bound_regions(fcx.tcx(),
ty::ty_fn_sig(method_callee.ty)).unwrap();
- debug!("attempt_resolution: method_callee={}",
- method_callee.repr());
+ debug!("attempt_resolution: method_callee={:?}",
+ method_callee);
for (&method_arg_ty, &self_arg_ty) in
method_sig.inputs[1..].iter().zip(&self.fn_sig.inputs)
use syntax::ast;
use syntax::ast::UintTy::{TyU8};
use syntax::codemap::Span;
-use util::ppaux::Repr;
/// Reifies a cast check to be checked once we have full type information for
/// a function context.
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(),
- self.cast_ty.repr());
+ debug!("check_cast({}, {:?} as {:?})", self.expr.id, self.expr_ty,
+ self.cast_ty);
if ty::type_is_error(self.expr_ty) || ty::type_is_error(self.cast_ty) {
// No sense in giving duplicate error messages
m_cast: &'tcx ty::mt<'tcx>)
-> Result<CastKind, CastError>
{
- debug!("check_ptr_ptr_cast m_expr={} m_cast={}",
- m_expr.repr(), m_cast.repr());
+ debug!("check_ptr_ptr_cast m_expr={:?} m_cast={:?}",
+ m_expr, m_cast);
// ptr-ptr cast. vtables must match.
// Cast to sized is OK
use syntax::abi;
use syntax::ast;
use syntax::ast_util;
-use util::ppaux::Repr;
pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
expr: &ast::Expr,
decl: &'tcx ast::FnDecl,
body: &'tcx ast::Block,
expected: Expectation<'tcx>) {
- debug!("check_expr_closure(expr={},expected={})",
- expr.repr(),
- expected.repr());
+ debug!("check_expr_closure(expr={:?},expected={:?})",
+ expr,
+ expected);
// It's always helpful for inference if we know the kind of
// closure sooner rather than later, so first examine the expected
expected_sig: Option<ty::FnSig<'tcx>>) {
let expr_def_id = ast_util::local_def(expr.id);
- debug!("check_closure opt_kind={:?} expected_sig={}",
+ debug!("check_closure opt_kind={:?} expected_sig={:?}",
opt_kind,
- expected_sig.repr());
+ expected_sig);
let mut fn_ty = astconv::ty_of_closure(
fcx,
// the `closures` table.
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(),
- fn_ty.sig.repr(),
+ debug!("closure for {:?} --> sig={:?} opt_kind={:?}",
+ expr_def_id,
+ fn_ty.sig,
opt_kind);
fcx.inh.closure_tys.borrow_mut().insert(expr_def_id, fn_ty);
expected_ty: Ty<'tcx>)
-> (Option<ty::FnSig<'tcx>>,Option<ty::ClosureKind>)
{
- debug!("deduce_expectations_from_expected_type(expected_ty={})",
- expected_ty.repr());
+ debug!("deduce_expectations_from_expected_type(expected_ty={:?})",
+ expected_ty);
match expected_ty.sty {
ty::TyTrait(ref object_type) => {
.pending_obligations()
.iter()
.filter_map(|obligation| {
- debug!("deduce_expectations_from_obligations: obligation.predicate={}",
- obligation.predicate.repr());
+ debug!("deduce_expectations_from_obligations: obligation.predicate={:?}",
+ obligation.predicate);
match obligation.predicate {
// Given a Projection predicate, we can potentially infer
{
let tcx = fcx.tcx();
- debug!("deduce_sig_from_projection({})",
- projection.repr());
+ debug!("deduce_sig_from_projection({:?})",
+ projection);
let trait_ref = projection.to_poly_trait_ref();
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());
+ debug!("deduce_sig_from_projection: arg_param_ty {:?}", arg_param_ty);
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());
+ debug!("deduce_sig_from_projection: input_tys {:?}", input_tys);
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());
+ debug!("deduce_sig_from_projection: ret_param_ty {:?}", ret_param_ty);
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());
+ debug!("deduce_sig_from_projection: fn_sig {:?}", fn_sig);
Some(fn_sig)
}
-> Option<ty::PolyTraitRef<'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(),
- self_ty.repr());
+ debug!("self_type_matches_expected_vid(trait_ref={:?}, self_ty={:?})",
+ trait_ref,
+ self_ty);
match self_ty.sty {
ty::TyInfer(ty::TyVar(v)) if expected_vid == v => Some(trait_ref),
_ => None,
use middle::ty::{self, mt, Ty};
use middle::ty_relate::RelateResult;
use util::common::indent;
-use util::ppaux::Repr;
use std::cell::RefCell;
use std::collections::VecDeque;
a: Ty<'tcx>,
b: Ty<'tcx>)
-> CoerceResult<'tcx> {
- debug!("Coerce.tys({} => {})",
- a.repr(),
- b.repr());
+ debug!("Coerce.tys({:?} => {:?})",
+ a,
+ b);
// Consider coercing the subtype to a DST
let unsize = self.unpack_actual_value(a, |a| {
b: Ty<'tcx>,
mutbl_b: ast::Mutability)
-> CoerceResult<'tcx> {
- debug!("coerce_borrowed_pointer(a={}, b={})",
- a.repr(),
- b.repr());
+ debug!("coerce_borrowed_pointer(a={:?}, b={:?})",
+ a,
+ b);
// If we have a parameter of type `&M T_a` and the value
// provided is `expr`, we will be adding an implicit borrow,
source: Ty<'tcx>,
target: Ty<'tcx>)
-> CoerceResult<'tcx> {
- debug!("coerce_unsized(source={}, target={})",
- source.repr(),
- target.repr());
+ debug!("coerce_unsized(source={:?}, target={:?})",
+ source,
+ target);
let traits = (self.tcx().lang_items.unsize_trait(),
self.tcx().lang_items.coerce_unsized_trait());
// 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());
+ debug!("coerce_unsized resolve step: {:?}", obligation);
let trait_ref = match obligation.predicate {
ty::Predicate::Trait(ref tr) if traits.contains(&tr.def_id()) => {
tr.clone()
autoref: reborrow,
unsize: Some(target)
};
- debug!("Success, coerced with {}", adjustment.repr());
+ debug!("Success, coerced with {:?}", adjustment);
Ok(Some(AdjustDerefRef(adjustment)))
}
*/
self.unpack_actual_value(b, |b| {
- debug!("coerce_from_fn_pointer(a={}, b={})",
- a.repr(), b.repr());
+ debug!("coerce_from_fn_pointer(a={:?}, b={:?})",
+ a, b);
if let ty::TyBareFn(None, fn_ty_b) = b.sty {
match (fn_ty_a.unsafety, fn_ty_b.unsafety) {
*/
self.unpack_actual_value(b, |b| {
- debug!("coerce_from_fn_item(a={}, b={})",
- a.repr(), b.repr());
+ debug!("coerce_from_fn_item(a={:?}, b={:?})",
+ a, b);
match b.sty {
ty::TyBareFn(None, _) => {
b: Ty<'tcx>,
mutbl_b: ast::Mutability)
-> CoerceResult<'tcx> {
- debug!("coerce_unsafe_ptr(a={}, b={})",
- a.repr(),
- b.repr());
+ debug!("coerce_unsafe_ptr(a={:?}, b={:?})",
+ a,
+ b);
let (is_ref, mt_a) = match a.sty {
ty::TyRef(_, mt) => (true, mt),
a: Ty<'tcx>,
b: Ty<'tcx>)
-> RelateResult<'tcx, ()> {
- debug!("mk_assignty({} -> {})", a.repr(), b.repr());
+ debug!("mk_assignty({:?} -> {:?})", a, b);
let mut unsizing_obligations = vec![];
let adjustment = try!(indent(|| {
fcx.infcx().commit_if_ok(|_| {
}
if let Some(adjustment) = adjustment {
- debug!("Success, coerced with {}", adjustment.repr());
+ debug!("Success, coerced with {:?}", adjustment);
fcx.write_adjustment(expr.id, adjustment);
}
Ok(())
use middle::traits;
use middle::ty::{self};
use middle::subst::{self, Subst, Substs, VecPerParamSpace};
-use util::ppaux::Repr;
use syntax::ast;
use syntax::codemap::Span;
impl_m_body_id: ast::NodeId,
trait_m: &ty::Method<'tcx>,
impl_trait_ref: &ty::TraitRef<'tcx>) {
- debug!("compare_impl_method(impl_trait_ref={})",
- impl_trait_ref.repr());
+ debug!("compare_impl_method(impl_trait_ref={:?})",
+ impl_trait_ref);
- debug!("compare_impl_method: impl_trait_ref (liberated) = {}",
- impl_trait_ref.repr());
+ debug!("compare_impl_method: impl_trait_ref (liberated) = {:?}",
+ impl_trait_ref);
let infcx = infer::new_infer_ctxt(tcx);
let mut fulfillment_cx = traits::FulfillmentContext::new(true);
span_err!(tcx.sess, impl_m_span, E0185,
"method `{}` has a `{}` declaration in the impl, \
but not in the trait",
- token::get_name(trait_m.name),
- impl_m.explicit_self.repr());
+ trait_m.name,
+ impl_m.explicit_self);
return;
}
(_, &ty::StaticExplicitSelfCategory) => {
span_err!(tcx.sess, impl_m_span, E0186,
"method `{}` has a `{}` declaration in the trait, \
but not in the impl",
- token::get_name(trait_m.name),
- trait_m.explicit_self.repr());
+ trait_m.name,
+ trait_m.explicit_self);
return;
}
_ => {
.subst(tcx, impl_to_skol_substs)
.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());
+ debug!("compare_impl_method: trait_to_skol_substs={:?}",
+ trait_to_skol_substs);
// Check region bounds. FIXME(@jroesch) refactor this away when removing
// ParamBounds.
impl_m_span,
infer::HigherRankedType,
&ty::Binder(impl_bounds));
- debug!("compare_impl_method: impl_bounds={}",
- impl_bounds.repr());
+ debug!("compare_impl_method: impl_bounds={:?}",
+ impl_bounds);
// Normalize the associated types in the trait_bounds.
let trait_bounds = trait_m.predicates.instantiate(tcx, &trait_to_skol_substs);
let trait_param_env = traits::normalize_param_env_or_error(trait_param_env,
normalize_cause.clone());
- debug!("compare_impl_method: trait_bounds={}",
- trait_param_env.caller_bounds.repr());
+ debug!("compare_impl_method: trait_bounds={:?}",
+ trait_param_env.caller_bounds);
let mut selcx = traits::SelectionContext::new(&infcx, &trait_param_env);
tcx.mk_bare_fn(ty::BareFnTy { unsafety: impl_m.fty.unsafety,
abi: impl_m.fty.abi,
sig: ty::Binder(impl_sig) }));
- debug!("compare_impl_method: impl_fty={}",
- impl_fty.repr());
+ debug!("compare_impl_method: impl_fty={:?}",
+ impl_fty);
let (trait_sig, skol_map) =
infcx.skolemize_late_bound_regions(&trait_m.fty.sig, snapshot);
abi: trait_m.fty.abi,
sig: ty::Binder(trait_sig) }));
- debug!("compare_impl_method: trait_fty={}",
- trait_fty.repr());
+ debug!("compare_impl_method: trait_fty={:?}",
+ trait_fty);
try!(infer::mk_subty(&infcx, false, origin, impl_fty, trait_fty));
match err {
Ok(()) => { }
Err(terr) => {
- debug!("checking trait method for compatibility: impl ty {}, trait ty {}",
- impl_fty.repr(),
- trait_fty.repr());
+ debug!("checking trait method for compatibility: impl ty {:?}, trait ty {:?}",
+ impl_fty,
+ trait_fty);
span_err!(tcx.sess, impl_m_span, E0053,
"method `{}` has an incompatible type for trait: {}",
token::get_name(trait_m.name),
let impl_params = impl_generics.regions.get_slice(subst::FnSpace);
debug!("check_region_bounds_on_impl_method: \
- trait_generics={} \
- impl_generics={} \
- trait_to_skol_substs={} \
- impl_to_skol_substs={}",
- trait_generics.repr(),
- impl_generics.repr(),
- trait_to_skol_substs.repr(),
- impl_to_skol_substs.repr());
+ trait_generics={:?} \
+ impl_generics={:?} \
+ trait_to_skol_substs={:?} \
+ impl_to_skol_substs={:?}",
+ trait_generics,
+ impl_generics,
+ trait_to_skol_substs,
+ impl_to_skol_substs);
// Must have same number of early-bound lifetime parameters.
// Unfortunately, if the user screws up the bounds, then this
impl_c_span: Span,
trait_c: &ty::AssociatedConst<'tcx>,
impl_trait_ref: &ty::TraitRef<'tcx>) {
- debug!("compare_const_impl(impl_trait_ref={})",
- impl_trait_ref.repr());
+ debug!("compare_const_impl(impl_trait_ref={:?})",
+ impl_trait_ref);
let infcx = infer::new_infer_ctxt(tcx);
let mut fulfillment_cx = traits::FulfillmentContext::new(true);
.subst(tcx, impl_to_skol_substs)
.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());
+ debug!("compare_const_impl: trait_to_skol_substs={:?}",
+ trait_to_skol_substs);
// Compute skolemized form of impl and trait const tys.
let impl_ty = impl_c.ty.subst(tcx, impl_to_skol_substs);
impl_c_span,
0,
&impl_ty);
- debug!("compare_const_impl: impl_ty={}",
- impl_ty.repr());
+ debug!("compare_const_impl: impl_ty={:?}",
+ impl_ty);
let trait_ty =
assoc::normalize_associated_types_in(&infcx,
impl_c_span,
0,
&trait_ty);
- debug!("compare_const_impl: trait_ty={}",
- trait_ty.repr());
+ debug!("compare_const_impl: trait_ty={:?}",
+ trait_ty);
infer::mk_subty(&infcx, false, origin, impl_ty, trait_ty)
});
match err {
Ok(()) => { }
Err(terr) => {
- debug!("checking associated const for compatibility: impl ty {}, trait ty {}",
- impl_ty.repr(),
- trait_ty.repr());
+ debug!("checking associated const for compatibility: impl ty {:?}, trait ty {:?}",
+ impl_ty,
+ trait_ty);
span_err!(tcx.sess, impl_c_span, E0326,
"implemented const `{}` has an incompatible type for \
trait: {}",
use std::result::Result::{Err, Ok};
use syntax::ast;
use syntax::codemap::Span;
-use util::ppaux::Repr;
// Requires that the two types unify, and prints an error message if
// they don't.
expected: Ty<'tcx>,
expr: &ast::Expr) {
let expr_ty = fcx.expr_ty(expr);
- debug!("demand::coerce(expected = {}, expr_ty = {})",
- expected.repr(),
- expr_ty.repr());
+ debug!("demand::coerce(expected = {:?}, expr_ty = {:?})",
+ expected,
+ expr_ty);
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) {
use middle::region;
use middle::subst::{self, Subst};
use middle::ty::{self, Ty};
-use util::ppaux::{Repr, UserString};
use syntax::ast;
use syntax::codemap::{self, Span};
///
pub fn check_drop_impl(tcx: &ty::ctxt, drop_impl_did: ast::DefId) -> Result<(), ()> {
let ty::TypeScheme { generics: ref dtor_generics,
- ty: ref dtor_self_type } = ty::lookup_item_type(tcx, drop_impl_did);
+ ty: dtor_self_type } = ty::lookup_item_type(tcx, drop_impl_did);
let dtor_predicates = ty::lookup_predicates(tcx, drop_impl_did);
match dtor_self_type.sty {
ty::TyEnum(self_type_did, self_to_impl_substs) |
try!(ensure_drop_params_and_item_params_correspond(tcx,
drop_impl_did,
dtor_generics,
- dtor_self_type,
+ &dtor_self_type,
self_type_did));
ensure_drop_predicates_are_implied_by_item_defn(tcx,
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()));
+ dtor_self_type));
}
}
}
if !assumptions_in_impl_context.contains(&predicate) {
let item_span = tcx.map.span(self_type_did.node);
- let req = predicate.user_string();
span_err!(tcx.sess, drop_impl_span, E0367,
- "The requirement `{}` is added only by the Drop impl.", req);
+ "The requirement `{}` is added only by the Drop impl.", predicate);
tcx.sess.span_note(item_span,
"The same requirement must be part of \
the struct/enum definition");
typ: ty::Ty<'tcx>,
span: Span,
scope: region::CodeExtent) {
- debug!("check_safety_of_destructor_if_necessary typ: {} scope: {:?}",
- typ.repr(), scope);
+ debug!("check_safety_of_destructor_if_necessary typ: {:?} scope: {:?}",
+ typ, scope);
// types that have been traversed so far by `traverse_type_if_unseen`
let mut breadcrumbs: Vec<Ty<'tcx>> = Vec::new();
Err(Error::Overflow(ref ctxt, ref detected_on_typ)) => {
let tcx = rcx.tcx();
span_err!(tcx.sess, span, E0320,
- "overflow while adding drop-check rules for {}",
- typ.user_string());
+ "overflow while adding drop-check rules for {}", typ);
match *ctxt {
TypeContext::Root => {
// no need for an additional note if the overflow
ty::item_path_str(tcx, def_id),
variant,
arg_index,
- detected_on_typ.user_string());
+ detected_on_typ);
}
TypeContext::Struct { def_id, field } => {
span_note!(
"overflowed on struct {} field {} type: {}",
ty::item_path_str(tcx, def_id),
field,
- detected_on_typ.user_string());
+ detected_on_typ);
}
}
}
let tp_def = item_type.generics.types
.opt_get(subst::TypeSpace, 0).unwrap();
let new_typ = substs.type_for_def(tp_def);
- debug!("replacing phantom {} with {}",
- typ.repr(), new_typ.repr());
+ debug!("replacing phantom {:?} with {:?}",
+ typ, new_typ);
(new_typ, xref_depth_orig + 1)
} else {
(typ, xref_depth_orig)
// definition of `Box<T>` must carry a PhantomData that
// puts us into the previous case.
ty::TyBox(new_typ) => {
- debug!("replacing TyBox {} with {}",
- typ.repr(), new_typ.repr());
+ debug!("replacing TyBox {:?} with {:?}",
+ typ, new_typ);
(new_typ, xref_depth_orig + 1)
}
debug!("iterate_over_potentially_unsafe_regions_in_type \
{}typ: {} scope: {:?} xref: {}",
(0..depth).map(|_| ' ').collect::<String>(),
- typ.repr(), scope, xref_depth);
+ typ, scope, xref_depth);
// If `typ` has a destructor, then we must ensure that all
// borrowed data reachable via `typ` must outlive the parent
match typ.sty {
ty::TyStruct(struct_did, substs) => {
- debug!("typ: {} is struct; traverse structure and not type-expression",
- typ.repr());
+ debug!("typ: {:?} is struct; traverse structure and not type-expression",
+ typ);
// Don't recurse; we extract type's substructure,
// so do not process subparts of type expression.
walker.skip_current_subtree();
}
ty::TyEnum(enum_did, substs) => {
- debug!("typ: {} is enum; traverse structure and not type-expression",
- typ.repr());
+ debug!("typ: {:?} is enum; traverse structure and not type-expression",
+ typ);
// Don't recurse; we extract type's substructure,
// so do not process subparts of type expression.
walker.skip_current_subtree();
match dtor_kind {
DtorKind::PureRecur => {
has_dtor_of_interest = false;
- debug!("typ: {} has no dtor, and thus is uninteresting",
- typ.repr());
+ debug!("typ: {:?} has no dtor, and thus is uninteresting",
+ typ);
}
DtorKind::Unknown(bounds) => {
match bounds.region_bound {
ty::ReStatic => {
- debug!("trait: {} has 'static bound, and thus is uninteresting",
- typ.repr());
+ debug!("trait: {:?} has 'static bound, and thus is uninteresting",
+ typ);
has_dtor_of_interest = false;
}
ty::ReEmpty => {
- debug!("trait: {} has empty region bound, and thus is uninteresting",
- typ.repr());
+ debug!("trait: {:?} has empty region bound, and thus is uninteresting",
+ typ);
has_dtor_of_interest = false;
}
r => {
- debug!("trait: {} has non-static bound: {}; assumed interesting",
- typ.repr(), r.repr());
+ debug!("trait: {:?} has non-static bound: {:?}; assumed interesting",
+ typ, r);
has_dtor_of_interest = true;
}
}
if result {
has_pred_of_interest = true;
- debug!("typ: {} has interesting dtor due to generic preds, e.g. {}",
- typ.repr(), pred.repr());
+ debug!("typ: {:?} has interesting dtor due to generic preds, e.g. {:?}",
+ typ, pred);
break 'items;
}
}
has_pred_of_interest;
if has_dtor_of_interest {
- debug!("typ: {} has interesting dtor, due to \
+ debug!("typ: {:?} has interesting dtor, due to \
region params: {} or pred: {}",
- typ.repr(),
+ typ,
has_region_param_of_interest,
has_pred_of_interest);
} else {
- debug!("typ: {} has dtor, but it is uninteresting",
- typ.repr());
+ debug!("typ: {:?} has dtor, but it is uninteresting",
+ typ);
}
}
}
use syntax::ast;
use syntax::codemap::Span;
use std::iter::repeat;
-use util::ppaux::Repr;
struct ConfirmContext<'a, 'tcx:'a> {
fcx: &'a FnCtxt<'a, 'tcx>,
supplied_method_types: Vec<Ty<'tcx>>)
-> MethodCallee<'tcx>
{
- debug!("confirm(unadjusted_self_ty={}, pick={}, supplied_method_types={})",
- unadjusted_self_ty.repr(),
- pick.repr(),
- supplied_method_types.repr());
+ debug!("confirm(unadjusted_self_ty={:?}, pick={:?}, supplied_method_types={:?})",
+ unadjusted_self_ty,
+ pick,
+ supplied_method_types);
let mut confirm_cx = ConfirmContext::new(fcx, span, self_expr, call_expr);
confirm_cx.confirm(unadjusted_self_ty, pick, supplied_method_types)
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());
+ debug!("all_substs={:?}", all_substs);
// Create the final signature for the method, replacing late-bound regions.
let InstantiatedMethodSig {
this.upcast(original_poly_trait_ref.clone(), trait_def_id);
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(),
- upcast_trait_ref.repr(),
- trait_def_id.repr());
+ debug!("original_poly_trait_ref={:?} upcast_trait_ref={:?} target_trait={:?}",
+ original_poly_trait_ref,
+ upcast_trait_ref,
+ trait_def_id);
let substs = upcast_trait_ref.substs.clone();
let origin = MethodTraitObject(MethodObject {
trait_ref: upcast_trait_ref,
self.tcx().sess.span_bug(
self.span,
&format!("self-type `{}` for ObjectPick never dereferenced to an object",
- self_ty.repr()))
+ self_ty))
}
}
}
Err(_) => {
self.tcx().sess.span_bug(
self.span,
- &format!(
- "{} was a subtype of {} but now is not?",
- self_ty.repr(),
- method_self_ty.repr()));
+ &format!("{} was a subtype of {} but now is not?",
+ self_ty, method_self_ty));
}
}
}
all_substs: subst::Substs<'tcx>)
-> InstantiatedMethodSig<'tcx>
{
- debug!("instantiate_method_sig(pick={}, all_substs={})",
- pick.repr(),
- all_substs.repr());
+ debug!("instantiate_method_sig(pick={:?}, all_substs={:?})",
+ pick,
+ all_substs);
// Instantiate the bounds on the method with the
// type/early-bound-regions substitutions performed. There can
let method_predicates = self.fcx.normalize_associated_types_in(self.span,
&method_predicates);
- debug!("method_predicates after subst = {}",
- method_predicates.repr());
+ debug!("method_predicates after subst = {:?}",
+ method_predicates);
// Instantiate late-bound regions and substitute the trait
// parameters into the method type to get the actual method type.
// may reference those regions.
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());
+ debug!("late-bound lifetimes from method instantiated, method_sig={:?}",
+ method_sig);
let method_sig = self.fcx.instantiate_type_scheme(self.span, &all_substs, &method_sig);
- debug!("type scheme substituted, method_sig={}",
- method_sig.repr());
+ debug!("type scheme substituted, method_sig={:?}",
+ method_sig);
InstantiatedMethodSig {
method_sig: method_sig,
pick: &probe::Pick<'tcx>,
all_substs: &subst::Substs<'tcx>,
method_predicates: &ty::InstantiatedPredicates<'tcx>) {
- debug!("add_obligations: pick={} all_substs={} method_predicates={}",
- pick.repr(),
- all_substs.repr(),
- method_predicates.repr());
+ debug!("add_obligations: pick={:?} all_substs={:?} method_predicates={:?}",
+ pick,
+ all_substs,
+ method_predicates);
self.fcx.add_obligations_for_parameters(
traits::ObligationCause::misc(self.span, self.fcx.body_id),
}
}
- debug!("fixup_derefs_on_method_receiver_if_necessary: exprs={}",
- exprs.repr());
+ debug!("fixup_derefs_on_method_receiver_if_necessary: exprs={:?}",
+ exprs);
// Fix up autoderefs and derefs.
for (i, &expr) in exprs.iter().rev().enumerate() {
Some(_) | None => 0,
};
- debug!("fixup_derefs_on_method_receiver_if_necessary: i={} expr={} autoderef_count={}",
- i, expr.repr(), autoderef_count);
+ debug!("fixup_derefs_on_method_receiver_if_necessary: i={} expr={:?} \
+ autoderef_count={}",
+ i, expr, autoderef_count);
if autoderef_count > 0 {
check::autoderef(self.fcx,
Some(_) => {
self.tcx().sess.span_bug(
base_expr.span,
- &format!("unexpected adjustment autoref {}",
- adr.repr()));
+ &format!("unexpected adjustment autoref {:?}",
+ adr));
}
},
None => (0, None),
if upcast_trait_refs.len() != 1 {
self.tcx().sess.span_bug(
self.span,
- &format!("cannot uniquely upcast `{}` to `{}`: `{}`",
- source_trait_ref.repr(),
- target_trait_def_id.repr(),
- upcast_trait_refs.repr()));
+ &format!("cannot uniquely upcast `{:?}` to `{:?}`: `{:?}`",
+ source_trait_ref,
+ target_trait_def_id,
+ upcast_trait_refs));
}
upcast_trait_refs.into_iter().next().unwrap()
use middle::traits;
use middle::ty::{self, AsPredicate, ToPolyTraitRef};
use middle::infer;
-use util::ppaux::Repr;
use syntax::ast::DefId;
use syntax::ast;
self_expr: &'tcx ast::Expr)
-> Result<ty::MethodCallee<'tcx>, MethodError>
{
- debug!("lookup(method_name={}, self_ty={}, call_expr={}, self_expr={})",
- method_name.repr(),
- self_ty.repr(),
- call_expr.repr(),
- self_expr.repr());
+ debug!("lookup(method_name={}, self_ty={:?}, call_expr={:?}, self_expr={:?})",
+ method_name,
+ self_ty,
+ call_expr,
+ self_expr);
let mode = probe::Mode::MethodCall;
let self_ty = fcx.infcx().resolve_type_vars_if_possible(&self_ty);
opt_input_types: Option<Vec<ty::Ty<'tcx>>>)
-> Option<ty::MethodCallee<'tcx>>
{
- debug!("lookup_in_trait_adjusted(self_ty={}, self_expr={}, m_name={}, trait_def_id={})",
- self_ty.repr(),
- self_expr.repr(),
- m_name.repr(),
- trait_def_id.repr());
+ debug!("lookup_in_trait_adjusted(self_ty={:?}, self_expr={:?}, m_name={}, trait_def_id={:?})",
+ self_ty,
+ self_expr,
+ m_name,
+ trait_def_id);
let trait_def = ty::lookup_trait_def(fcx.tcx(), trait_def_id);
assert_eq!(method_ty.generics.types.len(subst::FnSpace), 0);
assert_eq!(method_ty.generics.regions.len(subst::FnSpace), 0);
- debug!("lookup_in_trait_adjusted: method_num={} method_ty={}",
- method_num, method_ty.repr());
+ debug!("lookup_in_trait_adjusted: method_num={} method_ty={:?}",
+ method_num, method_ty);
// Instantiate late-bound regions and substitute the trait
// parameters into the method type to get the actual method type.
abi: method_ty.fty.abi.clone(),
}));
- debug!("lookup_in_trait_adjusted: matched method fty={} obligation={}",
- fty.repr(),
- obligation.repr());
+ debug!("lookup_in_trait_adjusted: matched method fty={:?} obligation={:?}",
+ fty,
+ obligation);
// Register obligations for the parameters. This will include the
// `Self` parameter, which in turn has a bound of the main trait,
span,
&format!(
"trait method is &self but first arg is: {}",
- transformed_self_ty.repr()));
+ transformed_self_ty));
}
}
}
substs: trait_ref.substs.clone()
};
- debug!("callee = {}", callee.repr());
+ debug!("callee = {:?}", callee);
Some(callee)
}
use std::collections::HashSet;
use std::mem;
use std::rc::Rc;
-use util::ppaux::Repr;
use self::CandidateKind::*;
pub use self::PickKind::*;
scope_expr_id: ast::NodeId)
-> PickResult<'tcx>
{
- debug!("probe(self_ty={}, item_name={}, scope_expr_id={})",
- self_ty.repr(),
+ debug!("probe(self_ty={:?}, item_name={}, scope_expr_id={})",
+ self_ty,
item_name,
scope_expr_id);
Some(simplified_steps)
};
- debug!("ProbeContext: steps for self_ty={} are {}",
- self_ty.repr(),
- steps.repr());
+ debug!("ProbeContext: steps for self_ty={:?} are {:?}",
+ self_ty,
+ steps);
// this creates one big transaction so that all type variables etc
// that we create during the probe process are removed later
}
fn assemble_probe(&mut self, self_ty: Ty<'tcx>) {
- debug!("assemble_probe: self_ty={}",
- self_ty.repr());
+ debug!("assemble_probe: self_ty={:?}",
+ self_ty);
match self_ty.sty {
ty::TyTrait(box ref data) => {
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());
+ xform_self_ty);
self.inherent_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
fn assemble_inherent_candidates_from_object(&mut self,
self_ty: Ty<'tcx>,
data: &ty::TraitTy<'tcx>) {
- debug!("assemble_inherent_candidates_from_object(self_ty={})",
- self_ty.repr());
+ debug!("assemble_inherent_candidates_from_object(self_ty={:?})",
+ self_ty);
let tcx = self.tcx();
trait_ref.substs);
if let Some(ref m) = item.as_opt_method() {
- debug!("found match: trait_ref={} substs={} m={}",
- trait_ref.repr(),
- trait_ref.substs.repr(),
- m.repr());
+ debug!("found match: trait_ref={:?} substs={:?} m={:?}",
+ trait_ref,
+ trait_ref.substs,
+ m);
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(),
usize,
),
{
- debug!("elaborate_bounds(bounds={})", bounds.repr());
+ debug!("elaborate_bounds(bounds={:?})", bounds);
let tcx = self.tcx();
for bound_trait_ref in traits::transitive_bounds(tcx, bounds) {
trait_def_id: ast::DefId)
-> Result<(),MethodError>
{
- debug!("assemble_extension_candidates_for_trait(trait_def_id={})",
- trait_def_id.repr());
+ debug!("assemble_extension_candidates_for_trait(trait_def_id={:?})",
+ trait_def_id);
// Check whether `trait_def_id` defines a method with suitable name:
let trait_items =
// 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(),
- impl_def_id.repr());
+ debug!("assemble_extension_candidates_for_trait_impl: trait_def_id={:?} \
+ impl_def_id={:?}",
+ trait_def_id,
+ impl_def_id);
if !self.impl_can_possibly_match(impl_def_id) {
return;
let (_, impl_substs) = self.impl_ty_and_substs(impl_def_id);
- debug!("impl_substs={}", impl_substs.repr());
+ debug!("impl_substs={:?}", impl_substs);
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());
+ debug!("impl_trait_ref={:?}", impl_trait_ref);
// Determine the receiver type that the method itself expects.
let xform_self_ty =
let traits::Normalized { value: xform_self_ty, obligations } =
traits::normalize(selcx, cause, &xform_self_ty);
- debug!("xform_self_ty={}", xform_self_ty.repr());
+ debug!("xform_self_ty={:?}", xform_self_ty);
self.extension_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
item_index: usize)
{
debug!("assemble_projection_candidates(\
- trait_def_id={}, \
- item={}, \
+ trait_def_id={:?}, \
+ item={:?}, \
item_index={})",
- trait_def_id.repr(),
- item.repr(),
+ trait_def_id,
+ item,
item_index);
for step in self.steps.iter() {
- debug!("assemble_projection_candidates: step={}",
- step.repr());
+ debug!("assemble_projection_candidates: step={:?}",
+ step);
let projection_trait_ref = match step.self_ty.sty {
ty::TyProjection(ref data) => &data.trait_ref,
_ => continue,
};
- debug!("assemble_projection_candidates: projection_trait_ref={}",
- projection_trait_ref.repr());
+ debug!("assemble_projection_candidates: projection_trait_ref={:?}",
+ projection_trait_ref);
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());
+ debug!("assemble_projection_candidates: predicates={:?}",
+ predicates);
for poly_bound in
traits::elaborate_predicates(self.tcx(), predicates)
.filter_map(|p| p.to_opt_poly_trait_ref())
{
let bound = self.erase_late_bound_regions(&poly_bound);
- debug!("assemble_projection_candidates: projection_trait_ref={} bound={}",
- projection_trait_ref.repr(),
- bound.repr());
+ debug!("assemble_projection_candidates: projection_trait_ref={:?} bound={:?}",
+ projection_trait_ref,
+ bound);
if self.infcx().can_equate(&step.self_ty, &bound.self_ty()).is_ok() {
let xform_self_ty = self.xform_self_ty(&item,
bound.self_ty(),
bound.substs);
- debug!("assemble_projection_candidates: bound={} xform_self_ty={}",
- bound.repr(),
- xform_self_ty.repr());
+ debug!("assemble_projection_candidates: bound={:?} xform_self_ty={:?}",
+ bound,
+ xform_self_ty);
self.extension_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
item: ty::ImplOrTraitItem<'tcx>,
item_index: usize)
{
- debug!("assemble_where_clause_candidates(trait_def_id={})",
- trait_def_id.repr());
+ debug!("assemble_where_clause_candidates(trait_def_id={:?})",
+ trait_def_id);
let caller_predicates = self.fcx.inh.param_env.caller_bounds.clone();
for poly_bound in traits::elaborate_predicates(self.tcx(), caller_predicates)
bound.self_ty(),
bound.substs);
- debug!("assemble_where_clause_candidates: bound={} xform_self_ty={}",
- bound.repr(),
- xform_self_ty.repr());
+ debug!("assemble_where_clause_candidates: bound={:?} xform_self_ty={:?}",
+ bound,
+ xform_self_ty);
self.extension_candidates.push(Candidate {
xform_self_ty: xform_self_ty,
}
fn pick_step(&mut self, step: &CandidateStep<'tcx>) -> Option<PickResult<'tcx>> {
- debug!("pick_step: step={}", step.repr());
+ debug!("pick_step: step={:?}", step);
if ty::type_is_error(step.self_ty) {
return None;
.filter(|&probe| self.consider_probe(self_ty, probe))
.collect();
- debug!("applicable_candidates: {}", applicable_candidates.repr());
+ debug!("applicable_candidates: {:?}", applicable_candidates);
if applicable_candidates.len() > 1 {
match self.collapse_candidates_to_trait_pick(&applicable_candidates[..]) {
}
fn consider_probe(&self, self_ty: Ty<'tcx>, probe: &Candidate<'tcx>) -> bool {
- debug!("consider_probe: self_ty={} probe={}",
- self_ty.repr(),
- probe.repr());
+ debug!("consider_probe: self_ty={:?} probe={:?}",
+ self_ty,
+ probe);
self.infcx().probe(|_| {
// First check that the self type can be related.
let obligations =
traits::predicates_for_generics(cause.clone(),
&impl_bounds);
- debug!("impl_obligations={}", obligations.repr());
+ debug!("impl_obligations={:?}", obligations);
// Evaluate those obligations to see if they might possibly hold.
obligations.iter()
substs: &subst::Substs<'tcx>)
-> Ty<'tcx>
{
- debug!("xform_self_ty(impl_ty={}, self_ty={}, substs={})",
- impl_ty.repr(),
- method.fty.sig.0.inputs.get(0).repr(),
- substs.repr());
+ debug!("xform_self_ty(impl_ty={:?}, self_ty={:?}, substs={:?})",
+ impl_ty,
+ method.fty.sig.0.inputs.get(0),
+ substs);
assert!(!substs.has_escaping_regions());
use middle::ty::{self, Ty};
use middle::def;
use metadata::{csearch, cstore, decoder};
-use util::ppaux::UserString;
use syntax::{ast, ast_util};
use syntax::codemap::Span;
match error {
MethodError::NoMatch(static_sources, out_of_scope_traits, mode) => {
let cx = fcx.tcx();
- let item_ustring = item_name.user_string();
fcx.type_error_message(
span,
in the current scope",
if mode == Mode::MethodCall { "method" }
else { "associated item" },
- item_ustring,
+ item_name,
actual)
},
rcvr_ty,
if fields.iter().any(|f| f.name == item_name) {
cx.sess.span_note(span,
&format!("use `(s.{0})(...)` if you meant to call the \
- function stored in the `{0}` field", item_ustring));
+ function stored in the `{0}` field", item_name));
}
}
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(),
+ item_name,
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., `{}()`)",
"candidate #{} is defined in an impl{} for the type `{}`",
idx + 1,
insertion,
- impl_ty.user_string());
+ impl_ty);
}
CandidateSource::TraitSource(trait_did) => {
let (_, item) = trait_item(fcx.tcx(), trait_did, item_name).unwrap();
valid_out_of_scope_traits: Vec<ast::DefId>)
{
let tcx = fcx.tcx();
- let item_ustring = item_name.user_string();
if !valid_out_of_scope_traits.is_empty() {
let mut candidates = valid_out_of_scope_traits;
perhaps you need to implement {one_of_them}:",
traits_define = if candidates.len() == 1 {"trait defines"} else {"traits define"},
one_of_them = if candidates.len() == 1 {"it"} else {"one of them"},
- name = item_ustring);
+ name = item_name);
fcx.sess().fileline_help(span, &msg[..]);
use TypeAndSubsts;
use lint;
use util::common::{block_query, ErrorReported, indenter, loop_query};
-use util::ppaux::{Repr, UserString};
use util::nodemap::{DefIdMap, FnvHashMap, NodeMap};
use util::lev_distance::lev_distance;
None => None
};
self.assign(local.span, local.id, o_ty);
- debug!("Local variable {} is assigned type {}",
- self.fcx.pat_to_string(&*local.pat),
+ debug!("Local variable {:?} is assigned type {}",
+ local.pat,
self.fcx.infcx().ty_to_string(
self.fcx.inh.locals.borrow().get(&local.id).unwrap().clone()));
visit::walk_local(self, local);
self.fcx.require_type_is_sized(var_ty, p.span,
traits::VariableType(p.id));
- debug!("Pattern binding {} is assigned to {} with type {}",
+ debug!("Pattern binding {} is assigned to {} with type {:?}",
token::get_ident(path1.node),
self.fcx.infcx().ty_to_string(
self.fcx.inh.locals.borrow().get(&p.id).unwrap().clone()),
- var_ty.repr());
+ var_ty);
}
}
visit::walk_pat(self, p);
let arg_tys = &fn_sig.inputs;
let ret_ty = fn_sig.output;
- debug!("check_fn(arg_tys={}, ret_ty={}, fn_id={})",
- arg_tys.repr(),
- ret_ty.repr(),
+ debug!("check_fn(arg_tys={:?}, ret_ty={:?}, fn_id={})",
+ arg_tys,
+ ret_ty,
fn_id);
// Create the function context. This is either derived from scratch or,
fn_sig_tys.push(ret_ty);
}
- debug!("fn-sig-map: fn_id={} fn_sig_tys={}",
+ debug!("fn-sig-map: fn_id={} fn_sig_tys={:?}",
fn_id,
- fn_sig_tys.repr());
+ fn_sig_tys);
inherited.fn_sig_map.borrow_mut().insert(fn_id, fn_sig_tys);
sig: &'tcx ast::MethodSig,
body: &'tcx ast::Block,
id: ast::NodeId, span: Span) {
- debug!("check_method_body(item_generics={}, id={})",
- item_generics.repr(), id);
+ debug!("check_method_body(item_generics={:?}, id={})",
+ item_generics, 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());
+ debug!("check_method_body: fty={:?}", fty);
check_bare_fn(ccx, &sig.decl, body, id, span, fty, param_env);
}
_ => {
span_err!(tcx.sess, impl_item.span, E0323,
"item `{}` is an associated const, \
- which doesn't match its trait `{}`",
+ which doesn't match its trait `{:?}`",
token::get_name(impl_const_ty.name()),
- impl_trait_ref.repr())
+ impl_trait_ref)
}
}
}
impl_item.span,
&format!(
"associated const `{}` is not a member of \
- trait `{}`",
+ trait `{:?}`",
token::get_name(impl_const_ty.name()),
- impl_trait_ref.repr()));
+ impl_trait_ref));
}
}
}
_ => {
span_err!(tcx.sess, impl_item.span, E0324,
"item `{}` is an associated method, \
- which doesn't match its trait `{}`",
+ which doesn't match its trait `{:?}`",
token::get_name(impl_item_ty.name()),
- impl_trait_ref.repr())
+ impl_trait_ref)
}
}
}
// caught in resolve.
tcx.sess.span_bug(
impl_item.span,
- &format!("method `{}` is not a member of trait `{}`",
+ &format!("method `{}` is not a member of trait `{:?}`",
token::get_name(impl_item_ty.name()),
- impl_trait_ref.repr()));
+ impl_trait_ref));
}
}
}
_ => {
span_err!(tcx.sess, impl_item.span, E0325,
"item `{}` is an associated type, \
- which doesn't match its trait `{}`",
+ which doesn't match its trait `{:?}`",
token::get_name(typedef_ty.name()),
- impl_trait_ref.repr())
+ impl_trait_ref)
}
}
}
impl_item.span,
&format!(
"associated type `{}` is not a member of \
- trait `{}`",
+ trait `{:?}`",
token::get_name(typedef_ty.name()),
- impl_trait_ref.repr()));
+ impl_trait_ref));
}
}
}
/// 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());
+ debug!("resolve_type_vars_if_possible(ty={:?})", ty);
// No ty::infer()? Nothing needs doing.
if !ty::type_has_ty_infer(ty) {
- debug!("resolve_type_vars_if_possible: ty={}", ty.repr());
+ debug!("resolve_type_vars_if_possible: ty={:?}", ty);
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());
+ debug!("resolve_type_vars_if_possible: ty={:?}", ty);
return ty;
}
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());
+ debug!("resolve_type_vars_if_possible: ty={:?}", ty);
return ty;
}
self.select_obligations_where_possible();
ty = self.infcx().resolve_type_vars_if_possible(&ty);
- debug!("resolve_type_vars_if_possible: ty={}", ty.repr());
+ debug!("resolve_type_vars_if_possible: ty={:?}", ty);
ty
}
#[inline]
pub fn write_ty(&self, node_id: ast::NodeId, ty: Ty<'tcx>) {
- debug!("write_ty({}, {}) in fcx {}",
- node_id, ty.repr(), self.tag());
+ debug!("write_ty({}, {:?}) in fcx {}",
+ node_id, ty, self.tag());
self.inh.node_types.borrow_mut().insert(node_id, ty);
}
pub fn write_substs(&self, node_id: ast::NodeId, substs: ty::ItemSubsts<'tcx>) {
if !substs.substs.is_noop() {
- debug!("write_substs({}, {}) in fcx {}",
+ debug!("write_substs({}, {:?}) in fcx {}",
node_id,
- substs.repr(),
+ substs,
self.tag());
self.inh.item_substs.borrow_mut().insert(node_id, substs);
pub fn write_adjustment(&self,
node_id: ast::NodeId,
adj: ty::AutoAdjustment<'tcx>) {
- debug!("write_adjustment(node_id={}, adj={})", node_id, adj.repr());
+ debug!("write_adjustment(node_id={}, adj={:?})", node_id, adj);
if adj.is_identity() {
return;
{
let value = value.subst(self.tcx(), substs);
let result = self.normalize_associated_types_in(span, &value);
- debug!("instantiate_type_scheme(value={}, substs={}) = {}",
- value.repr(),
- substs.repr(),
- result.repr());
+ debug!("instantiate_type_scheme(value={:?}, substs={:?}) = {:?}",
+ value,
+ substs,
+ result);
result
}
pub fn register_predicate(&self,
obligation: traits::PredicateObligation<'tcx>)
{
- debug!("register_predicate({})",
- obligation.repr());
+ debug!("register_predicate({:?})",
+ obligation);
self.inh.fulfillment_cx
.borrow_mut()
.register_predicate_obligation(self.infcx(), obligation);
t
}
- pub fn pat_to_string(&self, pat: &ast::Pat) -> String {
- pat.repr()
- }
-
pub fn expr_ty(&self, ex: &ast::Expr) -> Ty<'tcx> {
match self.inh.node_types.borrow().get(&ex.id) {
Some(&t) => t,
{
assert!(!predicates.has_escaping_regions());
- debug!("add_obligations_for_parameters(predicates={})",
- predicates.repr());
+ debug!("add_obligations_for_parameters(predicates={:?})",
+ predicates);
for obligation in traits::predicates_for_generics(cause, predicates) {
self.register_predicate(obligation);
-> (Ty<'tcx>, usize, Option<T>)
where F: FnMut(Ty<'tcx>, usize) -> Option<T>,
{
- debug!("autoderef(base_ty={}, opt_expr={}, lvalue_pref={:?})",
- base_ty.repr(),
- opt_expr.repr(),
+ debug!("autoderef(base_ty={:?}, opt_expr={:?}, lvalue_pref={:?})",
+ base_ty,
+ opt_expr,
lvalue_pref);
let mut t = base_ty;
// 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());
+ "reached the recursion limit while auto-dereferencing {:?}",
+ base_ty);
(fcx.tcx().types.err, 0, None)
}
-> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
{
let tcx = fcx.tcx();
- debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, \
- autoderefs={}, unsize={}, index_ty={})",
- expr.repr(),
- base_expr.repr(),
- adjusted_ty.repr(),
+ debug!("try_index_step(expr={:?}, base_expr.id={:?}, adjusted_ty={:?}, \
+ autoderefs={}, unsize={}, index_ty={:?})",
+ expr,
+ base_expr,
+ adjusted_ty,
autoderefs,
unsize,
- index_ty.repr());
+ index_ty);
let input_ty = fcx.infcx().next_ty_var();
None
}
}).unwrap_or(vec![]);
- debug!("expected_types_for_fn_args(formal={} -> {}, expected={} -> {})",
- formal_args.repr(), formal_ret.repr(),
- expected_args.repr(), expected_ret.repr());
+ debug!("expected_types_for_fn_args(formal={:?} -> {:?}, expected={:?} -> {:?})",
+ formal_args, formal_ret,
+ expected_args, expected_ret);
expected_args
}
unifier: F) where
F: FnOnce(),
{
- debug!(">> typechecking: expr={} expected={}",
- expr.repr(), expected.repr());
+ debug!(">> typechecking: expr={:?} expected={:?}",
+ expr, expected);
// Checks a method call.
fn check_method_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
|base_t, _| {
match base_t.sty {
ty::TyStruct(base_id, substs) => {
- debug!("struct named {}", base_t.repr());
+ debug!("struct named {:?}", base_t);
let fields = ty::lookup_struct_fields(tcx, base_id);
fcx.lookup_field_ty(expr.span, base_id, &fields[..],
field.node.name, &(*substs))
ty::TyStruct(base_id, substs) => {
tuple_like = ty::is_tuple_struct(tcx, base_id);
if tuple_like {
- debug!("tuple struct named {}", base_t.repr());
+ debug!("tuple struct named {:?}", base_t);
let fields = ty::lookup_struct_fields(tcx, base_id);
fcx.lookup_tup_field_ty(expr.span, base_id, &fields[..],
idx.node, &(*substs))
}
} else {
tcx.sess.span_bug(expr.span,
- &format!("unbound path {}", expr.repr()))
+ &format!("unbound path {:?}", expr))
};
if let Some((opt_ty, segments, def)) =
debug!("type of expr({}) {} is...", expr.id,
syntax::print::pprust::expr_to_string(expr));
- debug!("... {}, expected is {}",
- fcx.expr_ty(expr).repr(),
- expected.repr());
+ debug!("... {:?}, expected is {:?}",
+ fcx.expr_ty(expr),
+ expected);
unifier();
}
span_err!(tcx.sess, sp, E0073,
"this type cannot be instantiated without an \
instance of itself");
- fileline_help!(tcx.sess, sp, "consider using `Option<{}>`",
- item_ty.repr());
+ fileline_help!(tcx.sess, sp, "consider using `Option<{:?}>`",
+ item_ty);
false
} else {
true
def: def::Def,
span: Span,
node_id: ast::NodeId) {
- debug!("instantiate_path(path={:?}, def={}, node_id={}, type_scheme={})",
+ debug!("instantiate_path(path={:?}, def={:?}, node_id={}, type_scheme={:?})",
segments,
- def.repr(),
+ def,
node_id,
- type_scheme.repr());
+ type_scheme);
// 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
if fcx.mk_subty(false, infer::Misc(span), self_ty, impl_ty).is_err() {
fcx.tcx().sess.span_bug(span,
&format!(
- "instantiate_path: (UFCS) {} was a subtype of {} but now is not?",
- self_ty.repr(),
- impl_ty.repr()));
+ "instantiate_path: (UFCS) {:?} was a subtype of {:?} but now is not?",
+ self_ty,
+ impl_ty));
}
}
}
assert_eq!(substs.types.len(space), desired.len());
- debug!("Final substs: {}", substs.repr());
+ debug!("Final substs: {:?}", substs);
}
fn adjust_region_parameters(
span: Span,
tps: &OwnedSlice<ast::TyParam>,
ty: Ty<'tcx>) {
- debug!("check_bounds_are_used(n_tps={}, ty={})",
- tps.len(), ty.repr());
+ debug!("check_bounds_are_used(n_tps={}, ty={:?})",
+ tps.len(), ty);
// make a vector of booleans initially false, set to true when used
if tps.is_empty() { return; }
fty,
|| {
format!("intrinsic has wrong type: expected `{}`",
- fty.user_string())
+ fty)
});
}
}
use syntax::ast;
use syntax::ast_util;
use syntax::parse::token;
-use util::ppaux::{Repr, UserString};
/// Check a `a <op>= b`
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(),
- rhs_ty.user_string());
+ lhs_ty,
+ rhs_ty);
fcx.write_error(expr.id);
}
{
let tcx = fcx.ccx.tcx;
- debug!("check_binop(expr.id={}, expr={}, op={:?}, lhs_expr={}, rhs_expr={})",
+ debug!("check_binop(expr.id={}, expr={:?}, op={:?}, lhs_expr={:?}, rhs_expr={:?})",
expr.id,
- expr.repr(),
+ expr,
op,
- lhs_expr.repr(),
- rhs_expr.repr());
+ lhs_expr,
+ rhs_expr);
check_expr(fcx, lhs_expr);
let lhs_ty = fcx.resolve_type_vars_if_possible(fcx.expr_ty(lhs_expr));
// if this is simd, result is same as lhs, else bool
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(),
- unit_ty.repr());
+ debug!("enforce_builtin_binop_types: lhs_ty={:?} unit_ty={:?}",
+ lhs_ty,
+ unit_ty);
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()));
+ lhs_ty));
tcx.types.err
} else {
lhs_ty
op: ast::BinOp)
-> (Ty<'tcx>, Ty<'tcx>)
{
- debug!("check_overloaded_binop(expr.id={}, lhs_ty={})",
+ debug!("check_overloaded_binop(expr.id={}, lhs_ty={:?})",
expr.id,
- lhs_ty.repr());
+ lhs_ty);
let (name, trait_def_id) = name_and_trait_def_id(fcx, op);
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());
+ lhs_ty);
}
fcx.tcx().types.err
}
lhs_expr: &'a ast::Expr)
-> Result<Ty<'tcx>,()>
{
- debug!("lookup_op_method(expr={}, lhs_ty={}, opname={:?}, trait_did={}, lhs_expr={})",
- expr.repr(),
- lhs_ty.repr(),
+ debug!("lookup_op_method(expr={:?}, lhs_ty={:?}, opname={:?}, trait_did={:?}, lhs_expr={:?})",
+ expr,
+ lhs_ty,
opname,
- trait_did.repr(),
- lhs_expr.repr());
+ trait_did,
+ lhs_expr);
let method = match trait_did {
Some(trait_did) => {
use middle::ty::{self, ClosureTyper, ReScope, Ty, MethodCall};
use middle::infer::{self, GenericKind};
use middle::pat_util;
-use util::ppaux::{Repr, UserString};
use std::mem;
use syntax::{ast, ast_util};
.to_vec();
for r_o in ®ion_obligations {
- debug!("visit_region_obligations: r_o={}",
- r_o.repr());
+ debug!("visit_region_obligations: r_o={:?}",
+ r_o);
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);
for &ty in fn_sig_tys {
let ty = self.resolve_type(ty);
- debug!("relate_free_regions(t={})", ty.repr());
+ debug!("relate_free_regions(t={:?})", ty);
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,
// that don't go into the free-region-map but which we use
// here.
for implication in implications {
- debug!("implication: {}", implication.repr());
+ debug!("implication: {:?}", implication);
match implication {
implicator::Implication::RegionSubRegion(_,
ty::ReFree(free_a),
self.fcx.inh.infcx.add_given(free_a, vid_b);
}
implicator::Implication::RegionSubGeneric(_, r_a, ref generic_b) => {
- debug!("RegionSubGeneric: {} <= {}",
- r_a.repr(), generic_b.repr());
+ debug!("RegionSubGeneric: {:?} <= {:?}",
+ r_a, generic_b);
self.region_bound_pairs.push((r_a, generic_b.clone()));
}
fn constrain_bindings_in_pat(pat: &ast::Pat, rcx: &mut Rcx) {
let tcx = rcx.fcx.tcx();
- debug!("regionck::visit_pat(pat={})", pat.repr());
+ debug!("regionck::visit_pat(pat={:?})", pat);
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
}
fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
- debug!("regionck::visit_expr(e={}, repeating_scope={})",
- expr.repr(), rcx.repeating_scope);
+ debug!("regionck::visit_expr(e={:?}, repeating_scope={})",
+ expr, rcx.repeating_scope);
// No matter what, the type of each expression must outlive the
// scope of that expression. This also guarantees basic WF.
cast_expr: &ast::Expr,
source_expr: &ast::Expr)
{
- debug!("constrain_cast(cast_expr={}, source_expr={})",
- cast_expr.repr(),
- source_expr.repr());
+ debug!("constrain_cast(cast_expr={:?}, source_expr={:?})",
+ cast_expr,
+ source_expr);
let source_ty = rcx.resolve_node_type(source_expr.id);
let target_ty = rcx.resolve_node_type(cast_expr.id);
cast_expr: &ast::Expr,
from_ty: Ty<'tcx>,
to_ty: Ty<'tcx>) {
- debug!("walk_cast(from_ty={}, to_ty={})",
- from_ty.repr(),
- to_ty.repr());
+ debug!("walk_cast(from_ty={:?}, to_ty={:?})",
+ from_ty,
+ to_ty);
match (&from_ty.sty, &to_ty.sty) {
/*From:*/ (&ty::TyRef(from_r, ref from_mt),
/*To: */ &ty::TyRef(to_r, ref to_mt)) => {
//
// tcx.sess.span_bug(
// callee_expr.span,
- // format!("Calling non-function: {}", callee_ty.repr()));
+ // format!("Calling non-function: {}", callee_ty));
}
}
}
//! in the type of the function. Also constrains the regions that
//! appear in the arguments appropriately.
- debug!("constrain_call(call_expr={}, \
- receiver={}, \
+ debug!("constrain_call(call_expr={:?}, \
+ receiver={:?}, \
implicitly_ref_args={})",
- call_expr.repr(),
- receiver.repr(),
+ call_expr,
+ receiver,
implicitly_ref_args);
// `callee_region` is the scope representing the time in which the
let callee_scope = CodeExtent::from_node_id(call_expr.id);
let callee_region = ty::ReScope(callee_scope);
- debug!("callee_region={}", callee_region.repr());
+ debug!("callee_region={:?}", callee_region);
for arg_expr in arg_exprs {
- debug!("Argument: {}", arg_expr.repr());
+ debug!("Argument: {:?}", arg_expr);
// ensure that any regions appearing in the argument type are
// valid for at least the lifetime of the function:
// as loop above, but for receiver
if let Some(r) = receiver {
- debug!("receiver: {}", r.repr());
+ debug!("receiver: {:?}", r);
type_of_node_must_outlive(
rcx, infer::CallRcvr(r.span),
r.id, callee_region);
derefs: usize,
mut derefd_ty: Ty<'tcx>)
{
- debug!("constrain_autoderefs(deref_expr={}, derefs={}, derefd_ty={})",
- deref_expr.repr(),
+ debug!("constrain_autoderefs(deref_expr={:?}, derefs={}, derefd_ty={:?})",
+ deref_expr,
derefs,
- derefd_ty.repr());
+ derefd_ty);
let r_deref_expr = ty::ReScope(CodeExtent::from_node_id(deref_expr.id));
for i in 0..derefs {
derefd_ty = match rcx.fcx.inh.method_map.borrow().get(&method_call) {
Some(method) => {
- debug!("constrain_autoderefs: #{} is overloaded, method={}",
- i, method.repr());
+ debug!("constrain_autoderefs: #{} is overloaded, method={:?}",
+ i, method);
// Treat overloaded autoderefs as if an AutoRef adjustment
// was applied on the base type, as that is always the case.
_ => {
rcx.tcx().sess.span_bug(
deref_expr.span,
- &format!("bad overloaded deref type {}",
- method.ty.repr()))
+ &format!("bad overloaded deref type {:?}",
+ method.ty))
}
};
debug!("constrain_autoderefs: receiver r={:?} m={:?}",
- r.repr(), m);
+ r, 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());
+ self_cmt);
link_region(rcx, deref_expr.span, r,
ty::BorrowKind::from_mutbl(m), self_cmt);
}
.sess
.span_bug(span,
&format!("unexpected rvalue region in rvalue \
- destructor safety checking: `{}`",
- region.repr()));
+ destructor safety checking: `{:?}`",
+ region));
}
}
}
|method_call| rcx.resolve_method_type(method_call));
debug!("constrain_regions_in_type_of_node(\
ty={}, ty0={}, id={}, minimum_lifetime={:?})",
- ty.user_string(), ty0.user_string(),
+ ty, ty0,
id, minimum_lifetime);
type_must_outlive(rcx, origin, ty, minimum_lifetime);
}
/// 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(), base.repr());
+ debug!("link_addr_of(expr={:?}, base={:?})", expr, base);
let cmt = {
let mc = mc::MemCategorizationContext::new(rcx.fcx);
ignore_err!(mc.cat_expr(base))
};
- debug!("link_addr_of: cmt={}", cmt.repr());
+ debug!("link_addr_of: cmt={:?}", cmt);
link_region_from_node_type(rcx, expr.span, expr.id, mutability, cmt);
}
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());
+ debug!("discr_cmt={:?}", discr_cmt);
for arm in arms {
for root_pat in &arm.pats {
link_pattern(rcx, mc, discr_cmt.clone(), &**root_pat);
let arg_ty = rcx.fcx.node_ty(arg.id);
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(),
- arg_cmt.repr());
+ debug!("arg_ty={:?} arg_cmt={:?}",
+ arg_ty,
+ arg_cmt);
link_pattern(rcx, mc, arg_cmt, &*arg.pat);
}
}
mc: mc::MemCategorizationContext<FnCtxt<'a, 'tcx>>,
discr_cmt: mc::cmt<'tcx>,
root_pat: &ast::Pat) {
- debug!("link_pattern(discr_cmt={}, root_pat={})",
- discr_cmt.repr(),
- root_pat.repr());
+ debug!("link_pattern(discr_cmt={:?}, root_pat={:?})",
+ discr_cmt,
+ root_pat);
let _ = mc.cat_pattern(discr_cmt, root_pat, |mc, sub_cmt, sub_pat| {
match sub_pat.node {
// `ref x` pattern
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());
+ debug!("expr_cmt={:?}", expr_cmt);
match *autoref {
ty::AutoPtr(r, m) => {
fn link_by_ref(rcx: &Rcx,
expr: &ast::Expr,
callee_scope: CodeExtent) {
- debug!("link_by_ref(expr={}, callee_scope={:?})",
- expr.repr(), callee_scope);
+ debug!("link_by_ref(expr={:?}, callee_scope={:?})",
+ expr, 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);
id: ast::NodeId,
mutbl: ast::Mutability,
cmt_borrowed: mc::cmt<'tcx>) {
- debug!("link_region_from_node_type(id={:?}, mutbl={:?}, cmt_borrowed={})",
- id, mutbl, cmt_borrowed.repr());
+ debug!("link_region_from_node_type(id={:?}, mutbl={:?}, cmt_borrowed={:?})",
+ id, mutbl, cmt_borrowed);
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());
+ debug!("rptr_ty={}", rptr_ty);
let r = ty::ty_region(tcx, span, rptr_ty);
link_region(rcx, span, &r, ty::BorrowKind::from_mutbl(mutbl),
cmt_borrowed);
let mut borrow_kind = borrow_kind;
loop {
- debug!("link_region(borrow_region={}, borrow_kind={}, borrow_cmt={})",
- borrow_region.repr(),
- borrow_kind.repr(),
- borrow_cmt.repr());
+ debug!("link_region(borrow_region={:?}, borrow_kind={:?}, borrow_cmt={:?})",
+ borrow_region,
+ borrow_kind,
+ borrow_cmt);
match borrow_cmt.cat.clone() {
mc::cat_deref(ref_cmt, _,
mc::Implicit(ref_kind, ref_region)) |
_ => {
rcx.tcx().sess.span_bug(
span,
- &format!("Illegal upvar id: {}",
- upvar_id.repr()));
+ &format!("Illegal upvar id: {:?}",
+ upvar_id));
}
}
}
}
};
- debug!("link_reborrowed_region: {} <= {}",
- borrow_region.repr(),
- ref_region.repr());
+ debug!("link_reborrowed_region: {:?} <= {:?}",
+ borrow_region,
+ ref_region);
rcx.fcx.mk_subr(cause, *borrow_region, ref_region);
// If we end up needing to recurse and establish a region link
ty: Ty<'tcx>,
region: ty::Region)
{
- debug!("type_must_outlive(ty={}, region={})",
- ty.repr(),
- region.repr());
+ debug!("type_must_outlive(ty={:?}, region={:?})",
+ ty,
+ region);
let implications = implicator::implications(rcx.fcx.infcx(), rcx.fcx, rcx.body_id,
ty, region, origin.span());
for implication in implications {
- debug!("implication: {}", implication.repr());
+ debug!("implication: {:?}", implication);
match implication {
implicator::Implication::RegionSubRegion(None, r_a, r_b) => {
rcx.fcx.mk_subr(origin.clone(), r_a, r_b);
region: ty::Region,
def_id: ast::DefId,
substs: &'tcx Substs<'tcx>) {
- debug!("closure_must_outlive(region={}, def_id={}, substs={})",
- region.repr(), def_id.repr(), substs.repr());
+ debug!("closure_must_outlive(region={:?}, def_id={:?}, substs={:?})",
+ region, def_id, substs);
let upvars = rcx.fcx.closure_upvars(def_id, substs).unwrap();
for upvar in upvars {
generic: &GenericKind<'tcx>) {
let param_env = &rcx.fcx.inh.param_env;
- debug!("param_must_outlive(region={}, generic={})",
- region.repr(),
- generic.repr());
+ debug!("param_must_outlive(region={:?}, generic={:?})",
+ region,
+ generic);
// To start, collect bounds from user:
let mut param_bounds =
// well-formed, then, A must be lower-generic by `'a`, but we
// don't know that this holds from first principles.
for &(ref r, ref p) in &rcx.region_bound_pairs {
- debug!("generic={} p={}",
- generic.repr(),
- p.repr());
+ debug!("generic={:?} p={:?}",
+ generic,
+ p);
if generic == p {
param_bounds.push(*r);
}
let tcx = fcx.tcx();
let infcx = fcx.infcx();
- debug!("projection_bounds(projection_ty={})",
- projection_ty.repr());
+ debug!("projection_bounds(projection_ty={:?})",
+ projection_ty);
let ty = ty::mk_projection(tcx, projection_ty.trait_ref.clone(), projection_ty.item_name);
_ => { return None; }
};
- debug!("projection_bounds: outlives={} (1)",
- outlives.repr());
+ debug!("projection_bounds: outlives={:?} (1)",
+ outlives);
// apply the substitutions (and normalize any projected types)
let outlives = fcx.instantiate_type_scheme(span,
projection_ty.trait_ref.substs,
&outlives);
- debug!("projection_bounds: outlives={} (2)",
- outlives.repr());
+ debug!("projection_bounds: outlives={:?} (2)",
+ outlives);
let region_result = infcx.commit_if_ok(|_| {
let (outlives, _) =
infer::AssocTypeProjection(projection_ty.item_name),
&outlives);
- debug!("projection_bounds: outlives={} (3)",
- outlives.repr());
+ debug!("projection_bounds: outlives={:?} (3)",
+ outlives);
// check whether this predicate applies to our current projection
match infer::mk_eqty(infcx, false, infer::Misc(span), ty, outlives.0) {
}
});
- debug!("projection_bounds: region_result={}",
- region_result.repr());
+ debug!("projection_bounds: region_result={:?}",
+ region_result);
region_result.ok()
})
use syntax::ast_util;
use syntax::codemap::Span;
use syntax::visit::{self, Visitor};
-use util::ppaux::Repr;
///////////////////////////////////////////////////////////////////////////
// PUBLIC ENTRY POINTS
if !self.fcx.inh.closure_kinds.borrow().contains_key(&closure_def_id) {
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());
+ debug!("check_closure: adding closure_id={:?} to closures_with_inferred_kinds",
+ closure_def_id);
}
ty::with_freevars(self.tcx(), expr.id, |freevars| {
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode)
{
- debug!("adjust_upvar_borrow_kind_for_consume(cmt={}, mode={:?})",
- cmt.repr(), mode);
+ debug!("adjust_upvar_borrow_kind_for_consume(cmt={:?}, mode={:?})",
+ cmt, mode);
// we only care about moves
match mode {
// for that to be legal, the upvar would have to be borrowed
// by value instead
let guarantor = cmt.guarantor();
- debug!("adjust_upvar_borrow_kind_for_consume: guarantor={}",
- guarantor.repr());
+ debug!("adjust_upvar_borrow_kind_for_consume: guarantor={:?}",
+ guarantor);
match guarantor.cat {
mc::cat_deref(_, _, mc::BorrowedPtr(..)) |
mc::cat_deref(_, _, mc::Implicit(..)) => {
/// to). If cmt contains any by-ref upvars, this implies that
/// 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());
+ debug!("adjust_upvar_borrow_kind_for_mut(cmt={:?})",
+ cmt);
match cmt.cat.clone() {
mc::cat_deref(base, _, mc::Unique) |
}
fn adjust_upvar_borrow_kind_for_unique(&self, cmt: mc::cmt<'tcx>) {
- debug!("adjust_upvar_borrow_kind_for_unique(cmt={})",
- cmt.repr());
+ debug!("adjust_upvar_borrow_kind_for_unique(cmt={:?})",
+ cmt);
match cmt.cat.clone() {
mc::cat_deref(base, _, mc::Unique) |
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode)
{
- debug!("consume(cmt={},mode={:?})", cmt.repr(), mode);
+ debug!("consume(cmt={:?},mode={:?})", cmt, mode);
self.adjust_upvar_borrow_kind_for_consume(cmt, mode);
}
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode)
{
- debug!("consume_pat(cmt={},mode={:?})", cmt.repr(), mode);
+ debug!("consume_pat(cmt={:?},mode={:?})", cmt, mode);
self.adjust_upvar_borrow_kind_for_consume(cmt, mode);
}
bk: ty::BorrowKind,
_loan_cause: euv::LoanCause)
{
- debug!("borrow(borrow_id={}, cmt={}, bk={:?})",
- borrow_id, cmt.repr(), bk);
+ debug!("borrow(borrow_id={}, cmt={:?}, bk={:?})",
+ borrow_id, cmt, bk);
match bk {
ty::ImmBorrow => { }
assignee_cmt: mc::cmt<'tcx>,
_mode: euv::MutateMode)
{
- debug!("mutate(assignee_cmt={})",
- assignee_cmt.repr());
+ debug!("mutate(assignee_cmt={:?})",
+ assignee_cmt);
self.adjust_upvar_borrow_kind_for_mut(assignee_cmt);
}
use middle::ty::{self, Ty};
use middle::ty::liberate_late_bound_regions;
use middle::ty_fold::{TypeFolder, TypeFoldable, super_fold_ty};
-use util::ppaux::{Repr, UserString};
use std::collections::HashSet;
use syntax::ast;
param_name: ast::Name)
{
span_err!(self.tcx().sess, span, E0392,
- "parameter `{}` is never used", param_name.user_string());
+ "parameter `{}` is never used", param_name);
let suggested_marker_id = self.tcx().lang_items.phantom_data();
match suggested_marker_id {
self.tcx().sess.fileline_help(
span,
&format!("consider removing `{}` or using a marker such as `{}`",
- param_name.user_string(),
+ param_name,
ty::item_path_str(self.tcx(), def_id)));
}
None => {
"cannot bound type `{}`, where clause \
bounds may only be attached to types involving \
type parameters",
- bounded_ty.repr())
+ bounded_ty)
}
fn is_ty_param(ty: ty::Ty) -> bool {
self.fcx.tcx(),
region::DestructionScopeData::new(self.scope),
binder);
- debug!("BoundsChecker::fold_binder: late-bound regions replaced: {} at scope: {:?}",
- value.repr(), self.scope);
+ debug!("BoundsChecker::fold_binder: late-bound regions replaced: {:?} at scope: {:?}",
+ value, self.scope);
let value = value.fold_with(self);
self.binding_count -= 1;
ty::Binder(value)
}
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
- debug!("BoundsChecker t={}",
- t.repr());
+ debug!("BoundsChecker t={:?}",
+ t);
match self.cache {
Some(ref mut cache) => {
use middle::infer;
use write_substs_to_tcx;
use write_ty_to_tcx;
-use util::ppaux::Repr;
use std::cell::Cell;
self.visit_node_id(ResolvingPattern(p.span), p.id);
- debug!("Type for pattern binding {} (id {}) resolved to {}",
+ debug!("Type for pattern binding {} (id {}) resolved to {:?}",
pat_to_string(p),
p.id,
- ty::node_id_to_type(self.tcx(), p.id).repr());
+ ty::node_id_to_type(self.tcx(), p.id));
visit::walk_pat(self, p);
}
ty::UpvarBorrow { kind: upvar_borrow.kind, region: r })
}
};
- debug!("Upvar capture for {} resolved to {}",
- upvar_id.repr(),
- new_upvar_capture.repr());
+ debug!("Upvar capture for {:?} resolved to {:?}",
+ upvar_id,
+ new_upvar_capture);
self.fcx.tcx().upvar_capture_map.borrow_mut().insert(*upvar_id, new_upvar_capture);
}
}
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());
+ debug!("Node {} has type {:?}", id, n_ty);
// Resolve any substitutions
self.fcx.opt_node_ty_substs(id, |item_substs| {
// Resolve any method map entry
match self.fcx.inh.method_map.borrow_mut().remove(&method_call) {
Some(method) => {
- debug!("writeback::resolve_method_map_entry(call={:?}, entry={})",
+ debug!("writeback::resolve_method_map_entry(call={:?}, entry={:?})",
method_call,
- method.repr());
+ method);
let new_method = MethodCallee {
origin: self.resolve(&method.origin, reason),
ty: self.resolve(&method.ty, reason),
match self.infcx.fully_resolve(&t) {
Ok(t) => t,
Err(e) => {
- debug!("Resolver::fold_ty: input type `{}` not fully resolvable",
- t.repr());
+ debug!("Resolver::fold_ty: input type `{:?}` not fully resolvable",
+ t);
self.report_error(e);
self.tcx().types.err
}
use syntax::parse::token;
use syntax::visit;
use util::nodemap::{DefIdMap, FnvHashMap};
-use util::ppaux::Repr;
mod orphan;
mod overlap;
inference_context.tcx.sess.span_bug(
span,
&format!("coherence encountered unexpected type searching for base type: {}",
- ty.repr()));
+ ty));
}
}
}
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(),
- token::get_ident(item.ident));
+ debug!("(checking implementation) adding impl for trait '{:?}', item '{}'",
+ trait_ref,
+ item.ident);
enforce_trait_manually_implementable(self.crate_context.tcx,
item.span,
trait_ref: &ty::TraitRef<'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());
+ debug!("instantiate_default_methods(impl_id={:?}, trait_ref={:?})",
+ impl_id, trait_ref);
let impl_type_scheme = ty::lookup_item_type(tcx, impl_id);
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());
+ debug!("new_did={:?} trait_method={:?}", new_did, trait_method);
// Create substitutions for the various trait parameters.
let new_method_ty =
&**trait_method,
Some(trait_method.def_id)));
- debug!("new_method_ty={}", new_method_ty.repr());
+ debug!("new_method_ty={:?}", new_method_ty);
all_impl_items.push(MethodTraitItemId(new_did));
// construct the polytype for the method based on the
ty: ty::mk_bare_fn(tcx, Some(new_did),
tcx.mk_bare_fn(new_method_ty.fty.clone()))
};
- debug!("new_polytype={}", new_polytype.repr());
+ debug!("new_polytype={:?}", new_polytype);
tcx.tcache.borrow_mut().insert(new_did, new_polytype);
tcx.predicates.borrow_mut().insert(new_did, new_method_ty.predicates.clone());
let copy_trait = ty::lookup_trait_def(tcx, copy_trait);
copy_trait.for_each_impl(tcx, |impl_did| {
- debug!("check_implementations_of_copy: impl_did={}",
- impl_did.repr());
+ debug!("check_implementations_of_copy: impl_did={:?}",
+ impl_did);
if impl_did.krate != ast::LOCAL_CRATE {
debug!("check_implementations_of_copy(): impl not in this \
}
let self_type = ty::lookup_item_type(tcx, impl_did);
- debug!("check_implementations_of_copy: self_type={} (bound)",
- self_type.repr());
+ debug!("check_implementations_of_copy: self_type={:?} (bound)",
+ self_type);
let span = tcx.map.span(impl_did.node);
let param_env = ParameterEnvironment::for_item(tcx, impl_did.node);
let self_type = self_type.ty.subst(tcx, ¶m_env.free_substs);
assert!(!self_type.has_escaping_regions());
- debug!("check_implementations_of_copy: self_type={} (free)",
- self_type.repr());
+ debug!("check_implementations_of_copy: self_type={:?} (free)",
+ self_type);
match ty::can_type_implement_copy(¶m_env, span, self_type) {
Ok(()) => {}
let trait_def = ty::lookup_trait_def(tcx, coerce_unsized_trait);
trait_def.for_each_impl(tcx, |impl_did| {
- debug!("check_implementations_of_coerce_unsized: impl_did={}",
- impl_did.repr());
+ debug!("check_implementations_of_coerce_unsized: impl_did={:?}",
+ impl_did);
if impl_did.krate != ast::LOCAL_CRATE {
debug!("check_implementations_of_coerce_unsized(): impl not \
let trait_ref = ty::impl_trait_ref(self.crate_context.tcx,
impl_did).unwrap();
let target = *trait_ref.substs.types.get(subst::TypeSpace, 0);
- debug!("check_implementations_of_coerce_unsized: {} -> {} (bound)",
- source.repr(), target.repr());
+ debug!("check_implementations_of_coerce_unsized: {:?} -> {:?} (bound)",
+ source, target);
let span = tcx.map.span(impl_did.node);
let param_env = ParameterEnvironment::for_item(tcx, impl_did.node);
let target = target.subst(tcx, ¶m_env.free_substs);
assert!(!source.has_escaping_regions());
- debug!("check_implementations_of_coerce_unsized: {} -> {} (free)",
- source.repr(), target.repr());
+ debug!("check_implementations_of_coerce_unsized: {:?} -> {:?} (free)",
+ source, target);
let infcx = new_infer_ctxt(tcx);
if name == token::special_names::unnamed_field {
i.to_string()
} else {
- token::get_name(name).to_string()
- },
- a.repr(),
- b.repr())
+ name.to_string()
+ }, a, b)
}).collect::<Vec<_>>().connect(", "));
return;
}
{
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());
+ debug!("subst_receiver_types_in_method_ty: combined_substs={:?}",
+ combined_substs);
let method_predicates = method.predicates.subst(tcx, &combined_substs);
let mut method_generics = method.generics.subst(tcx, &combined_substs);
impl_type_scheme.generics.regions.get_slice(space).to_vec());
}
- debug!("subst_receiver_types_in_method_ty: method_generics={}",
- method_generics.repr());
+ debug!("subst_receiver_types_in_method_ty: method_generics={:?}",
+ method_generics);
let method_fty = method.fty.subst(tcx, &combined_substs);
- debug!("subst_receiver_types_in_method_ty: method_ty={}",
- method.fty.repr());
+ debug!("subst_receiver_types_in_method_ty: method_ty={:?}",
+ method.fty);
ty::Method::new(
method.name,
use syntax::ast_util;
use syntax::codemap::Span;
use syntax::visit;
-use util::ppaux::{Repr, UserString};
pub fn check(tcx: &ty::ctxt) {
let mut orphan = OrphanChecker { tcx: 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());
+ param_ty);
return;
}
}
// This final impl is legal according to the orpan
// rules, but it invalidates the reasoning from
// `two_foos` above.
- debug!("trait_ref={} trait_def_id={} trait_has_default_impl={}",
- trait_ref.repr(),
- trait_def_id.repr(),
+ debug!("trait_ref={:?} trait_def_id={:?} trait_has_default_impl={}",
+ trait_ref,
+ trait_def_id,
ty::trait_has_default_impl(self.tcx, trait_def_id));
if
ty::trait_has_default_impl(self.tcx, trait_def_id) &&
can only be implemented for a struct/enum type, \
not `{}`",
ty::item_path_str(self.tcx, trait_def_id),
- self_ty.user_string()))
+ self_ty))
}
};
use syntax::visit;
use syntax::codemap::Span;
use util::nodemap::DefIdMap;
-use util::ppaux::{Repr, UserString};
pub fn check(tcx: &ty::ctxt) {
let mut overlap = OverlapChecker { tcx: tcx, default_impls: DefIdMap() };
fn check_for_overlapping_impls_of_trait(&self,
trait_def: &'tcx ty::TraitDef<'tcx>)
{
- debug!("check_for_overlapping_impls_of_trait(trait_def={})",
- trait_def.repr());
+ debug!("check_for_overlapping_impls_of_trait(trait_def={:?})",
+ trait_def);
// We should already know all impls of this trait, so these
// borrows are safe.
if let Some((impl1_def_id, impl2_def_id)) = self.order_impls(
impl1_def_id, impl2_def_id)
{
- debug!("check_if_impls_overlap({}, {}, {})",
- trait_def_id.repr(),
- impl1_def_id.repr(),
- impl2_def_id.repr());
+ debug!("check_if_impls_overlap({:?}, {:?}, {:?})",
+ trait_def_id,
+ impl1_def_id,
+ impl2_def_id);
let infcx = infer::new_infer_ctxt(self.tcx);
if traits::overlapping_impls(&infcx, impl1_def_id, impl2_def_id) {
span_err!(self.tcx.sess, item.span, E0371,
"the object type `{}` automatically \
implements the trait `{}`",
- trait_ref.self_ty().user_string(),
+ trait_ref.self_ty(),
ty::item_path_str(self.tcx, trait_def_id));
}
}
use syntax::ast;
use syntax::ast_util;
use syntax::visit;
-use util::ppaux::UserString;
pub fn check(tcx: &ty::ctxt) {
let mut orphan = UnsafetyChecker { tcx: tcx };
(ast::Unsafety::Normal, ast::Unsafety::Unsafe, _) => {
span_err!(self.tcx.sess, item.span, E0199,
"implementing the trait `{}` is not unsafe",
- trait_ref.user_string());
+ trait_ref);
}
(ast::Unsafety::Unsafe,
ast::Unsafety::Normal, ast::ImplPolarity::Positive) => {
span_err!(self.tcx.sess, item.span, E0200,
"the trait `{}` requires an `unsafe impl` declaration",
- trait_ref.user_string());
+ trait_ref);
}
(ast::Unsafety::Unsafe,
use rustc::ast_map;
use util::common::{ErrorReported, memoized};
use util::nodemap::{FnvHashMap, FnvHashSet};
-use util::ppaux::{Repr, UserString};
use write_ty_to_tcx;
use std::cell::{Cell, RefCell};
tcx.sess.note(
&format!("the cycle begins when computing the bounds \
for type parameter `{}`...",
- def.name.user_string()));
+ def.name));
}
}
tcx.sess.note(
&format!("...which then requires computing the bounds \
for type parameter `{}`...",
- def.name.user_string()));
+ def.name));
}
}
}
tcx.sess.note(
&format!("...which then again requires computing the bounds \
for type parameter `{}`, completing the cycle.",
- def.name.user_string()));
+ def.name));
}
}
}
let item = match tcx.map.get(trait_id.node) {
ast_map::NodeItem(item) => item,
- _ => tcx.sess.bug(&format!("get_trait_def({}): not an item", trait_id.repr()))
+ _ => tcx.sess.bug(&format!("get_trait_def({:?}): not an item", trait_id))
};
trait_def_of_item(self, &*item)
trait_def_id: ast::DefId)
-> Result<(), ErrorReported>
{
- debug!("ensure_super_predicates(trait_def_id={})",
- trait_def_id.repr());
+ debug!("ensure_super_predicates(trait_def_id={:?})",
+ trait_def_id);
self.ccx.ensure_super_predicates(span, trait_def_id)
}
let fty = ty::mk_bare_fn(ccx.tcx, Some(def_id),
ccx.tcx.mk_bare_fn(ty_method.fty.clone()));
- debug!("method {} (id {}) has type {}",
- ident, id, fty.repr());
+ debug!("method {} (id {}) has type {:?}",
+ ident, id, fty);
ccx.tcx.tcache.borrow_mut().insert(def_id,TypeScheme {
generics: ty_method.generics.clone(),
ty: fty
write_ty_to_tcx(ccx.tcx, id, fty);
- debug!("writing method type: def_id={:?} mty={}",
- def_id, ty_method.repr());
+ debug!("writing method type: def_id={:?} mty={:?}",
+ def_id, ty_method);
ccx.tcx.impl_or_trait_items.borrow_mut().insert(def_id,
ty::MethodTraitItem(Rc::new(ty_method)));
rcvr_ty_predicates: &ty::GenericPredicates<'tcx>)
where I: Iterator<Item=(&'i ast::MethodSig, ast::NodeId, ast::Ident, ast::Visibility, Span)>
{
- debug!("convert_methods(untransformed_rcvr_ty={}, rcvr_ty_generics={}, rcvr_ty_predicates={})",
- untransformed_rcvr_ty.repr(),
- rcvr_ty_generics.repr(),
- rcvr_ty_predicates.repr());
+ debug!("convert_methods(untransformed_rcvr_ty={:?}, rcvr_ty_generics={:?}, \
+ rcvr_ty_predicates={:?})",
+ untransformed_rcvr_ty,
+ rcvr_ty_generics,
+ rcvr_ty_predicates);
let tcx = ccx.tcx;
let mut seen_methods = FnvHashSet();
{
let tcx = ccx.tcx;
- debug!("ensure_super_predicates_step(trait_def_id={})", trait_def_id.repr());
+ debug!("ensure_super_predicates_step(trait_def_id={:?})", trait_def_id);
if trait_def_id.krate != ast::LOCAL_CRATE {
// If this trait comes from an external crate, then all of the
let superpredicates = ty::GenericPredicates {
predicates: VecPerParamSpace::new(superbounds, vec![], vec![])
};
- debug!("superpredicates for trait {} = {}",
- local_def(item.id).repr(),
- superpredicates.repr());
+ debug!("superpredicates for trait {:?} = {:?}",
+ local_def(item.id),
+ superpredicates);
tcx.super_predicates.borrow_mut().insert(trait_def_id, superpredicates.clone());
.map(|tr| tr.def_id())
.collect();
- debug!("ensure_super_predicates_step: def_ids={}", def_ids.repr());
+ debug!("ensure_super_predicates_step: def_ids={:?}", def_ids);
def_ids
}
scheme.generics.types.iter()
.map(|t| match t.object_lifetime_default {
Some(ty::ObjectLifetimeDefault::Specific(r)) =>
- r.user_string(),
- d =>
- d.repr(),
+ r.to_string(),
+ d => format!("{:?}", d),
})
.collect::<Vec<String>>()
.connect(",");
ast_generics: &ast::Generics)
-> ty::Generics<'tcx>
{
- debug!("ty_generics_for_trait(trait_id={}, substs={})",
- local_def(trait_id).repr(), substs.repr());
+ debug!("ty_generics_for_trait(trait_id={:?}, substs={:?})",
+ local_def(trait_id), substs);
let mut generics = ty_generics_for_type_or_impl(ccx, ast_generics);
&ty::liberate_late_bound_regions(
tcx, body_scope, &ty::Binder(base_type)));
- debug!("required_type={} required_type_free={} \
- base_type={} base_type_free={}",
- required_type.repr(),
- required_type_free.repr(),
- base_type.repr(),
- base_type_free.repr());
+ debug!("required_type={:?} required_type_free={:?} \
+ base_type={:?} base_type_free={:?}",
+ required_type,
+ required_type_free,
+ base_type,
+ base_type_free);
let infcx = infer::new_infer_ctxt(tcx);
drop(::require_same_types(tcx,
required_type_free,
|| {
format!("mismatched self type: expected `{}`",
- required_type.user_string())
+ required_type)
}));
// We could conceviably add more free-region relations here,
idx: index as u32,
name: ty_param.ident.name };
if !input_parameters.contains(&ctp::Parameter::Type(param_ty)) {
- report_unused_parameter(tcx, ty_param.span, "type", ¶m_ty.user_string());
+ report_unused_parameter(tcx, ty_param.span, "type", ¶m_ty.to_string());
}
}
!input_parameters.contains(&ctp::Parameter::Region(region))
{
report_unused_parameter(tcx, lifetime_def.lifetime.span,
- "lifetime", ®ion.name.user_string());
+ "lifetime", ®ion.name.to_string());
}
}
use rustc::ast_map;
use session::config;
use util::common::time;
-use util::ppaux::{Repr, UserString};
use syntax::codemap::Span;
use syntax::print::pprust::*;
// Functions that write types into the node type table
fn write_ty_to_tcx<'tcx>(tcx: &ty::ctxt<'tcx>, node_id: ast::NodeId, ty: Ty<'tcx>) {
- debug!("write_ty_to_tcx({}, {})", node_id, ty.repr());
+ debug!("write_ty_to_tcx({}, {:?})", node_id, ty);
assert!(!ty::type_needs_infer(ty));
tcx.node_type_insert(node_id, ty);
}
node_id: ast::NodeId,
item_substs: ty::ItemSubsts<'tcx>) {
if !item_substs.is_noop() {
- debug!("write_substs_to_tcx({}, {})",
+ debug!("write_substs_to_tcx({}, {:?})",
node_id,
- item_substs.repr());
+ item_substs);
assert!(item_substs.substs.types.all(|t| !ty::type_needs_infer(*t)));
require_same_types(tcx, None, false, main_span, main_t, se_ty,
|| {
format!("main function expects type: `{}`",
- se_ty.user_string())
+ se_ty)
});
}
_ => {
tcx.sess.span_bug(main_span,
- &format!("main has a non-function type: found \
- `{}`",
- main_t.repr()));
+ &format!("main has a non-function type: found `{}`",
+ main_t));
}
}
}
require_same_types(tcx, None, false, start_span, start_t, se_ty,
|| {
format!("start function expects type: `{}`",
- se_ty.user_string())
+ se_ty)
});
}
_ => {
tcx.sess.span_bug(start_span,
- &format!("start has a non-function type: found \
- `{}`",
- start_t.repr()));
+ &format!("start has a non-function type: found `{}`",
+ start_t));
}
}
}
use syntax::visit;
use syntax::visit::Visitor;
use util::nodemap::NodeMap;
-use util::ppaux::Repr;
pub fn infer_variance(tcx: &ty::ctxt) {
let krate = tcx.map.krate();
generics: &ty::Generics<'tcx>,
trait_ref: ty::TraitRef<'tcx>,
variance: VarianceTermPtr<'a>) {
- debug!("add_constraints_from_trait_ref: trait_ref={} variance={:?}",
- trait_ref.repr(),
+ debug!("add_constraints_from_trait_ref: trait_ref={:?} variance={:?}",
+ trait_ref,
variance);
let trait_def = ty::lookup_trait_def(self.tcx(), trait_ref.def_id);
generics: &ty::Generics<'tcx>,
ty: Ty<'tcx>,
variance: VarianceTermPtr<'a>) {
- debug!("add_constraints_from_ty(ty={}, variance={:?})",
- ty.repr(),
+ debug!("add_constraints_from_ty(ty={:?}, variance={:?})",
+ ty,
variance);
match ty.sty {
ty::TyInfer(..) => {
self.tcx().sess.bug(
&format!("unexpected type encountered in \
- variance inference: {}",
- ty.repr()));
+ variance inference: {}", ty));
}
}
}
region_param_defs: &[ty::RegionParameterDef],
substs: &subst::Substs<'tcx>,
variance: VarianceTermPtr<'a>) {
- debug!("add_constraints_from_substs(def_id={}, substs={}, variance={:?})",
- def_id.repr(),
- substs.repr(),
+ debug!("add_constraints_from_substs(def_id={:?}, substs={:?}, variance={:?})",
+ def_id,
+ substs,
variance);
for p in type_param_defs {
self.tcx()
.sess
.bug(&format!("unexpected region encountered in variance \
- inference: {}",
- region.repr()));
+ inference: {:?}",
+ region));
}
}
}
types: types,
regions: regions
};
- debug!("item_id={} item_variances={}",
+ debug!("item_id={} item_variances={:?}",
item_id,
- item_variances.repr());
+ item_variances);
let item_def_id = ast_util::local_def(item_id);
// For unit testing: check for a special "rustc_variance"
// attribute and report an error with various results if found.
if ty::has_attr(tcx, item_def_id, "rustc_variance") {
- let found = item_variances.repr();
- span_err!(tcx.sess, tcx.map.span(item_id), E0208, "{}", &found[..]);
+ span_err!(tcx.sess, tcx.map.span(item_id), E0208, "{:?}", item_variances);
}
let newly_added = tcx.item_variance_map.borrow_mut()
projects / rust.git / commitdiff