Struct PathResolver 

pub struct PathResolver { /* private fields */ }

Tracks use statements and validates whether paths refer to a specific target.

This is generic enough to work for enums, structs, functions, traits, etc.

Implementations

impl PathResolver

pub fn new(canonical_path: &str) -> Option<Self>

Create a new path resolver for a specific canonical path.

Arguments

• canonical_path - The fully qualified path (e.g., “crate::compiler::types::IRValue”)

Returns

A new PathResolver, or None if the path is invalid

Example

let resolver = PathResolver::new("crate::compiler::types::IRValue");

pub fn simple(name: &str) -> Self

Create a resolver that only matches exact simple paths (backward compatible mode).

This matches the old behavior where only EnumName::Variant is matched, without any use statement tracking.

pub fn scan_file(&mut self, file: &File)

Scan a file to build the local alias map from use statements.

This should be called once per file before using matches_target().

pub fn matches_target(&self, path: &Path) -> bool

Check if a path definitely refers to our target.

This uses conservative matching - only returns true if we’re certain the path refers to our target based on:

1. Exact canonical path match
2. Import alias resolution
3. Module path resolution

Arguments

• path - The syn::Path to check

Returns

true if the path definitely refers to our target

pub fn path_ends_with(&self, path: &Path, preceding_segment: &str) -> bool

Check if a path ends with the preceding segment (e.g., enum name).

This is useful for matching patterns like EnumName::VariantName regardless of what the variant name is, when combined with path validation.

Arguments

• path - The path to check
• preceding_segment - The segment before the variant (e.g., “IRValue” for enum variants)

Returns

true if the path has at least 2 segments and the second-to-last matches preceding_segment

pub fn target_name(&self) -> &str

Get the simple name of the target.

pub fn might_match_via_glob(&self, path: &Path) -> bool

Check if a path could potentially match via glob import.

Returns true if:

• We found a glob import that could include our target
• The path’s simple name matches our target

Trait Implementations

impl Clone for PathResolver

fn clone(&self) -> PathResolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PathResolver

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

Formats the value using the given formatter.