Struct FluxId

pub struct FluxId<Id> {
    parent: Id,
    name: Symbol,
}

An id for a Flux-specific item that doesn’t have a corresponding Rust item and thus, we cannot be identified with a DefId. This includes, for example, associated refinements, qualifiers and refinement functions.

Type-level invariant

This struct maintains a type-level invariant ensuring that the referenced item exists. The id is composed of two parts:

• parent: A reference to a parent Rust item
• name: A name uniquely identifiying the item within the parent

Since the name can be an arbitrary Symbol, this doesn’t guarantee the existence of the item, so we must be careful when creating instances of this struct.

Implementation Details

• Fields are private to ensure construction only through FluxId::new
• A clippy lint prevents direct usage of FluxId::new, which can be selectively disabled when item existence is guaranteed
• The type is parametric over the parent Id type to support various id types (e.g., DefId, MaybeExternId)

Fields

parent: Id

name: Symbol

Implementations

impl<Id> FluxId<Id>

pub fn new(parent: Id, name: Symbol) -> Self

pub fn parent(self) -> Id

pub fn name(self) -> Symbol

impl FluxId<DefId>

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

pub fn expect_local(self) -> FluxLocalDefId

pub fn krate(self) -> CrateNum

pub fn index(self) -> FluxId<DefIndex>

impl FluxId<LocalDefId>

pub fn to_def_id(self) -> FluxDefId

pub fn local_def_index(self) -> FluxId<DefIndex>

impl FluxId<MaybeExternId>

pub fn local_id(self) -> FluxLocalDefId

Trait Implementations

impl<Id: Clone> Clone for FluxId<Id>

fn clone(&self) -> FluxId<Id>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Id: Debug> Debug for FluxId<Id>

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

Formats the value using the given formatter.

impl<Id, __D: SpanDecoder> Decodable<__D> for FluxId<Id>

where Id: Decodable<__D>,

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

impl<Id, __E: SpanEncoder> Encodable<__E> for FluxId<Id>

where Id: Encodable<__E>,

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

impl<Id: Hash> Hash for FluxId<Id>

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

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<Id: PartialEq> PartialEq for FluxId<Id>

fn eq(&self, other: &FluxId<Id>) -> 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<Id: Copy> Copy for FluxId<Id>

impl<Id: Eq> Eq for FluxId<Id>

impl<Id> StructuralPartialEq for FluxId<Id>