Struct Item 

pub struct Item {
    pub id: Id,
    pub crate_id: u32,
    pub name: Option<String>,
    pub span: Option<Span>,
    pub visibility: Visibility,
    pub docs: Option<String>,
    pub links: HashMap<String, Id>,
    pub attrs: Vec<Attribute>,
    pub deprecation: Option<Deprecation>,
    pub stability: Option<Box<Stability>>,
    pub inner: ItemEnum,
}

Anything that can hold documentation - modules, structs, enums, functions, traits, etc.

The Item data type holds fields that can apply to any of these, and leaves kind-specific details (like function args or enum variants) to the inner field.

Fields

id: Id

The unique identifier of this item. Can be used to find this item in various mappings.

crate_id: u32

This can be used as a key to the external_crates map of Crate to see which crate this item came from.

name: Option<String>

Some items such as impls don’t have names.

span: Option<Span>

The source location of this item (absent if it came from a macro expansion or inline assembly).

visibility: Visibility

By default all documented items are public, but you can tell rustdoc to output private items so this field is needed to differentiate.

docs: Option<String>

The full markdown docstring of this item. Absent if there is no documentation at all, Some(“”) if there is some documentation but it is empty (EG #[doc = ""]).

links: HashMap<String, Id>

This mapping resolves intra-doc links from the docstring to their IDs

attrs: Vec<Attribute>

Attributes on this item.

Does not include:

• #[doc = "Doc Comment"] or /// Doc comment: see Self::docs instead.
• #[deprecated] attributes: see the Self::deprecation field instead.
• #[stable] and #[unstable] attributes: see the Self::stability field instead.

Attributes appear in pretty-printed Rust form, regardless of their formatting in the original source code. For example:

• #[non_exhaustive] and #[must_use] are represented as themselves.
• #[no_mangle] and #[export_name] are also represented as themselves.
• #[repr(C)] and other reprs also appear as themselves, though potentially with a different order: e.g. repr(i8, C) may become repr(C, i8). Multiple repr attributes on the same item may be combined into an equivalent single attr.

deprecation: Option<Deprecation>

Information about the item’s deprecation, if present.

stability: Option<Box<Stability>>

Stability information for this item, if any.

This describes whether the item itself is stable or unstable, as noted by a #[stable] or #[unstable] attribute. It does not capture const stability, default-body stability, etc.

Whether a path to an item is stable depends on the stability of containing modules or re-exports along that path. For example, a stable item can be reachable through both an unstable module and a stable re-export.

For items whose inner kind is ItemEnum::Use, this is the stability of the import itself, not the item being imported. This allows users to determine the stability of paths that involve re-exports.

Associated items can inherit instability from their enclosing unstable trait or impl. Unannotated associated items in stable traits or impls may have no separate stability value.

Currently, Rust’s #[stable] and #[unstable] attributes are themselves not stable. As a result, this field is primarily populated for standard-library items; most ordinary third-party crates usually have no data here.

inner: ItemEnum

The type-specific fields describing this item.

Trait Implementations

impl Clone for Item

fn clone(&self) -> Item

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Item

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Item

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Item

impl PartialEq for Item

fn eq(&self, other: &Item) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Item

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Item