Struct rustc_span::hygiene::ExpnData

pub struct ExpnData {
    pub kind: ExpnKind,
    pub parent: ExpnId,
    pub call_site: Span,
    pub def_site: Span,
    pub allow_internal_unstable: Option<Lrc<[Symbol]>>,
    pub allow_internal_unsafe: bool,
    pub local_inner_macros: bool,
    pub edition: Edition,
    pub macro_def_id: Option<DefId>,
    krate: CrateNum,
    orig_id: Option<u32>,
    disambiguator: u32,
}

A subset of properties from both macro definition and macro call available through global data. Avoid using this if you have access to the original definition or call structures.

Fields

kind: ExpnKind

The kind of this expansion - macro or compiler desugaring.

parent: ExpnId

The expansion that produced this expansion.

call_site: Span

The location of the actual macro invocation or syntax sugar , e.g. let x = foo!(); or if let Some(y) = x {}

This may recursively refer to other macro invocations, e.g., if foo!() invoked bar!() internally, and there was an expression inside bar!; the call_site of the expression in the expansion would point to the bar! invocation; that call_site span would have its own ExpnData, with the call_site pointing to the foo! invocation.

def_site: Span

The span of the macro definition (possibly dummy). This span serves only informational purpose and is not used for resolution.

allow_internal_unstable: Option<Lrc<[Symbol]>>

List of #[unstable]/feature-gated features that the macro is allowed to use internally without forcing the whole crate to opt-in to them.

allow_internal_unsafe: bool

Whether the macro is allowed to use unsafe internally even if the user crate has #![forbid(unsafe_code)].

local_inner_macros: bool

Enables the macro helper hack (ident!(...) -> $crate::ident!(...)) for a given macro.

edition: Edition

Edition of the crate in which the macro is defined.

macro_def_id: Option<DefId>

The DefId of the macro being invoked, if this ExpnData corresponds to a macro invocation

krate: CrateNum

The crate that originally created this ExpnData. During metadata serialization, we only encode ExpnDatas that were created locally - when our serialized metadata is decoded, foreign ExpnIds will have their ExpnData looked up from the crate specified by `Crate

orig_id: Option<u32>

The raw that this ExpnData had in its original crate. An ExpnData can be created before being assigned an ExpnId, so this might be None until set_expn_data is called

disambiguator: u32

Used to force two ExpnDatas to have different Fingerprints. Due to macro expansion, it’s possible to end up with two ExpnIds that have identical ExpnDatas. This violates the contract of HashStable

• the two ExpnIds are not equal, but their Fingerprints are equal (since the numerical ExpnId value is not considered by the HashStable implementation).

The disambiguator field is set by update_disambiguator when two distinct ExpnIds would end up with the same Fingerprint. Since ExpnData includes a krate field, this value only needs to be unique within a single crate.

Implementations

impl ExpnData

pub fn new(
    kind: ExpnKind,
    parent: ExpnId,
    call_site: Span,
    def_site: Span,
    allow_internal_unstable: Option<Lrc<[Symbol]>>,
    allow_internal_unsafe: bool,
    local_inner_macros: bool,
    edition: Edition,
    macro_def_id: Option<DefId>
) -> ExpnData

pub fn default(
    kind: ExpnKind,
    call_site: Span,
    edition: Edition,
    macro_def_id: Option<DefId>
) -> ExpnData

Constructs expansion data with default properties.

pub fn allow_unstable(
    kind: ExpnKind,
    call_site: Span,
    edition: Edition,
    allow_internal_unstable: Lrc<[Symbol]>,
    macro_def_id: Option<DefId>
) -> ExpnData

pub fn is_root(&self) -> bool

Trait Implementations

impl Clone for ExpnData

fn clone(&self) -> ExpnData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExpnData

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

Formats the value using the given formatter.

impl<__D: Decoder> Decodable<__D> for ExpnData

fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<__E: Encoder> Encodable<__E> for ExpnData

fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

impl !Hash for ExpnData

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<__CTX> HashStable<__CTX> for ExpnData where
    __CTX: HashStableContext, 

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl !PartialEq<ExpnData> for ExpnData

#[must_use]

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.