Struct PathSegment 

pub struct PathSegment<Kind = AnyKind> { /* private fields */ }

A typed path segment: one “piece” of a Rust path, with extra structure.

What does that mean?

In Rust, every item (function, type, trait, field…) has a path starting at its crate root. For example, in a crate called my_crate:

mod a {
    mod b {
        fn hello() {}
    }
    trait Foo {
        fn f() {
            enum T {
                C { field: u8 },
            }
        }
    }
}

Some paths and their segments are:

Path	Segments
my_crate	[my_crate]
my_crate::a	[my_crate], [a]
my_crate::a::b::hello	[my_crate], [a], [b], [hello]
my_crate::a::Foo	[my_crate], [a], [Foo]
my_crate::a::Foo::f	[my_crate], [a], [Foo::f]
my_crate::a::Foo::f::T	[my_crate], [a], [Foo::f], [T]
my_crate::a::Foo::f::T::C	[my_crate], [a], [Foo::f], [T::C]
my_crate::a::Foo::f::T::C::field	[my_crate], [a], [Foo::f], [T::C::field]

Each [X] here is a path segment.

Hierarchy

Path segments form a hierarchy: each one knows its parent. For example, the field my_field is inside the constructor of MyVariant, which is inside the enum MyEnum, which lives inside the function f, and so on – all the way up to the crate root.

This parenthood is important:

• a field segment always has a constructor parent (e.g. my_field → MyVariant).
• an associated item always has a trait/impl container parent (e.g. f → Foo).
• everything ultimately has a crate as its top parent.

Why does this matter?

This strong typing of segments lets tools:

• disambiguate names across contexts (e.g. two types with the same constructor name),
• generate unique, human-readable names in other languages/backends,
• walk up the chain of parents to reconstruct full paths.

For example, with the F* backend, constructors are not namespaced under the name of their type, but live directly at top-level. Thus, they need to be unique. Using the hierarchy, we can print them as Foo_MyVariant instead of Foo.MyVariant.

Implementations

impl<K> PathSegment<K>

pub fn payload(&self) -> PathSegmentPayload

Returns the payload of this path segment (named vs. unnamed and why).

pub fn disambiguator(&self) -> u32

Returns the rustc path disambiguator for this segment.

pub fn kind(&self) -> &K

Returns the kind of this segment as an [K].

impl PathSegment<ConstructorKind>

pub fn lift(&self) -> PathSegment<AnyKind>

Lift a PathSegment of kind ConstructorKind to a PathSegment of kind AnyKind.

impl PathSegment<TypeDefKind>

pub fn lift(&self) -> PathSegment<AnyKind>

Lift a PathSegment of kind TypeDefKind to a PathSegment of kind AnyKind.

impl PathSegment<AssocItemContainerKind>

pub fn lift(&self) -> PathSegment<AnyKind>

Lift a PathSegment of kind AssocItemContainerKind to a PathSegment of kind AnyKind.

impl PathSegment

pub fn parent(&self) -> Option<PathSegment>

Returns the parent path segment, if any.

Parents exist only for:

• AnyKind::Constructor (parent is its TypeDefKind),
• AnyKind::AssocItem (parent is its container trait/impl),
• AnyKind::Field (parent is its constructor).

All other kinds return None.

pub fn parents(&self) -> impl Iterator<Item = Self>

Returns an iterator over self and all its ancestors, walking up via Self::parent until no parent remains.

Trait Implementations

impl<Kind: Clone> Clone for PathSegment<Kind>

fn clone(&self) -> PathSegment<Kind>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Kind: Debug> Debug for PathSegment<Kind>

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

Formats the value using the given formatter.

impl PartialEq for PathSegment

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

Equality operator ==.

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

Inequality operator !=.