crate module: Item,
crate externs: Vec<ExternalCrate>,
crate primitives: ThinVec<(DefId, PrimitiveType)>,
- // These are later on moved into `CACHEKEY`, leaving the map empty.
- // Only here so that they can be filtered through the rustdoc passes.
+ /// Only here so that they can be filtered through the rustdoc passes.
crate external_traits: Rc<RefCell<FxHashMap<DefId, TraitWithExtraInfo>>>,
crate collapsed: bool,
}
crate fn is_sized_bound(&self, cx: &DocContext<'_>) -> bool {
use rustc_hir::TraitBoundModifier as TBM;
if let GenericBound::TraitBound(PolyTrait { ref trait_, .. }, TBM::None) = *self {
- if trait_.def_id() == cx.tcx.lang_items().sized_trait() {
+ if Some(trait_.def_id()) == cx.tcx.lang_items().sized_trait() {
return true;
}
}
crate generic_params: Vec<GenericParamDef>,
}
-/// A representation of a type suitable for hyperlinking purposes. Ideally, one can get the original
-/// type out of the AST/`TyCtxt` given one of these, if more information is needed. Most
-/// importantly, it does not preserve mutability or boxes.
+/// Rustdoc's representation of types, mostly based on the [`hir::Ty`].
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
crate enum Type {
- /// Structs/enums/traits (most that would be an `hir::TyKind::Path`).
- ResolvedPath {
- path: Path,
- did: DefId,
- },
- /// `dyn for<'a> Trait<'a> + Send + 'static`
+ /// A named type, which could be a trait.
+ ///
+ /// This is mostly Rustdoc's version of [`hir::Path`]. It has to be different because Rustdoc's [`PathSegment`] can contain cleaned generics.
+ ResolvedPath { path: Path, did: DefId },
+ /// A `dyn Trait` object: `dyn for<'a> Trait<'a> + Send + 'static`
DynTrait(Vec<PolyTrait>, Option<Lifetime>),
- /// For parameterized types, so the consumer of the JSON don't go
- /// looking for types which don't exist anywhere.
+ /// A type parameter.
Generic(Symbol),
- /// Primitives are the fixed-size numeric types (plus int/usize/float), char,
- /// arrays, slices, and tuples.
+ /// A primitive (aka, builtin) type.
Primitive(PrimitiveType),
- /// `extern "ABI" fn`
+ /// A function pointer: `extern "ABI" fn(...) -> ...`
BareFunction(Box<BareFunctionDecl>),
+ /// A tuple type: `(i32, &str)`.
Tuple(Vec<Type>),
+ /// A slice type (does *not* include the `&`): `[i32]`
Slice(Box<Type>),
- /// The `String` field is about the size or the constant representing the array's length.
+ /// An array type.
+ ///
+ /// The `String` field is a stringified version of the array's length parameter.
Array(Box<Type>, String),
+ /// A raw pointer type: `*const i32`, `*mut i32`
RawPointer(Mutability, Box<Type>),
- BorrowedRef {
- lifetime: Option<Lifetime>,
- mutability: Mutability,
- type_: Box<Type>,
- },
+ /// A reference type: `&i32`, `&'a mut Foo`
+ BorrowedRef { lifetime: Option<Lifetime>, mutability: Mutability, type_: Box<Type> },
- // `<Type as Trait>::Name`
+ /// A qualified path to an associated item: `<Type as Trait>::Name`
QPath {
name: Symbol,
self_type: Box<Type>,
+ /// FIXME: This is a hack that should be removed; see [this discussion][1].
+ ///
+ /// [1]: https://github.com/rust-lang/rust/pull/85479#discussion_r635729093
self_def_id: Option<DefId>,
trait_: Path,
},
- // `_`
+ /// A type that is inferred: `_`
Infer,
- // `impl TraitA + TraitB + ...`
+ /// An `impl Trait`: `impl TraitA + TraitB + ...`
ImplTrait(Vec<GenericBound>),
}
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),
}
}
-/// N.B. this has to be different from `hir::PrimTy` because it also includes types that aren't
-/// paths, like `Unit`.
+/// A primitive (aka, builtin) type.
+///
+/// This represents things like `i32`, `str`, etc.
+///
+/// N.B. This has to be different from [`hir::PrimTy`] because it also includes types that aren't
+/// paths, like [`Self::Unit`].
#[derive(Clone, PartialEq, Eq, Hash, Copy, Debug)]
crate enum PrimitiveType {
Isize,
}
impl Path {
+ crate fn def_id(&self) -> DefId {
+ self.res.def_id()
+ }
+
crate fn last(&self) -> Symbol {
self.segments.last().expect("segments were empty").name
}
}
crate fn whole_name(&self) -> String {
- self.segments.iter().map(|s| s.name.to_string()).collect::<Vec<_>>().join("::")
+ self.segments.iter().map(|s| s.name.to_string()).intersperse("::".into()).collect()
}
/// Checks if this is a `T::Name` path for an associated type.
}
}
-// FIXME: this is temporary
-impl GetDefId for Path {
- fn def_id(&self) -> Option<DefId> {
- Some(self.res.def_id())
- }
-
- fn def_id_full(&self, _: &Cache) -> Option<DefId> {
- self.def_id()
- }
-}
-
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
crate enum GenericArg {
Lifetime(Lifetime),
impl Impl {
crate fn provided_trait_methods(&self, tcx: TyCtxt<'_>) -> FxHashSet<Symbol> {
self.trait_
- .def_id()
+ .as_ref()
+ .map(|t| t.def_id())
.map(|did| tcx.provided_trait_methods(did).map(|meth| meth.ident.name).collect())
.unwrap_or_default()
}
projects / rust.git / blobdiff