OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rustc: rename item_path to def_path (except the module in ty).

Browse Source
This commit is contained in:
Eduard-Mihai Burtescu 2018-12-19 12:31:35 +02:00
parent f1af5a77a0
commit e0c75ff40d
54 changed files with 174 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/librustc/dep_graph/dep_node.rs
View File

@ -724,7 +724,7 @@ impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> DepNodeParams<'a, 'gcx, 'tcx> for DefId {
}
fn to_debug_str(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> String {
tcx.item_path_str(*self)
tcx.def_path_str(*self)
}
}
@ -736,7 +736,7 @@ impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> DepNodeParams<'a, 'gcx, 'tcx> for DefIndex {
}
fn to_debug_str(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> String {
tcx.item_path_str(DefId::local(*self))
tcx.def_path_str(DefId::local(*self))
}
}

2
src/librustc/hir/def_id.rs
View File

@ -249,7 +249,7 @@ impl DefId {
if self.is_local() && self.index == CRATE_DEF_INDEX {
format!("top-level module")
} else {
format!("module `{}`", tcx.item_path_str(*self))
format!("module `{}`", tcx.def_path_str(*self))
}
}
}

16
src/librustc/infer/error_reporting/mod.rs
View File

@ -448,10 +448,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
// Only external crates, if either is from a local
// module we could have false positives
if !(did1.is_local() || did2.is_local()) && did1.krate != did2.krate {
let exp_path = self.tcx.item_path_str(did1);
let found_path = self.tcx.item_path_str(did2);
let exp_abs_path = self.tcx.absolute_item_path_str(did1);
let found_abs_path = self.tcx.absolute_item_path_str(did2);
let exp_path = self.tcx.def_path_str(did1);
let found_path = self.tcx.def_path_str(did2);
let exp_abs_path = self.tcx.absolute_def_path_str(did1);
let found_abs_path = self.tcx.absolute_def_path_str(did2);
// We compare strings because DefPath can be different
// for imported and non-imported crates
if exp_path == found_path || exp_abs_path == found_abs_path {
@ -658,7 +658,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
return Some(());
}
if let &ty::Adt(def, _) = &ta.sty {
let path_ = self.tcx.item_path_str(def.did.clone());
let path_ = self.tcx.def_path_str(def.did.clone());
if path_ == other_path {
self.highlight_outer(&mut t1_out, &mut t2_out, path, sub, i, &other_ty);
return Some(());
@ -757,8 +757,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
let sub_no_defaults_1 = self.strip_generic_default_params(def1.did, sub1);
let sub_no_defaults_2 = self.strip_generic_default_params(def2.did, sub2);
let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new());
let path1 = self.tcx.item_path_str(def1.did.clone());
let path2 = self.tcx.item_path_str(def2.did.clone());
let path1 = self.tcx.def_path_str(def1.did.clone());
let path2 = self.tcx.def_path_str(def2.did.clone());
if def1.did == def2.did {
// Easy case. Replace same types with `_` to shorten the output and highlight
// the differing ones.
@ -1013,7 +1013,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
if exp_is_struct && &exp_found.expected == ret_ty.skip_binder() {
let message = format!(
"did you mean `{}(/* fields */)`?",
self.tcx.item_path_str(def_id)
self.tcx.def_path_str(def_id)
);
diag.span_label(span, message);
}

4
src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs
View File

@ -193,7 +193,7 @@ impl NiceRegionError<'me, 'gcx, 'tcx> {
cause.span(&self.tcx()),
&format!(
"implementation of `{}` is not general enough",
self.tcx().item_path_str(trait_def_id),
self.tcx().def_path_str(trait_def_id),
),
);
@ -201,7 +201,7 @@ impl NiceRegionError<'me, 'gcx, 'tcx> {
ObligationCauseCode::ItemObligation(def_id) => {
err.note(&format!(
"Due to a where-clause on `{}`,",
self.tcx().item_path_str(def_id),
self.tcx().def_path_str(def_id),
));
}
_ => (),

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

@ -593,7 +593,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
.map_or(false, |parent_depr| parent_depr.same_origin(&depr_entry));
if !skip {
let path = self.item_path_str(def_id);
let path = self.def_path_str(def_id);
let message = format!("use of deprecated item '{}'", path);
lint_deprecated(def_id,
id,
@ -620,7 +620,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
if let Some(id) = id {
if let Some(stability) = stability {
if let Some(depr) = &stability.rustc_depr {
let path = self.item_path_str(def_id);
let path = self.def_path_str(def_id);
if deprecation_in_effect(&depr.since.as_str()) {
let message = format!("use of deprecated item '{}'", path);
lint_deprecated(def_id,

8
src/librustc/mir/mod.rs
View File

@ -2062,7 +2062,7 @@ impl<'tcx> Debug for Place<'tcx> {
Base(PlaceBase::Static(box self::Static { def_id, ty })) => write!(
fmt,
"({}: {:?})",
ty::tls::with(|tcx| tcx.item_path_str(def_id)),
ty::tls::with(|tcx| tcx.def_path_str(def_id)),
ty
),
Base(PlaceBase::Promoted(ref promoted)) => write!(
@ -2731,7 +2731,7 @@ pub fn fmt_const_val(f: &mut impl Write, const_val: ty::Const<'_>) -> fmt::Resul
}
// print function definitions
if let FnDef(did, _) = ty.sty {
return write!(f, "{}", item_path_str(did));
return write!(f, "{}", def_path_str(did));
}
// print string literals
if let ConstValue::Slice(ptr, len) = value {
@ -2756,8 +2756,8 @@ pub fn fmt_const_val(f: &mut impl Write, const_val: ty::Const<'_>) -> fmt::Resul
write!(f, "{:?}:{}", value, ty)
}
fn item_path_str(def_id: DefId) -> String {
ty::tls::with(|tcx| tcx.item_path_str(def_id))
fn def_path_str(def_id: DefId) -> String {
ty::tls::with(|tcx| tcx.def_path_str(def_id))
}
impl<'tcx> graph::DirectedGraph for Mir<'tcx> {

8
src/librustc/traits/error_reporting.rs
View File

@ -1285,11 +1285,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
let span = self.sess.source_map().def_span(span);
let mut err = struct_span_err!(self.sess, span, E0072,
"recursive type `{}` has infinite size",
self.item_path_str(type_def_id));
self.def_path_str(type_def_id));
err.span_label(span, "recursive type has infinite size");
err.help(&format!("insert indirection (e.g., a `Box`, `Rc`, or `&`) \
at some point to make `{}` representable",
self.item_path_str(type_def_id)));
self.def_path_str(type_def_id)));
err
}
@ -1299,7 +1299,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
violations: Vec<ObjectSafetyViolation>)
-> DiagnosticBuilder<'tcx>
{
let trait_str = self.item_path_str(trait_def_id);
let trait_str = self.def_path_str(trait_def_id);
let span = self.sess.source_map().def_span(span);
let mut err = struct_span_err!(
self.sess, span, E0038,
@ -1524,7 +1524,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
region, object_ty));
}
ObligationCauseCode::ItemObligation(item_def_id) => {
let item_name = tcx.item_path_str(item_def_id);
let item_name = tcx.def_path_str(item_def_id);
let msg = format!("required by `{}`", item_name);
if let Some(sp) = tcx.hir().span_if_local(item_def_id) {

8
src/librustc/traits/mod.rs
View File

@ -650,7 +650,7 @@ pub fn type_known_to_meet_bound_modulo_regions<'a, 'gcx, 'tcx>(
) -> bool {
debug!("type_known_to_meet_bound_modulo_regions(ty={:?}, bound={:?})",
ty,
infcx.tcx.item_path_str(def_id));
infcx.tcx.def_path_str(def_id));
let trait_ref = ty::TraitRef {
def_id,
@ -665,7 +665,7 @@ pub fn type_known_to_meet_bound_modulo_regions<'a, 'gcx, 'tcx>(
let result = infcx.predicate_must_hold_modulo_regions(&obligation);
debug!("type_known_to_meet_ty={:?} bound={} => {:?}",
ty, infcx.tcx.item_path_str(def_id), result);
ty, infcx.tcx.def_path_str(def_id), result);
if result && (ty.has_infer_types() || ty.has_closure_types()) {
// Because of inference "guessing", selection can sometimes claim
@ -692,13 +692,13 @@ pub fn type_known_to_meet_bound_modulo_regions<'a, 'gcx, 'tcx>(
Ok(()) => {
debug!("type_known_to_meet_bound_modulo_regions: ty={:?} bound={} success",
ty,
infcx.tcx.item_path_str(def_id));
infcx.tcx.def_path_str(def_id));
true
}
Err(e) => {
debug!("type_known_to_meet_bound_modulo_regions: ty={:?} bound={} errors={:?}",
ty,
infcx.tcx.item_path_str(def_id),
infcx.tcx.def_path_str(def_id),
e);
false
}

2
src/librustc/traits/object_safety.rs
View File

@ -133,7 +133,7 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
hir::CRATE_HIR_ID,
*span,
&format!("the trait `{}` cannot be made into an object",
self.item_path_str(trait_def_id)),
self.def_path_str(trait_def_id)),
&violation.error_msg());
false
} else {

2
src/librustc/traits/on_unimplemented.rs
View File

@ -276,7 +276,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString {
-> String
{
let name = tcx.item_name(trait_ref.def_id);
let trait_str = tcx.item_path_str(trait_ref.def_id);
let trait_str = tcx.def_path_str(trait_ref.def_id);
let generics = tcx.generics_of(trait_ref.def_id);
let generic_map = generics.params.iter().filter_map(|param| {
let value = match param.kind {

2
src/librustc/traits/project.rs
View File

@ -1549,7 +1549,7 @@ fn assoc_ty_def<'cx, 'gcx, 'tcx>(
// should have failed in astconv.
bug!("No associated type `{}` for {}",
assoc_ty_name,
tcx.item_path_str(impl_def_id))
tcx.def_path_str(impl_def_id))
}
}

14
src/librustc/ty/error.rs
View File

@ -125,9 +125,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
Traits(values) => ty::tls::with(|tcx| {
report_maybe_different(f,
&format!("trait `{}`",
tcx.item_path_str(values.expected)),
tcx.def_path_str(values.expected)),
&format!("trait `{}`",
tcx.item_path_str(values.found)))
tcx.def_path_str(values.found)))
}),
IntMismatch(ref values) => {
write!(f, "expected `{:?}`, found `{:?}`",
@ -146,8 +146,8 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
}
ProjectionMismatched(ref values) => ty::tls::with(|tcx| {
write!(f, "expected {}, found {}",
tcx.item_path_str(values.expected),
tcx.item_path_str(values.found))
tcx.def_path_str(values.expected),
tcx.def_path_str(values.found))
}),
ProjectionBoundsLength(ref values) => {
write!(f, "expected {} associated type bindings, found {}",
@ -169,8 +169,8 @@ impl<'a, 'gcx, 'lcx, 'tcx> ty::TyS<'tcx> {
ty::Uint(_) | ty::Float(_) | ty::Str | ty::Never => self.to_string().into(),
ty::Tuple(ref tys) if tys.is_empty() => self.to_string().into(),
ty::Adt(def, _) => format!("{} `{}`", def.descr(), tcx.item_path_str(def.did)).into(),
ty::Foreign(def_id) => format!("extern type `{}`", tcx.item_path_str(def_id)).into(),
ty::Adt(def, _) => format!("{} `{}`", def.descr(), tcx.def_path_str(def.did)).into(),
ty::Foreign(def_id) => format!("extern type `{}`", tcx.def_path_str(def_id)).into(),
ty::Array(_, n) => match n {
ty::LazyConst::Evaluated(n) => match n.assert_usize(tcx) {
Some(n) => format!("array of {} elements", n).into(),
@ -199,7 +199,7 @@ impl<'a, 'gcx, 'lcx, 'tcx> ty::TyS<'tcx> {
ty::FnPtr(_) => "fn pointer".into(),
ty::Dynamic(ref inner, ..) => {
if let Some(principal) = inner.principal() {
format!("trait {}", tcx.item_path_str(principal.def_id())).into()
format!("trait {}", tcx.def_path_str(principal.def_id())).into()
} else {
"trait".into()
}

68
src/librustc/ty/item_path.rs
View File

@ -16,7 +16,7 @@ thread_local! {
static SHOULD_PREFIX_WITH_CRATE: Cell<bool> = Cell::new(false);
}
/// Enforces that item_path_str always returns an absolute path and
/// Enforces that def_path_str always returns an absolute path and
/// also enables "type-based" impl paths. This is used when building
/// symbols that contain types, where we want the crate name to be
/// part of the symbol.
@ -56,7 +56,7 @@ pub fn with_crate_prefix<F: FnOnce() -> R, R>(f: F) -> R {
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
// HACK(eddyb) get rid of `item_path_str` and/or pass `Namespace` explicitly always
// HACK(eddyb) get rid of `def_path_str` and/or pass `Namespace` explicitly always
// (but also some things just print a `DefId` generally so maybe we need this?)
fn guess_def_namespace(self, def_id: DefId) -> Namespace {
match self.def_key(def_id).disambiguated_data.data {
@ -76,52 +76,52 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
/// Returns a string identifying this `DefId`. This string is
/// suitable for user output. It is relative to the current crate
/// root, unless with_forced_absolute_paths was used.
pub fn item_path_str_with_substs_and_ns(
pub fn def_path_str_with_substs_and_ns(
self,
def_id: DefId,
substs: Option<SubstsRef<'tcx>>,
ns: Namespace,
) -> String {
debug!("item_path_str: def_id={:?}, substs={:?}, ns={:?}", def_id, substs, ns);
debug!("def_path_str: def_id={:?}, substs={:?}, ns={:?}", def_id, substs, ns);
if FORCE_ABSOLUTE.with(|force| force.get()) {
PrintCx::new(self, AbsolutePathPrinter).print_item_path(def_id, substs, ns)
PrintCx::new(self, AbsolutePathPrinter).print_def_path(def_id, substs, ns)
} else {
PrintCx::new(self, LocalPathPrinter).print_item_path(def_id, substs, ns)
PrintCx::new(self, LocalPathPrinter).print_def_path(def_id, substs, ns)
}
}
/// Returns a string identifying this def-id. This string is
/// suitable for user output. It is relative to the current crate
/// root, unless with_forced_absolute_paths was used.
pub fn item_path_str(self, def_id: DefId) -> String {
pub fn def_path_str(self, def_id: DefId) -> String {
let ns = self.guess_def_namespace(def_id);
self.item_path_str_with_substs_and_ns(def_id, None, ns)
self.def_path_str_with_substs_and_ns(def_id, None, ns)
}
/// Returns a string identifying this local node-id.
pub fn node_path_str(self, id: ast::NodeId) -> String {
self.item_path_str(self.hir().local_def_id(id))
self.def_path_str(self.hir().local_def_id(id))
}
/// Returns a string identifying this def-id. This string is
/// suitable for user output. It always begins with a crate identifier.
pub fn absolute_item_path_str(self, def_id: DefId) -> String {
debug!("absolute_item_path_str: def_id={:?}", def_id);
pub fn absolute_def_path_str(self, def_id: DefId) -> String {
debug!("absolute_def_path_str: def_id={:?}", def_id);
let ns = self.guess_def_namespace(def_id);
PrintCx::new(self, AbsolutePathPrinter).print_item_path(def_id, None, ns)
PrintCx::new(self, AbsolutePathPrinter).print_def_path(def_id, None, ns)
}
}
impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
pub fn default_print_item_path(
pub fn default_print_def_path(
&mut self,
def_id: DefId,
substs: Option<SubstsRef<'tcx>>,
ns: Namespace,
) -> P::Path {
debug!("default_print_item_path: def_id={:?}, substs={:?}, ns={:?}", def_id, substs, ns);
debug!("default_print_def_path: def_id={:?}, substs={:?}, ns={:?}", def_id, substs, ns);
let key = self.tcx.def_key(def_id);
debug!("default_print_item_path: key={:?}", key);
debug!("default_print_def_path: key={:?}", key);
match key.disambiguated_data.data {
DefPathData::CrateRoot => {
assert!(key.parent.is_none());
@ -155,13 +155,13 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
data @ DefPathData::ImplTrait |
data @ DefPathData::GlobalMetaData(..) => {
let parent_did = self.tcx.parent(def_id).unwrap();
let path = self.print_item_path(parent_did, None, ns);
let path = self.print_def_path(parent_did, None, ns);
self.path_append(path, &data.as_interned_str().as_symbol().as_str())
},
DefPathData::StructCtor => { // present `X` instead of `X::{{constructor}}`
let parent_def_id = self.tcx.parent(def_id).unwrap();
self.print_item_path(parent_def_id, substs, ns)
self.print_def_path(parent_def_id, substs, ns)
}
}
}
@ -202,7 +202,7 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
// If the impl is not co-located with either self-type or
// trait-type, then fallback to a format that identifies
// the module more clearly.
let path = self.print_item_path(parent_def_id, None, ns);
let path = self.print_def_path(parent_def_id, None, ns);
if let Some(trait_ref) = impl_trait_ref {
return self.path_append(path, &format!("<impl {} for {}>", trait_ref, self_ty));
} else {
@ -224,13 +224,13 @@ impl<P: ItemPathPrinter> PrintCx<'a, 'gcx, 'tcx, P> {
match self_ty.sty {
ty::Adt(adt_def, substs) => {
// FIXME(eddyb) this should recurse to build the path piecewise.
// self.print_item_path(adt_def.did, Some(substs), ns)
// self.print_def_path(adt_def.did, Some(substs), ns)
let mut s = String::new();
crate::util::ppaux::parameterized(&mut s, adt_def.did, substs, ns).unwrap();
self.path_impl(&s)
}
ty::Foreign(did) => self.print_item_path(did, None, ns),
ty::Foreign(did) => self.print_def_path(did, None, ns),
ty::Bool |
ty::Char |
@ -301,13 +301,13 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
pub trait ItemPathPrinter: Sized {
type Path;
fn print_item_path(
fn print_def_path(
self: &mut PrintCx<'_, '_, 'tcx, Self>,
def_id: DefId,
substs: Option<SubstsRef<'tcx>>,
ns: Namespace,
) -> Self::Path {
self.default_print_item_path(def_id, substs, ns)
self.default_print_def_path(def_id, substs, ns)
}
fn print_impl_path(
self: &mut PrintCx<'_, '_, 'tcx, Self>,
@ -357,12 +357,12 @@ impl LocalPathPrinter {
/// If possible, this returns a global path resolving to `def_id` that is visible
/// from at least one local module and returns true. If the crate defining `def_id` is
/// declared with an `extern crate`, the path is guaranteed to use the `extern crate`.
fn try_print_visible_item_path(
fn try_print_visible_def_path(
self: &mut PrintCx<'_, '_, '_, Self>,
def_id: DefId,
ns: Namespace,
) -> Option<<Self as ItemPathPrinter>::Path> {
debug!("try_print_visible_item_path: def_id={:?}", def_id);
debug!("try_print_visible_def_path: def_id={:?}", def_id);
// If `def_id` is a direct or injected extern crate, return the
// path to the crate followed by the path to the item within the crate.
@ -390,9 +390,9 @@ impl LocalPathPrinter {
span,
..
}) => {
debug!("try_print_visible_item_path: def_id={:?}", def_id);
debug!("try_print_visible_def_path: def_id={:?}", def_id);
let path = if !span.is_dummy() {
self.print_item_path(def_id, None, ns)
self.print_def_path(def_id, None, ns)
} else {
self.path_crate(cnum)
};
@ -412,7 +412,7 @@ impl LocalPathPrinter {
let visible_parent_map = self.tcx.visible_parent_map(LOCAL_CRATE);
let mut cur_def_key = self.tcx.def_key(def_id);
debug!("try_print_visible_item_path: cur_def_key={:?}", cur_def_key);
debug!("try_print_visible_def_path: cur_def_key={:?}", cur_def_key);
// For a UnitStruct or TupleStruct we want the name of its parent rather than <unnamed>.
if let DefPathData::StructCtor = cur_def_key.disambiguated_data.data {
@ -425,12 +425,12 @@ impl LocalPathPrinter {
}
let visible_parent = visible_parent_map.get(&def_id).cloned()?;
let path = self.try_print_visible_item_path(visible_parent, ns)?;
let path = self.try_print_visible_def_path(visible_parent, ns)?;
let actual_parent = self.tcx.parent(def_id);
let data = cur_def_key.disambiguated_data.data;
debug!(
"try_print_visible_item_path: data={:?} visible_parent={:?} actual_parent={:?}",
"try_print_visible_def_path: data={:?} visible_parent={:?} actual_parent={:?}",
data, visible_parent, actual_parent,
);
@ -485,7 +485,7 @@ impl LocalPathPrinter {
})
},
};
debug!("try_print_visible_item_path: symbol={:?}", symbol);
debug!("try_print_visible_def_path: symbol={:?}", symbol);
Some(self.path_append(path, &symbol))
}
}
@ -493,14 +493,14 @@ impl LocalPathPrinter {
impl ItemPathPrinter for LocalPathPrinter {
type Path = String;
fn print_item_path(
fn print_def_path(
self: &mut PrintCx<'_, '_, 'tcx, Self>,
def_id: DefId,
substs: Option<SubstsRef<'tcx>>,
ns: Namespace,
) -> Self::Path {
self.try_print_visible_item_path(def_id, ns)
.unwrap_or_else(|| self.default_print_item_path(def_id, substs, ns))
self.try_print_visible_def_path(def_id, ns)
.unwrap_or_else(|| self.default_print_def_path(def_id, substs, ns))
}
fn print_impl_path(
self: &mut PrintCx<'_, '_, 'tcx, Self>,
@ -522,7 +522,7 @@ impl ItemPathPrinter for LocalPathPrinter {
// only occur very early in the compiler pipeline.
// FIXME(eddyb) this should just be using `tcx.def_span(impl_def_id)`
let parent_def_id = self.tcx.parent(impl_def_id).unwrap();
let path = self.print_item_path(parent_def_id, None, ns);
let path = self.print_def_path(parent_def_id, None, ns);
let span = self.tcx.def_span(impl_def_id);
return self.path_append(path, &format!("<impl at {:?}>", span));
}

2
src/librustc/ty/mod.rs
View File

@ -2056,7 +2056,7 @@ impl ReprOptions {
}
// This is here instead of layout because the choice must make it into metadata.
if !tcx.consider_optimizing(|| format!("Reorder fields of {:?}", tcx.item_path_str(did))) {
if !tcx.consider_optimizing(|| format!("Reorder fields of {:?}", tcx.def_path_str(did))) {
flags.insert(ReprFlags::IS_LINEAR);
}
ReprOptions { int: size, align: max_align, pack: min_pack, flags: flags }

32
src/librustc/ty/query/config.rs
View File

@ -71,7 +71,7 @@ pub(super) trait QueryDescription<'tcx>: QueryAccessors<'tcx> {
impl<'tcx, M: QueryAccessors<'tcx, Key=DefId>> QueryDescription<'tcx> for M {
default fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
if !tcx.sess.verbose() {
format!("processing `{}`", tcx.item_path_str(def_id)).into()
format!("processing `{}`", tcx.def_path_str(def_id)).into()
} else {
let name = unsafe { ::std::intrinsics::type_name::<M>() };
format!("processing {:?} with query `{}`", def_id, name).into()
@ -301,7 +301,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::layout_raw<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::super_predicates_of<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("computing the supertraits of `{}`",
tcx.item_path_str(def_id)).into()
tcx.def_path_str(def_id)).into()
}
}
@ -322,7 +322,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::type_param_predicates<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::coherent_trait<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("coherence checking all impls of trait `{}`",
tcx.item_path_str(def_id)).into()
tcx.def_path_str(def_id)).into()
}
}
@ -359,7 +359,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::inferred_outlives_crate<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::mir_shims<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def: ty::InstanceDef<'tcx>) -> Cow<'static, str> {
format!("generating MIR shim for `{}`",
tcx.item_path_str(def.def_id())).into()
tcx.def_path_str(def.def_id())).into()
}
}
@ -394,7 +394,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::const_eval<'tcx> {
) -> Cow<'static, str> {
format!(
"const-evaluating + checking `{}`",
tcx.item_path_str(key.value.instance.def.def_id()),
tcx.def_path_str(key.value.instance.def.def_id()),
).into()
}
@ -415,7 +415,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::const_eval_raw<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, key: ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>)
-> Cow<'static, str>
{
format!("const-evaluating `{}`", tcx.item_path_str(key.value.instance.def.def_id())).into()
format!("const-evaluating `{}`", tcx.def_path_str(key.value.instance.def.def_id())).into()
}
#[inline]
@ -513,7 +513,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::trait_of_item<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::const_is_rvalue_promotable_to_static<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("const checking if rvalue is promotable to static `{}`",
tcx.item_path_str(def_id)).into()
tcx.def_path_str(def_id)).into()
}
#[inline]
@ -532,21 +532,21 @@ impl<'tcx> QueryDescription<'tcx> for queries::const_is_rvalue_promotable_to_sta
impl<'tcx> QueryDescription<'tcx> for queries::rvalue_promotable_map<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("checking which parts of `{}` are promotable to static",
tcx.item_path_str(def_id)).into()
tcx.def_path_str(def_id)).into()
}
}
impl<'tcx> QueryDescription<'tcx> for queries::is_mir_available<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("checking if item is mir available: `{}`",
tcx.item_path_str(def_id)).into()
tcx.def_path_str(def_id)).into()
}
}
impl<'tcx> QueryDescription<'tcx> for queries::codegen_fulfill_obligation<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>,
key: (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>)) -> Cow<'static, str> {
format!("checking if `{}` fulfills its obligations", tcx.item_path_str(key.1.def_id()))
format!("checking if `{}` fulfills its obligations", tcx.def_path_str(key.1.def_id()))
.into()
}
@ -565,19 +565,19 @@ impl<'tcx> QueryDescription<'tcx> for queries::codegen_fulfill_obligation<'tcx>
impl<'tcx> QueryDescription<'tcx> for queries::trait_impls_of<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("trait impls of `{}`", tcx.item_path_str(def_id)).into()
format!("trait impls of `{}`", tcx.def_path_str(def_id)).into()
}
}
impl<'tcx> QueryDescription<'tcx> for queries::is_object_safe<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("determine object safety of trait `{}`", tcx.item_path_str(def_id)).into()
format!("determine object safety of trait `{}`", tcx.def_path_str(def_id)).into()
}
}
impl<'tcx> QueryDescription<'tcx> for queries::is_const_fn_raw<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Cow<'static, str> {
format!("checking if item is const fn: `{}`", tcx.item_path_str(def_id)).into()
format!("checking if item is const fn: `{}`", tcx.def_path_str(def_id)).into()
}
}
@ -883,7 +883,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::output_filenames<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::vtable_methods<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, key: ty::PolyTraitRef<'tcx> ) -> Cow<'static, str> {
format!("finding all methods for trait {}", tcx.item_path_str(key.def_id())).into()
format!("finding all methods for trait {}", tcx.def_path_str(key.def_id())).into()
}
}
@ -927,7 +927,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::optimized_mir<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::substitute_normalize_and_test_predicates<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, key: (DefId, SubstsRef<'tcx>)) -> Cow<'static, str> {
format!("testing substituted normalized predicates:`{}`", tcx.item_path_str(key.0)).into()
format!("testing substituted normalized predicates:`{}`", tcx.def_path_str(key.0)).into()
}
}
@ -945,7 +945,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::target_features_whitelist<'tcx> {
impl<'tcx> QueryDescription<'tcx> for queries::instance_def_size_estimate<'tcx> {
fn describe(tcx: TyCtxt<'_, '_, '_>, def: ty::InstanceDef<'tcx>) -> Cow<'static, str> {
format!("estimating size for `{}`", tcx.item_path_str(def.def_id())).into()
format!("estimating size for `{}`", tcx.def_path_str(def.def_id())).into()
}
}

