Struct Path 

pub struct Path {
    pub span: Span,
    pub id: NodeID,
    /* private fields */
}

A Path in a program.

Fields

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( user_program: Option<ProgramId>, qualifier: Vec<Identifier>, identifier: Identifier, span: Span, id: NodeID, ) -> Self

Creates a new unresolved Path from the given components.

• user_program: An optional program name (e.g. credits in credits.aleo::Bar)
• qualifier: The namespace segments (e.g., foo::bar in foo::bar::baz).
• identifier: The final item in the path (e.g., baz).
• 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 segments_iter(&self) -> impl Iterator<Item = Symbol> + '_

Returns an iterator over all segments as Symbols (qualifiers + identifier).

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

Returns a Vec<Symbol> of the segments.

pub fn user_program(&self) -> Option<&ProgramId>

Returns the optional program identifier.

pub fn with_user_program(self, user_program: ProgramId) -> Self

Returns self after setting it user_program field to user_program.

pub fn span(&self) -> Span

pub fn id(&self) -> NodeID

pub fn is_resolved(&self) -> bool

pub fn is_local(&self) -> bool

pub fn is_global(&self) -> bool

pub fn program(&self) -> Option<Symbol>

Returns the program symbol this path refers to, if known.

Priority:

1. User-written program qualifier (e.g. foo.aleo::bar::baz)
2. Resolved global target program
3. None (unresolved or local)

pub fn try_local_symbol(&self) -> Option<Symbol>

Returns the Symbol if local, None if not.

pub fn try_global_location(&self) -> Option<&Location>

Returns the Location if global, None if not.

pub fn expect_local_symbol(&self) -> Symbol

Returns the Symbol if local, panics if not.

pub fn expect_global_location(&self) -> &Location

Returns the Location if global, panics if not.

pub fn to_local(self) -> Self

Resolves this path to a local symbol.

pub fn to_global(self, location: Location) -> Self

Resolves this path to a global location.

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

Returns a new Path with the final identifier replaced by new_symbol.

This updates:

• identifier.name
• target:
  • Local(_) → Local(new_symbol)
  • Global(Location) → same location, but with the final path segment replaced
  • Unresolved → unchanged

pub fn resolve_as_global_in_module<I>( self, program: Symbol, external_libs: &IndexSet<Symbol>, current_module: I, ) -> Self

where I: IntoIterator<Item = Symbol>,

Resolves this path as a global path within the current module context.

This function converts a user-written path into a fully qualified PathTarget::Global by determining which program the path belongs to and constructing the corresponding module path.

Resolution follows two main cases:

1. External library access If the path does not explicitly specify a program (user_program is None) and the first qualifier segment matches a known external library name, that segment is interpreted as the target program. The remaining qualifier segments and identifier form the path inside that program.

2. Local or explicitly-qualified program access Otherwise, the path is resolved relative to the current module context. The final location is constructed by combining:

   • the current module path,
   • any user-written qualifier segments, and
   • the final identifier.

If the user explicitly wrote a program (via user_program), it overrides the default program parameter. Otherwise, the current program is used.

Importantly, this transformation does not modify the user-written syntax (user_program, qualifier, identifier). It only determines the internal target used during later compilation stages.

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<'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