diff --git a/CHANGELOG.md b/CHANGELOG.md
index f5316048..4cfa465a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - zsh: better cd completions.
 - elvish: `z -` now work as expected.
 - Lazily delete excluded directories from the database.
+- Normalize drive letters when resolving paths on Windows.
 
 ## [0.9.4] - 2024-02-21
 
diff --git a/src/util.rs b/src/util.rs
index 1f8fc95f..e1d15a32 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -292,43 +292,74 @@ pub fn resolve_path(path: impl AsRef<Path>) -> Result<PathBuf> {
         }
 
         fn get_drive_path(drive_letter: u8) -> PathBuf {
-            format!(r"{}:\", drive_letter as char).into()
+            format!(r"{}:\", patch_drive_letter(drive_letter)).into()
         }
 
         fn get_drive_relative(drive_letter: u8) -> Result<PathBuf> {
             let path = current_dir()?;
             if Some(drive_letter) == get_drive_letter(&path) {
-                return Ok(path);
+                return Ok(patch_drive_prefix(path));
             }
 
-            if let Some(path) = env::var_os(format!("={}:", drive_letter as char)) {
-                return Ok(path.into());
+            if let Some(path) = env::var_os(format!("={}:", patch_drive_letter(drive_letter))) {
+                return Ok(patch_drive_prefix(path.into()));
             }
 
             let path = get_drive_path(drive_letter);
             Ok(path)
         }
 
+        fn patch_drive_letter(drive_letter: u8) -> char {
+            drive_letter.to_ascii_uppercase() as char
+        }
+
+        // https://github.com/rust-lang/rust-analyzer/pull/14689
+        fn patch_drive_prefix(path: PathBuf) -> PathBuf {
+            let mut components = path.components();
+
+            match components.next() {
+                Some(Component::Prefix(prefix)) => {
+                    let prefix = match prefix.kind() {
+                        Prefix::Disk(drive_letter) => {
+                            format!(r"{}:", patch_drive_letter(drive_letter))
+                        }
+                        Prefix::VerbatimDisk(drive_letter) => {
+                            format!(r"\\?\{}:", patch_drive_letter(drive_letter))
+                        }
+                        _ => return path,
+                    };
+
+                    let mut path = PathBuf::default();
+                    path.push(prefix);
+                    path.extend(components);
+                    path
+                }
+                _ => path,
+            }
+        }
+
         match components.peek() {
             Some(Component::Prefix(prefix)) => match prefix.kind() {
                 Prefix::Disk(drive_letter) => {
-                    let disk = components.next().unwrap();
+                    components.next();
                     if components.peek() == Some(&Component::RootDir) {
-                        let root = components.next().unwrap();
-                        stack.push(disk);
-                        stack.push(root);
+                        components.next();
+                        base_path = get_drive_path(drive_letter);
                     } else {
                         base_path = get_drive_relative(drive_letter)?;
-                        stack.extend(base_path.components());
                     }
+
+                    stack.extend(base_path.components());
                 }
                 Prefix::VerbatimDisk(drive_letter) => {
                     components.next();
                     if components.peek() == Some(&Component::RootDir) {
                         components.next();
+                        base_path = get_drive_path(drive_letter);
+                    } else {
+                        bail!("illegal path: {}", path.display());
                     }
 
-                    base_path = get_drive_path(drive_letter);
                     stack.extend(base_path.components());
                 }
                 _ => bail!("invalid path: {}", path.display()),