14
src/librustc/util/ppaux.rs
View File

@ -320,7 +320,7 @@ impl<F: fmt::Write> PrintCx<'a, 'gcx, 'tcx, FmtPrinter<F>> {
// FIXME(eddyb) recurse through printing a path via `self`, instead
// instead of using the `tcx` method that produces a `String`.
print!(self, write("{}",
self.tcx.item_path_str_with_substs_and_ns(def_id, Some(substs), ns)))?;
self.tcx.def_path_str_with_substs_and_ns(def_id, Some(substs), ns)))?;
// For impls, the above call already prints relevant generics args.
if let DefPathData::Impl = key.disambiguated_data.data {
@ -515,7 +515,7 @@ define_print! {
if let Tuple(ref args) = principal.substs.type_at(0).sty {
let mut projections = self.projection_bounds();
if let (Some(proj), None) = (projections.next(), projections.next()) {
print!(cx, write("{}", cx.tcx.item_path_str(principal.def_id)))?;
print!(cx, write("{}", cx.tcx.def_path_str(principal.def_id)))?;
cx.fn_sig(args, false, proj.ty)?;
resugared_principal = true;
}
@ -538,7 +538,7 @@ define_print! {
// Builtin bounds.
let mut auto_traits: Vec<_> = self.auto_traits().map(|did| {
cx.tcx.item_path_str(did)
cx.tcx.def_path_str(did)
}).collect();
// The auto traits come ordered by `DefPathHash`. While
@ -582,7 +582,7 @@ impl fmt::Debug for ty::GenericParamDef {
impl fmt::Debug for ty::TraitDef {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
PrintCx::with(FmtPrinter { fmt: f }, |cx| {
print!(cx, write("{}", cx.tcx.item_path_str(self.def_id)))
print!(cx, write("{}", cx.tcx.def_path_str(self.def_id)))
})
}
}
@ -590,7 +590,7 @@ impl fmt::Debug for ty::TraitDef {
impl fmt::Debug for ty::AdtDef {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
PrintCx::with(FmtPrinter { fmt: f }, |cx| {
print!(cx, write("{}", cx.tcx.item_path_str(self.did)))
print!(cx, write("{}", cx.tcx.def_path_str(self.did)))
})
}
}
@ -1513,11 +1513,11 @@ define_print! {
ty::Predicate::WellFormed(ty) => print!(cx, print(ty), write(" well-formed")),
ty::Predicate::ObjectSafe(trait_def_id) => {
print!(cx, write("the trait `{}` is object-safe",
cx.tcx.item_path_str(trait_def_id)))
cx.tcx.def_path_str(trait_def_id)))
}
ty::Predicate::ClosureKind(closure_def_id, _closure_substs, kind) => {
print!(cx, write("the closure `{}` implements the trait `{}`",
cx.tcx.item_path_str(closure_def_id), kind))
cx.tcx.def_path_str(closure_def_id), kind))
}
ty::Predicate::ConstEvaluatable(def_id, substs) => {
print!(cx, write("the constant `"))?;

8
src/librustc_borrowck/borrowck/mod.rs
View File

@ -1406,7 +1406,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
out.push('(');
self.append_loan_path_to_string(&lp_base, out);
out.push_str(DOWNCAST_PRINTED_OPERATOR);
out.push_str(&self.tcx.item_path_str(variant_def_id));
out.push_str(&self.tcx.def_path_str(variant_def_id));
out.push(')');
}
@ -1443,7 +1443,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
out.push('(');
self.append_autoderefd_loan_path_to_string(&lp_base, out);
out.push_str(DOWNCAST_PRINTED_OPERATOR);
out.push_str(&self.tcx.item_path_str(variant_def_id));
out.push_str(&self.tcx.def_path_str(variant_def_id));
out.push(')');
}
@ -1523,7 +1523,7 @@ impl<'tcx> fmt::Debug for LoanPath<'tcx> {
LpDowncast(ref lp, variant_def_id) => {
let variant_str = if variant_def_id.is_local() {
ty::tls::with(|tcx| tcx.item_path_str(variant_def_id))
ty::tls::with(|tcx| tcx.def_path_str(variant_def_id))
} else {
format!("{:?}", variant_def_id)
};
@ -1558,7 +1558,7 @@ impl<'tcx> fmt::Display for LoanPath<'tcx> {
LpDowncast(ref lp, variant_def_id) => {
let variant_str = if variant_def_id.is_local() {
ty::tls::with(|tcx| tcx.item_path_str(variant_def_id))
ty::tls::with(|tcx| tcx.def_path_str(variant_def_id))
} else {
format!("{:?}", variant_def_id)
};

2
src/librustc_codegen_utils/symbol_names.rs
View File

@ -227,7 +227,7 @@ fn get_symbol_hash<'a, 'tcx>(
fn def_symbol_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> ty::SymbolName {
item_path::with_forced_absolute_paths(|| {
PrintCx::new(tcx, SymbolPathPrinter)
.print_item_path(def_id, None, Namespace::ValueNS)
.print_def_path(def_id, None, Namespace::ValueNS)
.into_interned()
})
}

12
src/librustc_codegen_utils/symbol_names_test.rs
View File

@ -1,7 +1,7 @@
//! Walks the crate looking for items/impl-items/trait-items that have
//! either a `rustc_symbol_name` or `rustc_item_path` attribute and
//! either a `rustc_symbol_name` or `rustc_def_path` attribute and
//! generates an error giving, respectively, the symbol name or
//! item-path. This is used for unit testing the code that generates
//! def-path. This is used for unit testing the code that generates
//! paths etc in all kinds of annoying scenarios.
use rustc::hir;
@ -10,7 +10,7 @@ use rustc::ty::TyCtxt;
use rustc_mir::monomorphize::Instance;
const SYMBOL_NAME: &'static str = "rustc_symbol_name";
const ITEM_PATH: &'static str = "rustc_item_path";
const DEF_PATH: &'static str = "rustc_def_path";
pub fn report_symbol_names<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
// if the `rustc_attrs` feature is not enabled, then the
@ -41,9 +41,9 @@ impl<'a, 'tcx> SymbolNamesTest<'a, 'tcx> {
let instance = Instance::mono(tcx, def_id);
let name = self.tcx.symbol_name(instance);
tcx.sess.span_err(attr.span, &format!("symbol-name({})", name));
} else if attr.check_name(ITEM_PATH) {
let path = tcx.item_path_str(def_id);
tcx.sess.span_err(attr.span, &format!("item-path({})", path));
} else if attr.check_name(DEF_PATH) {
let path = tcx.def_path_str(def_id);
tcx.sess.span_err(attr.span, &format!("def-path({})", path));
}
// (*) The formatting of `tag({})` is chosen so that tests can elect

2
src/librustc_incremental/assert_dep_graph.rs
View File

@ -206,7 +206,7 @@ fn check_paths<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
tcx.sess.span_err(
target_span,
&format!("no path from `{}` to `{}`",
tcx.item_path_str(source_def_id),
tcx.def_path_str(source_def_id),
target_pass));
} else {
tcx.sess.span_err(

2
src/librustc_incremental/persist/dirty_clean.rs
View File

@ -463,7 +463,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
if let Some(def_id) = dep_node.extract_def_id(self.tcx) {
format!("{:?}({})",
dep_node.kind,
self.tcx.item_path_str(def_id))
self.tcx.def_path_str(def_id))
} else {
format!("{:?}({:?})", dep_node.kind, dep_node.hash)
}

2
src/librustc_lint/unused.rs
View File

@ -182,7 +182,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults {
for attr in cx.tcx.get_attrs(def_id).iter() {
if attr.check_name("must_use") {
let msg = format!("unused {}`{}`{} that must be used",
descr_pre_path, cx.tcx.item_path_str(def_id), descr_post_path);
descr_pre_path, cx.tcx.def_path_str(def_id), descr_post_path);
let mut err = cx.struct_span_lint(UNUSED_MUST_USE, sp, &msg);
// check for #[must_use = "..."]
if let Some(note) = attr.value_str() {

2
src/librustc_mir/borrow_check/mod.rs
View File

@ -68,7 +68,7 @@ pub fn provide(providers: &mut Providers<'_>) {
fn mir_borrowck<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> BorrowCheckResult<'tcx> {
let input_mir = tcx.mir_validated(def_id);
debug!("run query mir_borrowck: {}", tcx.item_path_str(def_id));
debug!("run query mir_borrowck: {}", tcx.def_path_str(def_id));
let mut return_early;

2
src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs
View File

@ -93,7 +93,7 @@ impl BorrowExplanation {
// simplify output by reporting just the ADT name.
ty::Adt(adt, _substs) if adt.has_dtor(tcx) && !adt.is_box() => (
"`Drop` code",
format!("type `{}`", tcx.item_path_str(adt.did)),
format!("type `{}`", tcx.def_path_str(adt.did)),
),
// Otherwise, just report the whole type (and use

2
src/librustc_mir/const_eval.rs
View File

@ -142,7 +142,7 @@ fn eval_body_using_ecx<'mir, 'tcx>(
assert!(!layout.is_unsized());
let ret = ecx.allocate(layout, MemoryKind::Stack);
let name = ty::tls::with(|tcx| tcx.item_path_str(cid.instance.def_id()));
let name = ty::tls::with(|tcx| tcx.def_path_str(cid.instance.def_id()));
let prom = cid.promoted.map_or(String::new(), |p| format!("::promoted[{:?}]", p));
trace!("eval_body_using_ecx: pushing stack frame for global: {}{}", name, prom);
assert!(mir.arg_count == 0);

2
src/librustc_mir/hair/pattern/check_match.rs
View File

@ -319,7 +319,7 @@ fn check_for_bindings_named_same_as_variants(cx: &MatchVisitor<'_, '_>, pat: &Pa
if edef.is_enum() && edef.variants.iter().any(|variant| {
variant.ident == ident && variant.ctor_kind == CtorKind::Const
}) {
let ty_path = cx.tcx.item_path_str(edef.did);
let ty_path = cx.tcx.def_path_str(edef.did);
let mut err = struct_span_warn!(cx.tcx.sess, p.span, E0170,
"pattern binding `{}` is named the same as one \
of the variants of the type `{}`",

4
src/librustc_mir/hair/pattern/mod.rs
View File

@ -969,8 +969,8 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
ty::Adt(adt_def, _) if !self.tcx.has_attr(adt_def.did, "structural_match") => {
let msg = format!("to use a constant of type `{}` in a pattern, \
`{}` must be annotated with `#[derive(PartialEq, Eq)]`",
self.tcx.item_path_str(adt_def.did),
self.tcx.item_path_str(adt_def.did));
self.tcx.def_path_str(adt_def.did),
self.tcx.def_path_str(adt_def.did));
self.tcx.sess.span_err(span, &msg);
PatternKind::Wild
}

2
src/librustc_mir/interpret/eval_context.rs
View File

@ -283,7 +283,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc
ty::InstanceDef::Item(def_id) => if self.tcx.is_mir_available(did) {
Ok(self.tcx.optimized_mir(did))
} else {
err!(NoMirFor(self.tcx.item_path_str(def_id)))
err!(NoMirFor(self.tcx.def_path_str(def_id)))
},
_ => Ok(self.tcx.instance_mir(instance)),
}

2
src/librustc_mir/transform/qualify_consts.rs
View File

@ -1253,7 +1253,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
if !self.span.allows_unstable(&feature.as_str()) {
let mut err = self.tcx.sess.struct_span_err(self.span,
&format!("`{}` is not yet stable as a const fn",
self.tcx.item_path_str(def_id)));
self.tcx.def_path_str(def_id)));
if nightly_options::is_nightly_build() {
help!(&mut err,
"add `#![feature({})]` to the \

4
src/librustc_mir/transform/rustc_peek.rs
View File

@ -29,10 +29,10 @@ impl MirPass for SanityCheck {
let def_id = src.def_id();
let id = tcx.hir().as_local_hir_id(def_id).unwrap();
if !tcx.has_attr(def_id, "rustc_mir") {
debug!("skipping rustc_peek::SanityCheck on {}", tcx.item_path_str(def_id));
debug!("skipping rustc_peek::SanityCheck on {}", tcx.def_path_str(def_id));
return;
} else {
debug!("running rustc_peek::SanityCheck on {}", tcx.item_path_str(def_id));
debug!("running rustc_peek::SanityCheck on {}", tcx.def_path_str(def_id));
}
let attributes = tcx.get_attrs(def_id);

2
src/librustc_mir/util/graphviz.rs
View File

@ -127,7 +127,7 @@ fn write_graph_label<'a, 'gcx, 'tcx, W: Write>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &Mir<'_>,
w: &mut W)
-> io::Result<()> {
write!(w, " label=<fn {}(", dot::escape_html(&tcx.item_path_str(def_id)))?;
write!(w, " label=<fn {}(", dot::escape_html(&tcx.def_path_str(def_id)))?;
// fn argument types.
for (i, arg) in mir.args_iter().enumerate() {

2
src/librustc_mir/util/liveness.rs
View File

@ -267,7 +267,7 @@ pub fn dump_mir<'a, 'tcx>(
}
let node_path = item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 below
tcx.item_path_str(source.def_id())
tcx.def_path_str(source.def_id())
});
dump_matched_mir_node(tcx, pass_name, &node_path, source, mir, result);
}

8
src/librustc_mir/util/pretty.rs
View File

@ -80,7 +80,7 @@ pub fn dump_mir<'a, 'gcx, 'tcx, F>(
let node_path = item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 below
tcx.item_path_str(source.def_id())
tcx.def_path_str(source.def_id())
});
dump_matched_mir_node(
tcx,
@ -105,7 +105,7 @@ pub fn dump_enabled<'a, 'gcx, 'tcx>(
};
let node_path = item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 below
tcx.item_path_str(source.def_id())
tcx.def_path_str(source.def_id())
});
filters.split('|').any(|or_filter| {
or_filter.split('&').all(|and_filter| {
@ -115,7 +115,7 @@ pub fn dump_enabled<'a, 'gcx, 'tcx>(
}
// #41697 -- we use `with_forced_impl_filename_line()` because
// `item_path_str()` would otherwise trigger `type_of`, and this can
// `def_path_str()` would otherwise trigger `type_of`, and this can
// run while we are already attempting to evaluate `type_of`.
fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>(
@ -614,7 +614,7 @@ fn write_mir_sig(
item_path::with_forced_impl_filename_line(|| {
// see notes on #41697 elsewhere
write!(w, "{}", tcx.item_path_str(src.def_id()))
write!(w, " {}", tcx.def_path_str(src.def_id()))
})?;
if src.promoted.is_none() && is_function {

2
src/librustc_privacy/lib.rs
View File

@ -816,7 +816,7 @@ impl<'a, 'tcx> NamePrivacyVisitor<'a, 'tcx> {
let def_id = self.tcx.adjust_ident(ident, def.did, current_hir).1;
if !def.is_enum() && !field.vis.is_accessible_from(def_id, self.tcx) {
struct_span_err!(self.tcx.sess, span, E0451, "field `{}` of {} `{}` is private",
field.ident, def.variant_descr(), self.tcx.item_path_str(def.did))
field.ident, def.variant_descr(), self.tcx.def_path_str(def.did))
.span_label(span, format!("field `{}` is private", field.ident))
.emit();
}

4
src/librustc_save_analysis/lib.rs
View File

@ -411,7 +411,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
if let Some(def_id) = trait_id {
// A method in a trait impl.
qualname.push_str(" as ");
qualname.push_str(&self.tcx.item_path_str(def_id));
qualname.push_str(&self.tcx.def_path_str(def_id));
self.tcx
.associated_items(def_id)
.find(|item| item.ident.name == ident.name)
@ -451,7 +451,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
}
(
format!("::{}", self.tcx.item_path_str(def_id)),
format!("::{}", self.tcx.def_path_str(def_id)),
Some(def_id),
None,
docs,

6
src/librustc_typeck/astconv.rs
View File

@ -922,7 +922,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o {
"the value of the associated type `{}` (from the trait `{}`) \
is already specified",
binding.item_name,
tcx.item_path_str(assoc_ty.container.id()))
tcx.def_path_str(assoc_ty.container.id()))
.span_label(binding.span, "re-bound here")
.span_label(*prev_span, format!("`{}` bound here first", binding.item_name))
.emit();
@ -1071,7 +1071,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o {
format!(
"`{}` (from the trait `{}`)",
assoc_item.ident,
tcx.item_path_str(trait_def_id),
tcx.def_path_str(trait_def_id),
)
}).collect::<Vec<_>>().join(", ");
let mut err = struct_span_err!(
@ -1459,7 +1459,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o {
let self_ty = if let Some(ty) = opt_self_ty {
ty
} else {
let path_str = tcx.item_path_str(trait_def_id);
let path_str = tcx.def_path_str(trait_def_id);
self.report_ambiguous_associated_type(span,
"Type",
&path_str,

4
src/librustc_typeck/check/_match.rs
View File

@ -1001,13 +1001,13 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
E0026,
"{} `{}` does not have {}",
kind_name,
tcx.item_path_str(variant.did),
tcx.def_path_str(variant.did),
field_names);
if let Some((span, ident)) = inexistent_fields.last() {
err.span_label(*span,
format!("{} `{}` does not have {} field{}",
kind_name,
tcx.item_path_str(variant.did),
tcx.def_path_str(variant.did),
t,
plural));
if plural == "" {

2
src/librustc_typeck/check/compare_method.rs
View File

@ -719,7 +719,7 @@ fn compare_number_of_method_arguments<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
trait `{}` has {}",
trait_m.ident,
potentially_plural_count(impl_number_args, "parameter"),
tcx.item_path_str(trait_m.def_id),
tcx.def_path_str(trait_m.def_id),
trait_number_args);
if let Some(trait_span) = trait_span {
err.span_label(trait_span, format!("trait requires {}",

2
src/librustc_typeck/check/demand.rs
View File

@ -130,7 +130,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let sole_field = &variant.fields[0];
let sole_field_ty = sole_field.ty(self.tcx, substs);
if self.can_coerce(expr_ty, sole_field_ty) {
let variant_path = self.tcx.item_path_str(variant.did);
let variant_path = self.tcx.def_path_str(variant.did);
// FIXME #56861: DRYer prelude filtering
Some(variant_path.trim_start_matches("std::prelude::v1::").to_string())
} else {

4
src/librustc_typeck/check/method/probe.rs
View File

@ -1195,7 +1195,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
// `report_method_error()`.
diag.help(&format!(
"call with fully qualified syntax `{}(...)` to keep using the current method",
self.tcx.item_path_str(stable_pick.item.def_id),
self.tcx.def_path_str(stable_pick.item.def_id),
));
if nightly_options::is_nightly_build() {
@ -1203,7 +1203,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
diag.help(&format!(
"add #![feature({})] to the crate attributes to enable `{}`",
feature,
self.tcx.item_path_str(candidate.item.def_id),
self.tcx.def_path_str(candidate.item.def_id),
));
}
}

16
src/librustc_typeck/check/method/suggest.rs
View File

@ -102,7 +102,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
None => String::new(),
Some(trait_ref) => {
format!(" of the trait `{}`",
self.tcx.item_path_str(trait_ref.def_id))
self.tcx.def_path_str(trait_ref.def_id))
}
};
@ -135,16 +135,16 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
item_span,
"candidate #{} is defined in the trait `{}`",
idx + 1,
self.tcx.item_path_str(trait_did));
self.tcx.def_path_str(trait_did));
} else {
span_note!(err,
item_span,
"the candidate is defined in the trait `{}`",
self.tcx.item_path_str(trait_did));
self.tcx.def_path_str(trait_did));
}
err.help(&format!("to disambiguate the method call, write `{}::{}({}{})` \
instead",
self.tcx.item_path_str(trait_did),
self.tcx.def_path_str(trait_did),
item_name,
if rcvr_ty.is_region_ptr() && args.is_some() {
if rcvr_ty.is_mutable_pointer() {
@ -516,7 +516,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
};
format!(
"use {};\n{}",
with_crate_prefix(|| self.tcx.item_path_str(*did)),
with_crate_prefix(|| self.tcx.def_path_str(*did)),
additional_newline
)
});
@ -530,14 +530,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
&format!(
"\ncandidate #{}: `use {};`",
i + 1,
with_crate_prefix(|| self.tcx.item_path_str(*trait_did))
with_crate_prefix(|| self.tcx.def_path_str(*trait_did))
)
);
} else {
msg.push_str(
&format!(
"\n`use {};`",
with_crate_prefix(|| self.tcx.item_path_str(*trait_did))
with_crate_prefix(|| self.tcx.def_path_str(*trait_did))
)
);
}
@ -638,7 +638,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
for (i, trait_info) in candidates.iter().enumerate() {
msg.push_str(&format!("\ncandidate #{}: `{}`",
i + 1,
self.tcx.item_path_str(trait_info.def_id)));
self.tcx.def_path_str(trait_info.def_id)));
}
err.note(&msg[..]);
}

4
src/librustc_typeck/check/mod.rs
View File

@ -1328,7 +1328,7 @@ pub fn check_item_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Ite
debug!(
"check_item_type(it.hir_id={}, it.name={})",
it.hir_id,
tcx.item_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
tcx.def_path_str(tcx.hir().local_def_id_from_hir_id(it.hir_id))
);
let _indenter = indenter();
match it.node {
@ -3534,7 +3534,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
autoderef.unambiguous_final_ty(self);
if let Some((did, field_ty)) = private_candidate {
let struct_path = self.tcx().item_path_str(did);
let struct_path = self.tcx().def_path_str(did);
let mut err = struct_span_err!(self.tcx().sess, expr.span, E0616,
"field `{}` of struct `{}` is private",
field, struct_path);

4
src/librustc_typeck/check/wfcheck.rs
View File

@ -68,7 +68,7 @@ pub fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: Def
debug!("check_item_well_formed(it.hir_id={:?}, it.name={})",
item.hir_id,
tcx.item_path_str(def_id));
tcx.def_path_str(def_id));
match item.node {
// Right now we check that every default trait implementation
@ -976,7 +976,7 @@ fn report_bivariance<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
if let Some(def_id) = suggested_marker_id {
err.help(&format!("consider removing `{}` or using a marker such as `{}`",
param_name,
tcx.item_path_str(def_id)));
tcx.def_path_str(def_id)));
}
err.emit();
}

8
src/librustc_typeck/coherence/builtin.rs
View File

@ -198,8 +198,8 @@ fn visit_implementation_of_dispatch_from_dyn<'a, 'tcx>(
if def_a.is_struct() && def_b.is_struct() =>
{
if def_a != def_b {
let source_path = tcx.item_path_str(def_a.did);
let target_path = tcx.item_path_str(def_b.did);
let source_path = tcx.def_path_str(def_a.did);
let target_path = tcx.def_path_str(def_b.did);
create_err(
&format!(
@ -388,8 +388,8 @@ pub fn coerce_unsized_info<'a, 'gcx>(gcx: TyCtxt<'a, 'gcx, 'gcx>,
(&ty::Adt(def_a, substs_a), &ty::Adt(def_b, substs_b)) if def_a.is_struct() &&
def_b.is_struct() => {
if def_a != def_b {
let source_path = gcx.item_path_str(def_a.did);
let target_path = gcx.item_path_str(def_b.did);
let source_path = gcx.def_path_str(def_a.did);
let target_path = gcx.def_path_str(def_b.did);
span_err!(gcx.sess,
span,
E0377,

6
src/librustc_typeck/coherence/mod.rs
View File

@ -28,7 +28,7 @@ fn check_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, node_id: ast::NodeId) {
if let Some(trait_ref) = tcx.impl_trait_ref(impl_def_id) {
debug!("(checking implementation) adding impl for trait '{:?}', item '{}'",
trait_ref,
tcx.item_path_str(impl_def_id));
tcx.def_path_str(impl_def_id));
// Skip impls where one of the self type is an error type.
// This occurs with e.g., resolve failures (#30589).
@ -204,10 +204,10 @@ fn check_impl_overlap<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, node_id: ast::NodeI
E0371,
"the object type `{}` automatically implements the trait `{}`",
trait_ref.self_ty(),
tcx.item_path_str(trait_def_id))
tcx.def_path_str(trait_def_id))
.span_label(sp, format!("`{}` automatically implements trait `{}`",
trait_ref.self_ty(),
tcx.item_path_str(trait_def_id)))
tcx.def_path_str(trait_def_id)))
.emit();
}
}

4
src/librustc_typeck/coherence/orphan.rs
View File

@ -121,7 +121,7 @@ impl<'cx, 'tcx, 'v> ItemLikeVisitor<'v> for OrphanChecker<'cx, 'tcx> {
format!("cross-crate traits with a default impl, like `{}`, \
can only be implemented for a struct/enum type \
defined in the current crate",
self.tcx.item_path_str(trait_def_id)),
self.tcx.def_path_str(trait_def_id)),
"can't implement cross-crate trait for type in another crate"
))
}
@ -129,7 +129,7 @@ impl<'cx, 'tcx, 'v> ItemLikeVisitor<'v> for OrphanChecker<'cx, 'tcx> {
_ => {
Some((format!("cross-crate traits with a default impl, like `{}`, can \
only be implemented for a struct/enum type, not `{}`",
self.tcx.item_path_str(trait_def_id),
self.tcx.def_path_str(trait_def_id),
self_ty),
"can't implement cross-crate trait with a default impl for \
non-struct/enum type"))

2
src/librustc_typeck/variance/constraints.rs
View File

@ -131,7 +131,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
fn build_constraints_for_item(&mut self, def_id: DefId) {
let tcx = self.tcx();
debug!("build_constraints_for_item({})", tcx.item_path_str(def_id));
debug!("build_constraints_for_item({})", tcx.def_path_str(def_id));
// Skip items with no generics - there's nothing to infer in them.
if tcx.generics_of(def_id).count() == 0 {

2
src/librustdoc/clean/mod.rs
View File

@ -4250,7 +4250,7 @@ where F: Fn(DefId) -> Def {
}
let names = PrintCx::new(tcx, AbsolutePathPrinter)
.print_item_path(def_id, None, Namespace::TypeNS);
.print_def_path(def_id, None, Namespace::TypeNS);
hir::Path {
span: DUMMY_SP,

2
src/libsyntax/feature_gate.rs
View File

@ -1042,7 +1042,7 @@ pub const BUILTIN_ATTRIBUTES: &[(&str, AttributeType, AttributeTemplate, Attribu
"rustc_attrs",
"internal rustc attributes will never be stable",
cfg_fn!(rustc_attrs))),
("rustc_item_path", Whitelisted, template!(Word), Gated(Stability::Unstable,
("rustc_def_path", Whitelisted, template!(Word), Gated(Stability::Unstable,
"rustc_attrs",
"internal rustc attributes will never be stable",
cfg_fn!(rustc_attrs))),

2
src/test/mir-opt/issue-41697.rs
View File

@ -1,7 +1,7 @@
// Regression test for #41697. Using dump-mir was triggering
// artificial cycles: during type-checking, we had to get the MIR for
// the constant expressions in `[u8; 2]`, which in turn would trigger
// an attempt to get the item-path, which in turn would request the
// an attempt to get the def-path, which in turn would request the
// types of the impl, which would trigger a cycle. We suppressed this
// cycle now by forcing mir-dump to avoid asking for types of an impl.

2
src/test/ui/symbol-names/basic.rs
View File

@ -1,6 +1,6 @@
#![feature(rustc_attrs)]
#[rustc_symbol_name] //~ ERROR _ZN5basic4main
#[rustc_item_path] //~ ERROR item-path(main)
#[rustc_def_path] //~ ERROR def-path(main)
fn main() {
}

6
src/test/ui/symbol-names/basic.stderr
View File

@ -4,11 +4,11 @@ error: symbol-name(_ZN5basic4main17h08bcaf310214ed52E)
LL | #[rustc_symbol_name]
| ^^^^^^^^^^^^^^^^^^^^
error: item-path(main)
error: def-path(main)
--> $DIR/basic.rs:4:1
|
LL | #[rustc_item_path]
| ^^^^^^^^^^^^^^^^^^
LL | #[rustc_def_path]
| ^^^^^^^^^^^^^^^^^
error: aborting due to 2 previous errors

4
src/test/ui/symbol-names/impl1.rs
View File

@ -6,7 +6,7 @@ mod foo {
impl Foo {
#[rustc_symbol_name] //~ ERROR _ZN15impl1..foo..Foo3bar
#[rustc_item_path] //~ ERROR item-path(foo::Foo::bar)
#[rustc_def_path] //~ ERROR def-path(foo::Foo::bar)
fn bar() { }
}
}
@ -16,7 +16,7 @@ mod bar {
impl Foo {
#[rustc_symbol_name] //~ ERROR _ZN5impl13bar33_$LT$impl$u20$impl1..foo..Foo$GT$3baz
#[rustc_item_path] //~ ERROR item-path(bar::<impl foo::Foo>::baz)
#[rustc_def_path] //~ ERROR def-path(bar::<impl foo::Foo>::baz)
fn baz() { }
}
}

12
src/test/ui/symbol-names/impl1.stderr
View File

@ -4,11 +4,11 @@ error: symbol-name(_ZN15impl1..foo..Foo3bar17hc487d6ec13fe9124E)
LL | #[rustc_symbol_name]
| ^^^^^^^^^^^^^^^^^^^^
error: item-path(foo::Foo::bar)
error: def-path(foo::Foo::bar)
--> $DIR/impl1.rs:9:9
|
LL | #[rustc_item_path]
| ^^^^^^^^^^^^^^^^^^
LL | #[rustc_def_path]
| ^^^^^^^^^^^^^^^^^
error: symbol-name(_ZN5impl13bar33_$LT$impl$u20$impl1..foo..Foo$GT$3baz17h38577281258e1527E)
--> $DIR/impl1.rs:18:9
@ -16,11 +16,11 @@ error: symbol-name(_ZN5impl13bar33_$LT$impl$u20$impl1..foo..Foo$GT$3baz17h385772
LL | #[rustc_symbol_name]
| ^^^^^^^^^^^^^^^^^^^^
error: item-path(bar::<impl foo::Foo>::baz)
error: def-path(bar::<impl foo::Foo>::baz)
--> $DIR/impl1.rs:19:9
|
LL | #[rustc_item_path]
| ^^^^^^^^^^^^^^^^^^
LL | #[rustc_def_path]
| ^^^^^^^^^^^^^^^^^
error: aborting due to 4 previous errors