Struct DefId 

#[repr(C)]
pub struct DefId {
    pub index: DefIndex,
    pub krate: CrateNum,
}

A DefId identifies a particular definition, by combining a crate index and a def index.

You can create a DefId from a LocalDefId using local_def_id.to_def_id().

Fields

index: DefIndex

krate: CrateNum

Implementations

impl DefId

pub fn local(index: DefIndex) -> DefId

Makes a local DefId from the given DefIndex.

pub fn is_local(self) -> bool

Returns whether the item is defined in the crate currently being compiled.

pub fn as_local(self) -> Option<LocalDefId>

pub fn expect_local(self) -> LocalDefId

pub fn is_crate_root(self) -> bool

pub fn as_crate_root(self) -> Option<CrateNum>

pub fn is_top_level_module(self) -> bool

Trait Implementations

impl Clone for DefId

fn clone(&self) -> DefId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DefId

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

Formats the value using the given formatter.

impl<D> Decodable<D> for DefId

where D: SpanDecoder,

fn decode(s: &mut D) -> DefId

impl<E> Encodable<E> for DefId

where E: SpanEncoder,

fn encode(&self, s: &mut E)

impl From<LocalDefId> for DefId

fn from(local: LocalDefId) -> DefId

Converts to this type from the input type.

impl From<LocalModDefId> for DefId

fn from(typed: LocalModDefId) -> DefId

Converts to this type from the input type.

impl From<ModDefId> for DefId

fn from(typed: ModDefId) -> DefId

Converts to this type from the input type.

impl From<OwnerId> for DefId

fn from(value: OwnerId) -> DefId

Converts to this type from the input type.

impl Hash for DefId

fn hash<H>(&self, h: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<CTX> HashStable<CTX> for DefId

where CTX: HashStableContext,

fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher<SipHasher128>)

impl PartialEq for DefId

fn eq(&self, other: &DefId) -> 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<CTX> ToStableHashKey<CTX> for DefId

where CTX: HashStableContext,

type KeyType = DefPathHash

fn to_stable_hash_key(&self, hcx: &CTX) -> DefPathHash

impl Copy for DefId

impl Eq for DefId

impl !Ord for DefId

impl !PartialOrd for DefId

impl StructuralPartialEq for DefId

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes