Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

path: Reimplement PathStyle on the standard library's path implementation (#64149)

Xin Zhaoa84689073d29
diff --git a/crates/language_tools/src/lsp_button.rs b/crates/language_tools/src/lsp_button.rs
index 49bd5053dd5..a8915b9a642 100644
--- a/crates/language_tools/src/lsp_button.rs
+++ b/crates/language_tools/src/lsp_button.rs
@@ -703,7 +703,7 @@ fn tooltip_for_server_binary(
let runtime = path_style.file_name(&server_binary.path).and_then(|name| {
["node", "python"]
.into_iter()
- .find(|runtime| name.starts_with(runtime))
+ .find(|runtime| name.to_string_lossy().starts_with(runtime))
});
let target_path = runtime
diff --git a/crates/path/src/path.rs b/crates/path/src/path.rs
index 83f386c756e..baa1b3bd3dd 100644
--- a/crates/path/src/path.rs
+++ b/crates/path/src/path.rs
@@ -8,13 +8,17 @@
use std::{
borrow::Cow,
+ ffi::OsStr,
path::{Path, PathBuf},
};
+use crate::path_component::{Component, Components, Prefix, PrefixExt, iter_after};
use crate::rel_path::RelPath;
pub mod abs_path;
+mod path_component;
pub mod rel_path;
+mod windows_prefix;
pub trait PathExt {
fn to_rel_path_buf(&self) -> anyhow::Result<rel_path::RelPathBuf>;
@@ -257,175 +261,30 @@ impl PathStyle {
)
}
- pub fn file_name(self, path: &Path) -> Option<&str> {
- if self == PathStyle::local() {
- return path.file_name().and_then(|n| n.to_str());
- }
- let path_string = path.to_str()?;
- let parent_length = self.parent(path)?.to_str()?.len();
- let remainder = path_string.get(parent_length..)?;
- let is_verbatim = self.is_windows() && path_string.as_bytes().starts_with(br"\\?\");
- let is_body_separator = |character: char| {
- if is_verbatim {
- character == '\\'
- } else {
- self.separators_ch().contains(&character)
- }
- };
-
- let component = remainder
- .rsplit(is_body_separator)
- .find(|component| !component.is_empty() && (is_verbatim || *component != "."))?;
- if matches!(component, "." | "..") {
- None
- } else {
- Some(component)
- }
+ pub fn file_name<'a>(&self, path: &'a Path) -> Option<&'a OsStr> {
+ self.components(path).next_back().and_then(|p| match p {
+ Component::Normal(p) => Some(p),
+ _ => None,
+ })
}
- pub fn parent(self, path: &Path) -> Option<&Path> {
- if self == PathStyle::local() {
- return path.parent();
- }
- let path = path.to_str()?;
- let path_bytes = path.as_bytes();
- let is_windows = self.is_windows();
-
- const DRIVE_PREFIX_LENGTH: usize = 2;
- const UNC_PREFIX_LENGTH: usize = 2;
- const VERBATIM_PREFIX: &[u8] = br"\\?\";
- const VERBATIM_UNC_PREFIX: &[u8] = br"\\?\UNC\";
- const DEVICE_PREFIX: &[u8] = br"\\.\";
-
- let is_separator = |byte: u8| byte == b'/' || is_windows && byte == b'\\';
- let is_verbatim = is_windows && path_bytes.starts_with(VERBATIM_PREFIX);
- let has_unc_prefix = path_bytes
- .get(..UNC_PREFIX_LENGTH)
- .is_some_and(|prefix| prefix.iter().all(|byte| is_separator(*byte)));
- // Verbatim paths treat '/' as a literal character, so only '\' separates body components.
- let is_body_separator = |byte: u8| {
- if is_verbatim {
- byte == b'\\'
- } else {
- is_separator(byte)
- }
- };
-
- let component_end = |component_start: usize| {
- path_bytes
- .get(component_start..)
- .and_then(|remainder| remainder.iter().position(|byte| is_body_separator(*byte)))
- .map_or(path_bytes.len(), |position| component_start + position)
- };
-
- // Windows prefixes, in precedence order: \\?\UNC\, \\?\ (verbatim), \\.\ (device),
- // \\ (UNC), drive letter. The device prefix must be matched before the generic UNC
- // check because it also starts with two separators.
- let prefix_end = {
- if !is_windows {
- 0
- } else if path_bytes.starts_with(VERBATIM_UNC_PREFIX) {
- let server_end = component_end(VERBATIM_UNC_PREFIX.len());
- let share_start = server_end.saturating_add(1).min(path_bytes.len());
- if share_start < path_bytes.len() {
- component_end(share_start)
- } else {
- server_end
- }
- } else if is_verbatim {
- let drive_start = VERBATIM_PREFIX.len();
- let drive_end = drive_start + DRIVE_PREFIX_LENGTH;
- let has_drive_prefix = path_bytes
- .get(drive_start)
- .is_some_and(u8::is_ascii_alphabetic)
- && path_bytes.get(drive_start + 1) == Some(&b':');
-
- // A drive letter only counts as a prefix when followed by a separator or end
- // of path; otherwise (e.g. `\\?\C:foo`) the whole first component is the prefix.
- if has_drive_prefix
- && path_bytes
- .get(drive_end)
- .is_none_or(|byte| is_separator(*byte))
- {
- drive_end
- } else {
- component_end(drive_start)
- }
- } else if path_bytes.starts_with(DEVICE_PREFIX) {
- component_end(DEVICE_PREFIX.len())
- } else if has_unc_prefix {
- let server_end = component_end(UNC_PREFIX_LENGTH);
- let share_start = server_end.saturating_add(1).min(path_bytes.len());
- let share_end = component_end(share_start);
- // A UNC prefix requires a share name; `\\server` without one is treated as a
- // relative path, so its prefix is empty.
- if server_end > UNC_PREFIX_LENGTH && share_end > share_start {
- share_end
- } else {
- 0
- }
- } else if path_bytes.first().is_some_and(u8::is_ascii_alphabetic)
- && path_bytes.get(1) == Some(&b':')
- {
- DRIVE_PREFIX_LENGTH
- } else {
- 0
- }
- };
-
- // Uses is_separator rather than is_body_separator: after a verbatim drive prefix,
- // '/' still counts as the root separator (e.g. `\\?\C:/foo`) even though '/' does
- // not separate body components.
- let has_root = path_bytes
- .get(prefix_end)
- .is_some_and(|byte| is_separator(*byte));
- // The leading `.`/`./` is absorbed into the body (e.g. `./a` → parent `.`).
- let starts_with_current_directory = prefix_end == 0
- && !has_root
- && path_bytes.first() == Some(&b'.')
- && (path_bytes.len() == 1 || path_bytes.get(1).is_some_and(|byte| is_separator(*byte)));
- let body_start =
- prefix_end + usize::from(has_root) + usize::from(starts_with_current_directory);
-
- // Loop because trimming a trailing '.' (e.g. `foo/.`) can expose a separator to trim,
- // and vice versa (`foo/./`). Verbatim paths never treat '.' as a current-directory
- // component, hence the !is_verbatim check below.
- let trim_trailing = |mut end: usize| {
- loop {
- while end > body_start && is_body_separator(path_bytes[end - 1]) {
- end -= 1;
- }
-
- let is_trailing_current_directory = !is_verbatim
- && end > body_start
- && path_bytes[end - 1] == b'.'
- && (end - 1 == body_start
- || end
- .checked_sub(2)
- .and_then(|index| path_bytes.get(index))
- .is_some_and(|byte| is_body_separator(*byte)));
- if is_trailing_current_directory {
- end -= 1;
- } else {
- return end;
- }
+ pub fn parent<'a>(&self, path: &'a Path) -> Option<&'a Path> {
+ let mut comps = self.components(path);
+ let comp = comps.next_back();
+ comp.and_then(|p| match p {
+ Component::Normal(_) | Component::CurDir | Component::ParentDir => {
+ Some(comps.as_path())
}
- };
-
- let body_end = trim_trailing(path_bytes.len());
- // An empty body means the path is root- or prefix-only and has no parent; only a
- // bare current-directory component (`.`/`./`) has `""` as its parent.
- if body_end == body_start {
- return starts_with_current_directory.then_some(Path::new(""));
- }
-
- let parent_end = path_bytes
- .get(body_start..body_end)?
- .iter()
- .rposition(|byte| is_body_separator(*byte))
- .map_or(body_start, |position| trim_trailing(body_start + position));
+ _ => None,
+ })
+ }
- Some(Path::new(path.get(..parent_end)?))
+ pub fn starts_with<P: AsRef<Path>>(&self, path: P, prefix: P) -> bool {
+ iter_after(
+ self.components(path.as_ref()),
+ self.components(prefix.as_ref()),
+ )
+ .is_some()
}
pub fn strip_prefix<'a>(
@@ -468,6 +327,51 @@ impl PathStyle {
}
}
+// This part contains the methods adopted from the std lib
+// to make the pub api of `PathStyle` compatible with `Path`
+impl PathStyle {
+ fn components<'a>(&self, path: &'a Path) -> Components<'a> {
+ Components::new(*self, path)
+ }
+
+ fn parse_prefix<'a>(&self, path: &'a OsStr) -> Option<Prefix<'a>> {
+ match self {
+ PathStyle::Unix => None,
+ PathStyle::Windows => windows_prefix::parse_prefix(path),
+ }
+ }
+
+ fn has_prefixes(&self) -> bool {
+ match self {
+ PathStyle::Unix => false,
+ PathStyle::Windows => true,
+ }
+ }
+
+ fn is_sep_byte(&self, b: u8) -> bool {
+ match self {
+ Self::Unix => b == b'/',
+ Self::Windows => b == b'\\' || b == b'/',
+ }
+ }
+
+ fn is_verbatim_sep(&self, b: u8) -> bool {
+ match self {
+ Self::Unix => self.is_sep_byte(b),
+ Self::Windows => b == b'\\',
+ }
+ }
+
+ fn has_physical_root(&self, s: &[u8], prefix: Option<Prefix<'_>>) -> bool {
+ let path = if let Some(p) = prefix {
+ &s[p.len()..]
+ } else {
+ s
+ };
+ !path.is_empty() && self.is_sep_byte(path[0])
+ }
+}
+
fn is_absolute(path_like: &str, path_style: PathStyle) -> bool {
path_like.starts_with('/')
|| path_style == PathStyle::Windows
@@ -691,6 +595,82 @@ mod tests {
pretty_assertions::assert_eq!(actual, expected);
}
+ #[test]
+ fn test_unix_path_style_starts_with() {
+ let unix_paths_and_prefixes = [
+ ("", "", true),
+ ("foo", "", true),
+ ("", "foo", false),
+ ("foo", "foo", true),
+ ("foo/", "foo", true),
+ ("foo//", "foo", true),
+ ("foo///", "foo", true),
+ ("foo/.", "foo", true),
+ ("foo/./bar", "foo/bar", true),
+ ("foo/.//bar", "foo/bar", true),
+ ("foo//./bar", "foo/bar", true),
+ ("foo/bar", "foo", true),
+ ("foo/bar", "foobar", false),
+ ("foo/bar/baz", "foo/bar", true),
+ ("foo/bar", "foo/bar/baz", false),
+ ("./foo/bar/", ".", true),
+ ("/etc/passwd", "/etc", true),
+ ("/etc/passwd", "/etc/", true),
+ ("/etc/passwd", "/etc/passwd", true),
+ ("/etc/passwd", "/etc/passwd/", true),
+ ("/etc/passwd", "/etc/passwd///", true),
+ ("/etc/passwd", "/e", false),
+ ("/etc/passwd", "/etc/passwd.txt", false),
+ ("/etc/foo.rs", "/etc/foo", false),
+ ];
+
+ for (path, prefix, expected) in unix_paths_and_prefixes {
+ assert_eq!(
+ PathStyle::Unix.starts_with(Path::new(path), Path::new(prefix)),
+ expected,
+ "{path:?}.starts_with({prefix:?})"
+ );
+ }
+ }
+
+ #[test]
+ fn test_windows_path_style_starts_with() {
+ let windows_paths_and_prefixes = [
+ (
+ r"C:\src\rust\cargo-test\test\Cargo.toml",
+ r"c:\src\rust\cargo-test\test",
+ true,
+ ),
+ (r"C:\foo\.\bar.txt", r"C:\foo\bar.txt", true),
+ (r"C:\foo\.", r"C:\foo", true),
+ (r"\\server\share", r"\\server", false),
+ (r"\\server\share\foo.txt", r"\\server", false),
+ (r"\\server\share\foo.txt", r"\\server\share", true),
+ (r"\\server\share\foo.txt", r"\\server\share\", true),
+ (r"\\server\share\foo.txt", r"\\server\share/", true),
+ (r"\\server\share\foo.txt", r"\\server\other", false),
+ (r"\\server\share\foo.txt", r"\\SERVER\share", false),
+ (r"\\?\C:\foo\.\bar.txt", r"\\?\C:\foo\bar.txt", false),
+ (r"\\?\C:\foo.txt", r"\\?\C:\", true),
+ (
+ r"\\?\UNC\server\share\foo.txt",
+ r"\\?\UNC\server\share",
+ true,
+ ),
+ (r"\\?\UNC\server\share\foo.txt", r"\\?\UNC\server\", false),
+ (r"\\?\bar\foo.txt", r"\\?\bar", true),
+ (r"\\?\C:\foo/bar.txt", r"\\?\C:\foo", false),
+ ];
+
+ for (path, prefix, expected) in windows_paths_and_prefixes {
+ assert_eq!(
+ PathStyle::Windows.starts_with(Path::new(path), Path::new(prefix)),
+ expected,
+ "{path:?}.starts_with({prefix:?})"
+ );
+ }
+ }
+
#[test]
fn test_unix_path_style_file_name() {
let unix_paths_and_filenames = [
@@ -708,7 +688,7 @@ mod tests {
];
for (path, filename) in unix_paths_and_filenames {
- assert_eq!(PathStyle::Unix.file_name(path), filename);
+ assert_eq!(PathStyle::Unix.file_name(path), filename.map(OsStr::new));
}
}
@@ -731,13 +711,13 @@ mod tests {
(Path::new("//server/share/foo.txt"), Some("foo.txt")),
(Path::new(r"\\?\bar"), None),
(Path::new(r"\\?\bar\foo.txt"), Some("foo.txt")),
- (Path::new(r"\\?\C:/foo/bar"), Some("foo/bar")),
+ (Path::new(r"\\?\C:/foo/bar"), None),
(Path::new(r"\\.\device"), None),
(Path::new(r"\\.\device\foo.txt"), Some("foo.txt")),
];
for (path, filename) in windows_paths_and_filenames {
- assert_eq!(PathStyle::Windows.file_name(path), filename);
+ assert_eq!(PathStyle::Windows.file_name(path), filename.map(OsStr::new));
}
}
@@ -801,7 +781,7 @@ mod tests {
Some(r"\\?\UNC\server\share\"),
),
(r"\\?\C:\foo.txt", Some(r"\\?\C:\")),
- (r"\\?\C:/foo/bar", Some(r"\\?\C:/")),
+ (r"\\?\C:/foo/bar", None),
(r"\\.\device", None),
(r"\\.\device\foo.txt", Some(r"\\.\device\")),
(".", Some("")),
@@ -823,16 +803,22 @@ mod tests {
use std::os::unix::ffi::OsStrExt;
let path = Path::new(OsStr::from_bytes(b"/home/user/\xff\xfe/repo/file.txt"));
- assert_eq!(PathStyle::Unix.file_name(path), Some("file.txt"));
+ assert_eq!(
+ PathStyle::Unix.file_name(path),
+ Some(OsStr::new("file.txt"))
+ );
assert_eq!(
PathStyle::Unix.parent(path),
Some(Path::new(OsStr::from_bytes(b"/home/user/\xff\xfe/repo")))
);
- let invalid_filename_path = Path::new(OsStr::from_bytes(b"/home/user/repo/\xff\xfe.txt"));
- assert_eq!(PathStyle::Unix.file_name(invalid_filename_path), None);
+ let another_path = Path::new(OsStr::from_bytes(b"/home/user/repo/\xff\xfe.txt"));
+ assert_eq!(
+ PathStyle::Unix.file_name(another_path),
+ Some(OsStr::from_bytes(b"\xff\xfe.txt"))
+ );
assert_eq!(
- PathStyle::Unix.parent(invalid_filename_path),
+ PathStyle::Unix.parent(another_path),
Some(Path::new("/home/user/repo"))
);
}
@@ -851,8 +837,14 @@ mod tests {
let os_str = OsString::from_wide(&wide);
let path = Path::new(&os_str);
- assert_eq!(PathStyle::Windows.file_name(path), Some("file.txt"));
+ assert_eq!(
+ PathStyle::Windows.file_name(path),
+ Some(OsStr::new("file.txt"))
+ );
let parent = PathStyle::Windows.parent(path).unwrap();
- assert_eq!(PathStyle::Windows.file_name(parent), Some("repo"));
+ assert_eq!(
+ PathStyle::Windows.file_name(parent),
+ Some(OsStr::new("repo"))
+ );
}
}
diff --git a/crates/path/src/path_component.rs b/crates/path/src/path_component.rs
new file mode 100644
index 00000000000..6b92e8b683d
--- /dev/null
+++ b/crates/path/src/path_component.rs
@@ -0,0 +1,449 @@
+//! Path component parsing adapted from the Rust standard library
+//! (`std::path::Components` in rust-lang/rust's `library/std/src/path.rs`,
+//! revision 315ecf4a9).
+//!
+//! The code is largely a copy of upstream; the only notable changes are
+//! `PathStyle`-related: the `cfg(windows)`/`cfg(unix)` branches are replaced
+//! with runtime checks on [`PathStyle`], and helpers that `std` defines as
+//! private inherent methods on `Prefix` live in the local [`PrefixExt`] trait.
+
+use crate::PathStyle;
+use std::ffi::OsStr;
+use std::path::Path;
+pub use std::path::Prefix;
+
+pub(crate) trait PrefixExt {
+ fn len(&self) -> usize;
+ fn is_drive(&self) -> bool;
+
+ #[inline]
+ fn has_implicit_root(&self) -> bool {
+ !self.is_drive()
+ }
+}
+
+impl PrefixExt for Prefix<'_> {
+ #[inline]
+ fn len(&self) -> usize {
+ use self::Prefix::*;
+ fn os_str_len(s: &OsStr) -> usize {
+ s.as_encoded_bytes().len()
+ }
+ match *self {
+ Verbatim(x) => 4 + os_str_len(x),
+ VerbatimUNC(x, y) => {
+ 8 + os_str_len(x)
+ + if os_str_len(y) > 0 {
+ 1 + os_str_len(y)
+ } else {
+ 0
+ }
+ }
+ VerbatimDisk(_) => 6,
+ UNC(x, y) => {
+ 2 + os_str_len(x)
+ + if os_str_len(y) > 0 {
+ 1 + os_str_len(y)
+ } else {
+ 0
+ }
+ }
+ DeviceNS(x) => 4 + os_str_len(x),
+ Disk(_) => 2,
+ }
+ }
+
+ #[inline]
+ fn is_drive(&self) -> bool {
+ matches!(*self, Prefix::Disk(_))
+ }
+}
+
+// Iterate through `iter` while it matches `prefix`; return `None` if `prefix`
+// is not a prefix of `iter`, otherwise return `Some(iter_after_prefix)` giving
+// `iter` after having exhausted `prefix`.
+pub(crate) fn iter_after<'a, 'b, I, J>(mut iter: I, mut prefix: J) -> Option<I>
+where
+ I: Iterator<Item = Component<'a>> + Clone,
+ J: Iterator<Item = Component<'b>>,
+{
+ loop {
+ let mut iter_next = iter.clone();
+ match (iter_next.next(), prefix.next()) {
+ (Some(ref x), Some(ref y)) if x == y => (),
+ (Some(_), Some(_)) => return None,
+ (Some(_), None) => return Some(iter),
+ (None, None) => return Some(iter),
+ (None, Some(_)) => return None,
+ }
+ iter = iter_next;
+ }
+}
+
+#[derive(PartialEq, PartialOrd, Clone)]
+enum State {
+ Prefix = 0, // c:
+ StartDir = 1, // / or . or nothing
+ Body = 2, // foo/bar/baz
+ Done = 3,
+}
+
+#[allow(dead_code)]
+pub(crate) struct PrefixComponent<'a> {
+ /// The prefix as an unparsed `OsStr` slice.
+ raw: &'a OsStr,
+
+ /// The parsed prefix data.
+ parsed: Prefix<'a>,
+}
+
+impl<'a> PartialEq for PrefixComponent<'a> {
+ #[inline]
+ fn eq(&self, other: &PrefixComponent<'a>) -> bool {
+ self.parsed == other.parsed
+ }
+}
+
+#[derive(PartialEq)]
+pub(crate) enum Component<'a> {
+ /// A Windows path prefix, e.g., `C:` or `\\server\share`.
+ ///
+ /// There is a large variety of prefix types, see [`Prefix`]'s documentation
+ /// for more.
+ ///
+ /// Does not occur on Unix.
+ Prefix(PrefixComponent<'a>),
+
+ /// The root directory component, appears after any prefix and before anything else.
+ ///
+ /// It represents a separator that designates that a path starts from root.
+ RootDir,
+
+ /// A reference to the current directory, i.e., `.`.
+ CurDir,
+
+ /// A reference to the parent directory, i.e., `..`.
+ ParentDir,
+
+ /// A normal component, e.g., `a` and `b` in `a/b`.
+ ///
+ /// This variant is the most common one, it represents references to files
+ /// or directories.
+ Normal(&'a OsStr),
+}
+
+#[derive(Clone)]
+pub(crate) struct Components<'a> {
+ path_style: PathStyle,
+
+ // The path left to parse components from
+ path: &'a [u8],
+
+ // The prefix as it was originally parsed, if any
+ prefix: Option<Prefix<'a>>,
+
+ // true if path *physically* has a root separator; for most Windows
+ // prefixes, it may have a "logical" root separator for the purposes of
+ // normalization, e.g., \\server\share == \\server\share\.
+ has_physical_root: bool,
+
+ // The iterator is double-ended, and these two states keep track of what has
+ // been produced from either end
+ front: State,
+ back: State,
+}
+
+impl<'a> Components<'a> {
+ pub fn new(path_style: PathStyle, path: &'a Path) -> Self {
+ let prefix = path_style.parse_prefix(path.as_os_str());
+ Components {
+ path_style,
+ path: path.as_os_str().as_encoded_bytes(),
+ prefix,
+ has_physical_root: path_style
+ .has_physical_root(path.as_os_str().as_encoded_bytes(), prefix),
+ // use a platform-specific initial state to avoid one turn of
+ // the state-machine when the platform doesn't have a Prefix.
+ front: if path_style.has_prefixes() {
+ State::Prefix
+ } else {
+ State::StartDir
+ },
+ back: State::Body,
+ }
+ }
+
+ fn has_prefixes(&self) -> bool {
+ self.path_style.has_prefixes()
+ }
+
+ #[inline]
+ fn prefix_len(&self) -> usize {
+ if !self.has_prefixes() {
+ return 0;
+ }
+ self.prefix.as_ref().map(Prefix::len).unwrap_or(0)
+ }
+
+ #[inline]
+ fn prefix_verbatim(&self) -> bool {
+ if !self.has_prefixes() {
+ return false;
+ }
+ self.prefix
+ .as_ref()
+ .map(Prefix::is_verbatim)
+ .unwrap_or(false)
+ }
+
+ #[inline]
+ fn prefix_remaining(&self) -> usize {
+ if !self.has_prefixes() {
+ return 0;
+ }
+ if self.front == State::Prefix {
+ self.prefix_len()
+ } else {
+ 0
+ }
+ }
+
+ #[inline]
+ fn len_before_body(&self) -> usize {
+ let root = if self.front <= State::StartDir && self.has_physical_root {
+ 1
+ } else {
+ 0
+ };
+ let cur_dir = if self.front <= State::StartDir && self.include_cur_dir() {
+ 1
+ } else {
+ 0
+ };
+ self.prefix_remaining() + root + cur_dir
+ }
+
+ #[inline]
+ fn finished(&self) -> bool {
+ self.front == State::Done || self.back == State::Done || self.front > self.back
+ }
+
+ #[inline]
+ fn is_sep_byte(&self, b: u8) -> bool {
+ if self.prefix_verbatim() {
+ self.path_style.is_verbatim_sep(b)
+ } else {
+ self.path_style.is_sep_byte(b)
+ }
+ }
+
+ pub fn as_path(&self) -> &'a Path {
+ let mut comps = self.clone();
+ if comps.front == State::Body {
+ comps.trim_left();
+ }
+ if comps.back == State::Body {
+ comps.trim_right();
+ }
+ unsafe { Path::new(OsStr::from_encoded_bytes_unchecked(comps.path)) }
+ }
+
+ fn has_root(&self) -> bool {
+ if self.has_physical_root {
+ return true;
+ }
+ if self.has_prefixes()
+ && let Some(p) = self.prefix
+ {
+ if p.has_implicit_root() {
+ return true;
+ }
+ }
+ false
+ }
+
+ fn include_cur_dir(&self) -> bool {
+ if self.has_root() {
+ return false;
+ }
+ let slice = &self.path[self.prefix_remaining()..];
+ match slice {
+ [b'.'] => true,
+ [b'.', b, ..] => self.is_sep_byte(*b),
+ _ => false,
+ }
+ }
+
+ unsafe fn parse_single_component<'b>(&self, comp: &'b [u8]) -> Option<Component<'b>> {
+ match comp {
+ b"." if self.has_prefixes() && self.prefix_verbatim() => Some(Component::CurDir),
+ b"." => None, // . components are normalized away, except at
+ // the beginning of a path, which is treated
+ // separately via `include_cur_dir`
+ b".." => Some(Component::ParentDir),
+ b"" => None,
+ _ => Some(Component::Normal(unsafe {
+ OsStr::from_encoded_bytes_unchecked(comp)
+ })),
+ }
+ }
+
+ fn parse_next_component(&self) -> (usize, Option<Component<'a>>) {
+ debug_assert!(self.front == State::Body);
+ let (extra, comp) = match self.path.iter().position(|b| self.is_sep_byte(*b)) {
+ None => (0, self.path),
+ Some(i) => (1, &self.path[..i]),
+ };
+ // SAFETY: `comp` is a valid substring, since it is split on a separator.
+ (comp.len() + extra, unsafe {
+ self.parse_single_component(comp)
+ })
+ }
+
+ fn parse_next_component_back(&self) -> (usize, Option<Component<'a>>) {
+ debug_assert!(self.back == State::Body);
+ let start = self.len_before_body();
+ let (extra, comp) = match self.path[start..]
+ .iter()
+ .rposition(|b| self.is_sep_byte(*b))
+ {
+ None => (0, &self.path[start..]),
+ Some(i) => (1, &self.path[start + i + 1..]),
+ };
+ // SAFETY: `comp` is a valid substring, since it is split on a separator.
+ (comp.len() + extra, unsafe {
+ self.parse_single_component(comp)
+ })
+ }
+
+ fn trim_left(&mut self) {
+ while !self.path.is_empty() {
+ let (size, comp) = self.parse_next_component();
+ if comp.is_some() {
+ return;
+ } else {
+ self.path = &self.path[size..];
+ }
+ }
+ }
+
+ fn trim_right(&mut self) {
+ while self.path.len() > self.len_before_body() {
+ let (size, comp) = self.parse_next_component_back();
+ if comp.is_some() {
+ return;
+ } else {
+ self.path = &self.path[..self.path.len() - size];
+ }
+ }
+ }
+}
+
+impl<'a> Iterator for Components<'a> {
+ type Item = Component<'a>;
+
+ fn next(&mut self) -> Option<Component<'a>> {
+ while !self.finished() {
+ match self.front {
+ // most likely case first
+ State::Body if !self.path.is_empty() => {
+ let (size, comp) = self.parse_next_component();
+ self.path = &self.path[size..];
+ if comp.is_some() {
+ return comp;
+ }
+ }
+ State::Body => {
+ self.front = State::Done;
+ }
+ State::StartDir => {
+ self.front = State::Body;
+ if self.has_physical_root {
+ debug_assert!(!self.path.is_empty());
+ self.path = &self.path[1..];
+ return Some(Component::RootDir);
+ } else if self.has_prefixes()
+ && let Some(p) = self.prefix
+ {
+ if p.has_implicit_root() && !p.is_verbatim() {
+ return Some(Component::RootDir);
+ }
+ } else if self.include_cur_dir() {
+ debug_assert!(!self.path.is_empty());
+ self.path = &self.path[1..];
+ return Some(Component::CurDir);
+ }
+ }
+ _ if !self.has_prefixes() => unreachable!(),
+ State::Prefix if self.prefix_len() == 0 => {
+ self.front = State::StartDir;
+ }
+ State::Prefix => {
+ self.front = State::StartDir;
+ debug_assert!(self.prefix_len() <= self.path.len());
+ let raw = &self.path[..self.prefix_len()];
+ self.path = &self.path[self.prefix_len()..];
+ return Some(Component::Prefix(PrefixComponent {
+ raw: unsafe { OsStr::from_encoded_bytes_unchecked(raw) },
+ parsed: self.prefix.unwrap(),
+ }));
+ }
+ State::Done => unreachable!(),
+ }
+ }
+ None
+ }
+}
+
+impl<'a> DoubleEndedIterator for Components<'a> {
+ fn next_back(&mut self) -> Option<Component<'a>> {
+ while !self.finished() {
+ match self.back {
+ State::Body if self.path.len() > self.len_before_body() => {
+ let (size, comp) = self.parse_next_component_back();
+ self.path = &self.path[..self.path.len() - size];
+ if comp.is_some() {
+ return comp;
+ }
+ }
+ State::Body => {
+ self.back = State::StartDir;
+ }
+ State::StartDir => {
+ self.back = if self.has_prefixes() {
+ State::Prefix
+ } else {
+ State::Done
+ };
+ if self.has_physical_root {
+ self.path = &self.path[..self.path.len() - 1];
+ return Some(Component::RootDir);
+ } else if self.has_prefixes()
+ && let Some(p) = self.prefix
+ {
+ if p.has_implicit_root() && !p.is_verbatim() {
+ return Some(Component::RootDir);
+ }
+ } else if self.include_cur_dir() {
+ self.path = &self.path[..self.path.len() - 1];
+ return Some(Component::CurDir);
+ }
+ }
+ _ if !self.has_prefixes() => unreachable!(),
+ State::Prefix if self.prefix_len() > 0 => {
+ self.back = State::Done;
+ return Some(Component::Prefix(PrefixComponent {
+ raw: unsafe { OsStr::from_encoded_bytes_unchecked(self.path) },
+ parsed: self.prefix.unwrap(),
+ }));
+ }
+ State::Prefix => {
+ self.back = State::Done;
+ return None;
+ }
+ State::Done => unreachable!(),
+ }
+ }
+ None
+ }
+}
diff --git a/crates/path/src/windows_prefix.rs b/crates/path/src/windows_prefix.rs
new file mode 100644
index 00000000000..b59531e4cf4
--- /dev/null
+++ b/crates/path/src/windows_prefix.rs
@@ -0,0 +1,212 @@
+//! Windows prefix parsing adapted from the Rust standard library
+//! (rust-lang/rust's `library/std/src/sys/path/windows_prefix.rs`, revision
+//! 315ecf4a9).
+//!
+//! The code is a near-verbatim copy of upstream; the only notable changes are
+//! `PathStyle`-related: the separator helpers delegate to [`PathStyle::Windows`].
+
+use crate::PathStyle;
+use std::ffi::OsStr;
+use std::path::Prefix;
+
+struct PrefixParser<'a, const LEN: usize> {
+ path: &'a OsStr,
+ prefix: [u8; LEN],
+}
+
+impl<'a, const LEN: usize> PrefixParser<'a, LEN> {
+ #[inline]
+ fn get_prefix(path: &OsStr) -> [u8; LEN] {
+ let mut prefix = [0; LEN];
+ // SAFETY: Only ASCII characters are modified.
+ for (i, &ch) in path.as_encoded_bytes().iter().take(LEN).enumerate() {
+ prefix[i] = if ch == b'/' { b'\\' } else { ch };
+ }
+ prefix
+ }
+
+ fn new(path: &'a OsStr) -> Self {
+ Self {
+ path,
+ prefix: Self::get_prefix(path),
+ }
+ }
+
+ fn as_slice(&self) -> PrefixParserSlice<'a, '_> {
+ PrefixParserSlice {
+ path: self.path,
+ prefix: &self.prefix[..LEN.min(self.path.len())],
+ index: 0,
+ }
+ }
+}
+
+struct PrefixParserSlice<'a, 'b> {
+ path: &'a OsStr,
+ prefix: &'b [u8],
+ index: usize,
+}
+
+impl<'a> PrefixParserSlice<'a, '_> {
+ fn strip_prefix(&self, prefix: &str) -> Option<Self> {
+ self.prefix[self.index..]
+ .starts_with(prefix.as_bytes())
+ .then_some(Self {
+ index: self.index + prefix.len(),
+ ..*self
+ })
+ }
+
+ fn prefix_bytes(&self) -> &'a [u8] {
+ &self.path.as_encoded_bytes()[..self.index]
+ }
+
+ fn finish(self) -> &'a OsStr {
+ // SAFETY: The unsafety here stems from converting between &OsStr and
+ // &[u8] and back. This is safe to do because (1) we only look at ASCII
+ // contents of the encoding and (2) new &OsStr values are produced only
+ // from ASCII-bounded slices of existing &OsStr values.
+ unsafe { OsStr::from_encoded_bytes_unchecked(&self.path.as_encoded_bytes()[self.index..]) }
+ }
+}
+
+pub fn parse_prefix(path: &OsStr) -> Option<Prefix<'_>> {
+ use Prefix::{DeviceNS, Disk, UNC, Verbatim, VerbatimDisk, VerbatimUNC};
+
+ let parser = PrefixParser::<8>::new(path);
+ let parser = parser.as_slice();
+ if let Some(parser) = parser.strip_prefix(r"\\") {
+ // \\
+
+ // It's a POSIX path.
+ if cfg!(target_os = "cygwin") && !path.as_encoded_bytes().contains(&b'\\') {
+ return None;
+ }
+
+ // The meaning of verbatim paths can change when they use a different
+ // separator.
+ if let Some(parser) = parser.strip_prefix(r"?\")
+ // Cygwin allows `/` in verbatim paths.
+ && (cfg!(target_os = "cygwin") || !parser.prefix_bytes().contains(&b'/'))
+ {
+ // \\?\
+ if let Some(parser) = parser.strip_prefix(r"UNC\") {
+ // \\?\UNC\server\share
+
+ let path = parser.finish();
+ let (server, path) = parse_next_component(path, true);
+ let (share, _) = parse_next_component(path, true);
+
+ Some(VerbatimUNC(server, share))
+ } else {
+ let path = parser.finish();
+
+ // in verbatim paths only recognize an exact drive prefix
+ if let Some(drive) = parse_drive_exact(path) {
+ // \\?\C:
+ Some(VerbatimDisk(drive))
+ } else {
+ // \\?\prefix
+ let (prefix, _) = parse_next_component(path, true);
+ Some(Verbatim(prefix))
+ }
+ }
+ } else if let Some(parser) = parser.strip_prefix(r".\") {
+ // \\.\COM42
+ let path = parser.finish();
+ let (prefix, _) = parse_next_component(path, false);
+ Some(DeviceNS(prefix))
+ } else {
+ let path = parser.finish();
+ let (server, path) = parse_next_component(path, false);
+ let (share, _) = parse_next_component(path, false);
+
+ if !server.is_empty() && !share.is_empty() {
+ // \\server\share
+ Some(UNC(server, share))
+ } else {
+ // no valid prefix beginning with "\\" recognized
+ None
+ }
+ }
+ } else {
+ // If it has a drive like `C:` then it's a disk.
+ // Otherwise there is no prefix.
+ Some(Disk(parse_drive(path)?))
+ }
+}
+
+// Parses a drive prefix, e.g. "C:" and "C:\whatever"
+fn parse_drive(path: &OsStr) -> Option<u8> {
+ // In most DOS systems, it is not possible to have more than 26 drive letters.
+ // See <https://en.wikipedia.org/wiki/Drive_letter_assignment#Common_assignments>.
+ fn is_valid_drive_letter(drive: &u8) -> bool {
+ drive.is_ascii_alphabetic()
+ }
+
+ match path.as_encoded_bytes() {
+ [drive, b':', ..] if is_valid_drive_letter(drive) => Some(drive.to_ascii_uppercase()),
+ _ => None,
+ }
+}
+
+// Parses a drive prefix exactly, e.g. "C:"
+fn parse_drive_exact(path: &OsStr) -> Option<u8> {
+ // only parse two bytes: the drive letter and the drive separator
+ if path
+ .as_encoded_bytes()
+ .get(2)
+ .map(|&x| is_verbatim_sep(x))
+ .unwrap_or(true)
+ {
+ parse_drive(path)
+ } else {
+ None
+ }
+}
+
+// Parse the next path component.
+//
+// Returns the next component and the rest of the path excluding the component and separator.
+// Does not recognize `/` as a separator character on Windows if `verbatim` is true.
+pub(crate) fn parse_next_component(path: &OsStr, verbatim: bool) -> (&OsStr, &OsStr) {
+ let separator = if verbatim {
+ is_verbatim_sep
+ } else {
+ is_sep_byte
+ };
+
+ match path.as_encoded_bytes().iter().position(|&x| separator(x)) {
+ Some(separator_start) => {
+ let separator_end = separator_start + 1;
+
+ let component = &path.as_encoded_bytes()[..separator_start];
+
+ // Panic safe
+ // The max `separator_end` is `bytes.len()` and `bytes[bytes.len()..]` is a valid index.
+ let path = &path.as_encoded_bytes()[separator_end..];
+
+ // SAFETY: `path` is a valid wtf8 encoded slice and each of the separators ('/', '\')
+ // is encoded in a single byte, therefore `bytes[separator_start]` and
+ // `bytes[separator_end]` must be code point boundaries and thus
+ // `bytes[..separator_start]` and `bytes[separator_end..]` are valid wtf8 slices.
+ unsafe {
+ (
+ OsStr::from_encoded_bytes_unchecked(component),
+ OsStr::from_encoded_bytes_unchecked(path),
+ )
+ }
+ }
+ None => (path, OsStr::new("")),
+ }
+}
+
+#[inline]
+fn is_verbatim_sep(b: u8) -> bool {
+ PathStyle::Windows.is_verbatim_sep(b)
+}
+
+#[inline]
+fn is_sep_byte(b: u8) -> bool {
+ PathStyle::Windows.is_sep_byte(b)
+}
diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs
index a9730c4f071..cfc1f1bd087 100644
--- a/crates/project/src/git_store.rs
+++ b/crates/project/src/git_store.rs
@@ -10938,7 +10938,7 @@ async fn remove_empty_managed_worktree_ancestors(fs: &dyn Fs, child_path: &Path,
pub fn repo_identity_path(common_dir: &Path, path_style: PathStyle) -> &Path {
let is_dot_entry = path_style
.file_name(common_dir)
- .is_some_and(|n| n.starts_with('.'));
+ .is_some_and(|n| n.to_string_lossy().starts_with('.'));
if is_dot_entry {
path_style.parent(common_dir).unwrap_or(common_dir)
} else {
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 09c36b38555..6fd8b7bacd8 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -279,12 +279,12 @@ impl Render for TitleBar {
});
let display_name = if identity.extension() == Some(std::ffi::OsStr::new("git")) {
- identity.file_stem().and_then(|n| n.to_str())
+ identity.file_stem()
} else {
repo.path_style.file_name(identity)
};
- if let Some(repo_name) = display_name {
+ if let Some(repo_name) = display_name.and_then(|n| n.to_str()) {
let visible_worktrees_in_repo = self.visible_worktrees_in_repository(repo, cx);
let name = if visible_worktrees_in_repo == 1 {
if let Ok(relative) =