Struct WorkspaceFilePath 

pub struct WorkspaceFilePath { /* private fields */ }

Normalized relative path from workspace root (self-contained)

Design

This type holds the relative path, workspace root, and crate name, making it completely self-contained. You can get the absolute path and derive symbol paths without any external context or provider.

• relative: Path from workspace_root (used for Hash/Eq/Serialize)
• workspace_root: Shared workspace root (Arc for lightweight sharing)
• crate_name: The crate this file belongs to (required)

Creation

Always create via WorkspacePathResolver. Direct construction with new_unchecked() is for internal/test use only.

let resolver = WorkspacePathResolver::new("/path/to/workspace".into());
let path = resolver.resolve("src/lib.rs")?;

Implementations

impl WorkspaceFilePath

pub fn as_relative(&self) -> &Path

Get the relative path

pub fn workspace_root(&self) -> &Path

Get the workspace root

pub fn crate_name(&self) -> &CrateName

Get the crate name

pub fn to_absolute(&self) -> PathBuf

Get absolute path (no I/O, self-contained)

pub fn canonicalize(&self) -> Result<PathBuf>

Get canonicalized absolute path (with I/O)

pub fn file_name(&self) -> Option<&OsStr>

Get the file name

pub fn extension(&self) -> Option<&OsStr>

Get the file extension

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

Get the parent directory

pub fn is_rust_file(&self) -> bool

Check if this is a Rust source file

pub fn is_binary_entry(&self) -> bool

Check if this is a binary entry point (main.rs or src/bin/*.rs)

Binary entry points are handled separately from library code because:

• main.rs and lib.rs both map to the crate root in module path terms
• They represent different logical crates (binary vs library)
• Storing them together causes data overwrite issues

Returns

true if this file is:

• src/main.rs or */src/main.rs
• src/bin/*.rs or */src/bin/*.rs

pub fn with_context( &self, workspace_root: Arc<Path>, crate_name: CrateName, ) -> Self

Create a new WorkspaceFilePath with different context

This is useful after deserialization when both workspace_root and crate_name need to be set or updated.

pub fn with_relative(&self, relative: impl Into<PathBuf>) -> Self

Create a new WorkspaceFilePath with different relative path

This is useful for creating sibling files (e.g., creating src/storage.rs when you have src/lib.rs). The workspace_root and crate_name are inherited from the original path.

Example

let lib_rs = resolver.resolve("src/lib.rs")?;
let storage_rs = lib_rs.with_relative("src/storage.rs");

pub fn sibling(&self, file_name: &str) -> Self

Create a sibling file in the same directory

This is useful for creating module files (e.g., creating src/storage.rs when you have src/lib.rs).

Example

let lib_rs = resolver.resolve("src/lib.rs")?;
let storage_rs = lib_rs.sibling("storage.rs");
assert_eq!(storage_rs.as_relative(), Path::new("src/storage.rs"));

pub fn write(&self, content: impl AsRef<[u8]>) -> Result<()>

Write content to this file, creating parent directories if needed

This is the preferred way to write files in a workspace context. It automatically creates any missing parent directories before writing.

Example

let path = resolver.resolve("src/new_module/lib.rs")?;
path.write("// New module\n")?;  // Creates src/new_module/ if needed

pub fn read(&self) -> Result<String>

Read content from this file

pub fn read_bytes(&self) -> Result<Vec<u8>>

Read content as bytes from this file

pub fn exists(&self) -> bool

Check if the file exists

Trait Implementations

impl AsRef<Path> for WorkspaceFilePath

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for WorkspaceFilePath

fn clone(&self) -> WorkspaceFilePath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkspaceFilePath

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

Formats the value using the given formatter.

impl Display for WorkspaceFilePath

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

Formats the value using the given formatter.

impl Hash for WorkspaceFilePath

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 PartialEq for WorkspaceFilePath

fn eq(&self, other: &Self) -> 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 WorkspaceFilePath

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 WorkspaceFilePath