Struct rustc_span::hygiene::ExpnData

pub struct ExpnData {
    pub kind: ExpnKind,
    pub parent: ExpnId,
    pub call_site: Span,
    disambiguator: u32,
    pub def_site: Span,
    pub allow_internal_unstable: Option<Lrc<[Symbol]>>,
    pub edition: Edition,
    pub macro_def_id: Option<DefId>,
    pub parent_module: Option<DefId>,
    pub(crate) allow_internal_unsafe: bool,
    pub local_inner_macros: bool,
    pub(crate) collapse_debuginfo: bool,
}

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.

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.

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.

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

parent_module: Option<DefId>

The normal module (mod) in which the expanded macro was defined.

allow_internal_unsafe: bool

Suppresses the unsafe_code lint for code produced by this macro.

local_inner_macros: bool

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

collapse_debuginfo: bool

Should debuginfo for the macro be collapsed to the outermost expansion site (in other words, was the macro definition annotated with #[collapse_debuginfo])?

Implementations

impl ExpnData

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

pub fn default( kind: ExpnKind, call_site: Span, edition: Edition, macro_def_id: Option<DefId>, parent_module: 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>, parent_module: Option<DefId> ) -> ExpnData

pub fn is_root(&self) -> bool

fn hash_expn(&self, ctx: &mut impl HashStableContext) -> Hash64

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: SpanDecoder> Decodable<__D> for ExpnData

fn decode(__decoder: &mut __D) -> Self

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

fn encode(&self, __encoder: &mut __E)

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, Self: Sized,

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 for ExpnData

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

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

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

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

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: 72 bytes