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

Replace all uses of path.res.def_id() with path.def_id()

Browse source
This commit is contained in:
Noah Lev 2021-08-28 20:46:53 -07:00
parent 82b52e1951
commit 962e451443
10 changed files with 19 additions and 19 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustdoc/clean/auto_trait.rs
View file

@ -691,7 +691,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
fn is_fn_trait(&self, path: &Path) -> bool {
let tcx = self.cx.tcx;
let did = path.res.def_id();
let did = path.def_id();
did == tcx.require_lang_item(LangItem::Fn, None)
|| did == tcx.require_lang_item(LangItem::FnMut, None)
|| did == tcx.require_lang_item(LangItem::FnOnce, None)

8
src/librustdoc/clean/inline.rs
View file

@ -454,7 +454,7 @@ crate fn build_impl(
// Return if the trait itself or any types of the generic parameters are doc(hidden).
let mut stack: Vec<&Type> = vec![&for_];
if let Some(did) = trait_.as_ref().map(|t| t.res.def_id()) {
if let Some(did) = trait_.as_ref().map(|t| t.def_id()) {
if tcx.get_attrs(did).lists(sym::doc).has_word(sym::hidden) {
return;
}
@ -474,7 +474,7 @@ crate fn build_impl(
}
}
if let Some(did) = trait_.as_ref().map(|t| t.res.def_id()) {
if let Some(did) = trait_.as_ref().map(|t| t.def_id()) {
record_extern_trait(cx, did);
}
@ -628,7 +628,7 @@ fn filter_non_trait_generics(trait_did: DefId, mut g: clean::Generics) -> clean:
} if *s == kw::SelfUpper => {
bounds.retain(|bound| match bound {
clean::GenericBound::TraitBound(clean::PolyTrait { trait_, .. }, _) => {
trait_.res.def_id() != trait_did
trait_.def_id() != trait_did
}
_ => true,
});
@ -642,7 +642,7 @@ fn filter_non_trait_generics(trait_did: DefId, mut g: clean::Generics) -> clean:
ty: clean::QPath { self_type: box clean::Generic(ref s), trait_, name: _, .. },
bounds,
..
} => !(bounds.is_empty() || *s == kw::SelfUpper && trait_.res.def_id() == trait_did),
} => !(bounds.is_empty() || *s == kw::SelfUpper && trait_.def_id() == trait_did),
_ => true,
});
g

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

