Struct Path 

pub struct Path {
    qualifier: Vec<Identifier>,
    identifier: Identifier,
    is_absolute: bool,
    absolute_path: Option<Vec<Symbol>>,
    pub span: Span,
    pub id: NodeID,
}

A Path in a program.

Fields

qualifier: Vec<Identifier>

The qualifying namespace segments written by the user, excluding the item itself. e.g., in foo::bar::baz, this would be [foo, bar].

identifier: Identifier

The final item in the path, e.g., baz in foo::bar::baz.

is_absolute: bool

Is this path an absolute path? e.g. ::foo::bar::baz.

absolute_path: Option<Vec<Symbol>>

The fully resolved path. We may not know this until the pass PathResolution pass runs. For path that refer to global items (structs, consts, functions), absolute_path is guaranteed to be set after the pass PathResolution.

span: Span

A span locating where the path occurred in the source.

id: NodeID

The ID of the node.

Implementations

impl Path

pub fn new( qualifier: Vec<Identifier>, identifier: Identifier, is_absolute: bool, absolute_path: Option<Vec<Symbol>>, span: Span, id: NodeID, ) -> Self

Creates a new Path from the given components.

• qualifier: The namespace segments (e.g., foo::bar in foo::bar::baz).
• identifier: The final item in the path (e.g., baz).
• is_absolute: Whether the path is absolute (starts with ::).
• absolute_path: Optionally, the fully resolved symbolic path.
• span: The source code span for this path.
• id: The node ID.

pub fn identifier(&self) -> Identifier

Returns the final identifier of the path (e.g., baz in foo::bar::baz).

pub fn qualifier(&self) -> &[Identifier]

Returns a slice of the qualifier segments (e.g., [foo, bar] in foo::bar::baz).

pub fn is_absolute(&self) -> bool

Returns true if the path is absolute (i.e., starts with ::).

pub fn as_symbols(&self) -> Vec<Symbol>

Returns a Vec<Symbol> representing the full symbolic path: the qualifier segments followed by the final identifier.

Note: this refers to the user path which is not necessarily the absolute path.

pub fn try_absolute_path(&self) -> Option<Vec<Symbol>>

Returns an optional vector of Symbols representing the resolved absolute path, or None if resolution has not yet occurred.

pub fn absolute_path(&self) -> Vec<Symbol>

Returns a vector of Symbols representing the resolved absolute path.

If the path is not an absolute path, this method panics if the absolute path has not been resolved yet. For relative paths, this is expected to be called only after path resolution has occurred.

pub fn into_absolute(self) -> Self

Converts this Path into an absolute path by setting its is_absolute flag to true.

This does not alter the qualifier or identifier, nor does it compute or modify the resolved absolute_path.

pub fn with_updated_last_symbol(self, new_symbol: Symbol) -> Self

Returns a new Path instance with the last segment’s Symbol and the last symbol in the absolute_path (if present) replaced with new_symbol.

Other fields remain unchanged.

pub fn with_absolute_path(self, absolute_path: Option<Vec<Symbol>>) -> Self

Sets self.absolute_path to absolute_path

pub fn with_module_prefix(self, module_prefix: &[Symbol]) -> Self

Sets the absolute_path by prepending the given module_prefix to the path’s own qualifier and identifier. Returns the updated Path.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl Default for Path

fn default() -> Path

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Path

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Path

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

Formats the value using the given formatter.

impl From<Identifier> for Path

fn from(value: Identifier) -> Self

Converts to this type from the input type.

impl From<Path> for Expression

fn from(value: Path) -> Self

Converts to this type from the input type.

impl Hash for Path

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 Node for Path

fn span(&self) -> Span

Returns the span of the node.

fn set_span(&mut self, span: Span)

Sets the span of the node.

fn id(&self) -> NodeID

Returns the ID of the node.

fn set_id(&mut self, id: NodeID)

Sets the ID of the node.

impl PartialEq for Path

fn eq(&self, other: &Path) -> 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 Serialize for Path

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Path

impl StructuralPartialEq for Path