@ -1100,7 +1100,7 @@ impl Clean<Item> for ty::AssocItem {
if *name != my_name {
return None;
}
if trait_.res.def_id() != self.container.id() {
if trait_.def_id() != self.container.id() {
return None;
}
match **self_type {

2
src/librustdoc/clean/simplify.rs
View file

@ -102,7 +102,7 @@ crate fn merge_bounds(
// If this QPath's trait `trait_did` is the same as, or a supertrait
// of, the bound's trait `did` then we can keep going, otherwise
// this is just a plain old equality bound.
if !trait_is_same_or_supertrait(cx, trait_ref.trait_.res.def_id(), trait_did) {
if !trait_is_same_or_supertrait(cx, trait_ref.trait_.def_id(), trait_did) {
return false;
}
let last = trait_ref.trait_.segments.last_mut().expect("segments were empty");

4
src/librustdoc/clean/types.rs
View file

@ -1499,13 +1499,13 @@ impl Type {
QPath { self_type, trait_, name, .. } => (self_type, trait_, name),
_ => return None,
};
Some((&self_, trait_.res.def_id(), *name))
Some((&self_, trait_.def_id(), *name))
}
fn inner_def_id(&self, cache: Option<&Cache>) -> Option<DefId> {
let t: PrimitiveType = match *self {
ResolvedPath { did, .. } => return Some(did),
DynTrait(ref bounds, _) => return Some(bounds[0].trait_.res.def_id()),
DynTrait(ref bounds, _) => return Some(bounds[0].trait_.def_id()),
Primitive(p) => return cache.and_then(|c| c.primitive_locations.get(&p).cloned()),
BorrowedRef { type_: box Generic(..), .. } => PrimitiveType::Reference,
BorrowedRef { ref type_, .. } => return type_.inner_def_id(cache),

6
src/librustdoc/html/format.rs
View file

@ -914,7 +914,7 @@ fn fmt_type<'cx>(
clean::QPath { ref name, ref self_type, ref trait_, ref self_def_id } => {
let should_show_cast = !trait_.segments.is_empty()
&& self_def_id
.zip(Some(trait_.res.def_id()))
.zip(Some(trait_.def_id()))
.map_or(!self_type.is_self_type(), |(id, trait_)| id != trait_);
if f.alternate() {
if should_show_cast {
@ -939,7 +939,7 @@ fn fmt_type<'cx>(
// the ugliness comes from inlining across crates where
// everything comes in as a fully resolved QPath (hard to
// look at).
match href(trait_.res.def_id(), cx) {
match href(trait_.def_id(), cx) {
Ok((ref url, _, ref path)) if !f.alternate() => {
write!(
f,
@ -972,7 +972,7 @@ impl clean::Path {
&'a self,
cx: &'a Context<'tcx>,
) -> impl fmt::Display + 'b + Captures<'tcx> {
display_fn(move |f| resolved_path(f, self.res.def_id(), self, false, false, cx))
display_fn(move |f| resolved_path(f, self.def_id(), self, false, false, cx))
}
}

2
src/librustdoc/html/render/cache.rs
View file

@ -322,7 +322,7 @@ crate fn get_real_types<'tcx>(
if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) {
for bound in bound.get_bounds().unwrap_or(&[]) {
if let Some(path) = bound.get_trait_path() {
let ty = Type::ResolvedPath { did: path.res.def_id(), path };
let ty = Type::ResolvedPath { did: path.def_id(), path };
let adds = get_real_types(generics, &ty, tcx, recurse + 1, res);
nb_added += adds;
if adds == 0 && !ty.is_full_generic() {

2
src/librustdoc/html/render/mod.rs
View file

@ -2389,7 +2389,7 @@ fn collect_paths_for_type(first_ty: clean::Type, cache: &Cache) -> Vec<String> {
}
clean::Type::QPath { self_type, trait_, .. } => {
work.push_back(*self_type);
process_path(trait_.res.def_id());
process_path(trait_.def_id());
}
_ => {}
}

8
src/librustdoc/json/conversions.rs
View file

@ -365,7 +365,7 @@ impl FromWithTcx<clean::GenericBound> for GenericBound {
TraitBound(clean::PolyTrait { trait_, generic_params }, modifier) => {
// FIXME: should `trait_` be a clean::Path equivalent in JSON?
let trait_ =
clean::ResolvedPath { did: trait_.res.def_id(), path: trait_ }.into_tcx(tcx);
clean::ResolvedPath { did: trait_.def_id(), path: trait_ }.into_tcx(tcx);
GenericBound::TraitBound {
trait_,
generic_params: generic_params.into_iter().map(|x| x.into_tcx(tcx)).collect(),
@ -401,7 +401,7 @@ impl FromWithTcx<clean::Type> for Type {
Type::ResolvedPath {
name: first_trait.whole_name(),
id: from_item_id(first_trait.res.def_id().into()),
id: from_item_id(first_trait.def_id().into()),
args: first_trait
.segments
.last()
@ -436,7 +436,7 @@ impl FromWithTcx<clean::Type> for Type {
},
QPath { name, self_type, trait_, .. } => {
// FIXME: should `trait_` be a clean::Path equivalent in JSON?
let trait_ = ResolvedPath { did: trait_.res.def_id(), path: trait_ }.into_tcx(tcx);
let trait_ = ResolvedPath { did: trait_.def_id(), path: trait_ }.into_tcx(tcx);
Type::QualifiedPath {
name: name.to_string(),
self_type: Box::new((*self_type).into_tcx(tcx)),
@ -513,7 +513,7 @@ impl FromWithTcx<clean::Impl> for Impl {
} = impl_;
// FIXME: should `trait_` be a clean::Path equivalent in JSON?
let trait_ = trait_.map(|path| {
let did = path.res.def_id();
let did = path.def_id();
clean::ResolvedPath { path, did }.into_tcx(tcx)
});
Impl {

2
src/librustdoc/passes/collect_trait_impls.rs
View file

@ -82,7 +82,7 @@ crate fn collect_trait_impls(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
cleaner.keep_impl(for_)
|| trait_
.as_ref()
.map_or(false, |t| cleaner.keep_impl_with_def_id(t.res.def_id().into()))
.map_or(false, |t| cleaner.keep_impl_with_def_id(t.def_id().into()))
|| blanket_impl.is_some()
} else {
true