4 files changed, 139 insertions, 15 deletions

diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index d8beac98a..3953017c3 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -112,14 +112,13 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
     pub fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
         self.imp.expand(macro_call)
     }
-
-    pub fn expand_hypothetical(
+    pub fn speculative_expand(
         &self,
         actual_macro_call: &ast::MacroCall,
         hypothetical_args: &ast::TokenTree,
         token_to_map: SyntaxToken,
     ) -> Option<(SyntaxNode, SyntaxToken)> {
-        self.imp.expand_hypothetical(actual_macro_call, hypothetical_args, token_to_map)
+        self.imp.speculative_expand(actual_macro_call, hypothetical_args, token_to_map)
     }
 
     pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
@@ -311,7 +310,7 @@ impl<'db> SemanticsImpl<'db> {
         Some(node)
     }
 
-    fn expand_hypothetical(
+    fn speculative_expand(
         &self,
         actual_macro_call: &ast::MacroCall,
         hypothetical_args: &ast::TokenTree,
@@ -756,7 +755,7 @@ impl<'a> SemanticsScope<'a> {
 
     /// Resolve a path as-if it was written at the given scope. This is
     /// necessary a heuristic, as it doesn't take hygiene into account.
-    pub fn resolve_hypothetical(&self, path: &ast::Path) -> Option<PathResolution> {
+    pub fn speculative_resolve(&self, path: &ast::Path) -> Option<PathResolution> {
         let hygiene = Hygiene::new(self.db.upcast(), self.file_id);
         let path = Path::from_src(path.clone(), &hygiene)?;
         self.resolve_hir_path(&path)
diff --git a/crates/ide/src/completion/completion_context.rs b/crates/ide/src/completion/completion_context.rs
index 3857dce67..85456a66f 100644
--- a/crates/ide/src/completion/completion_context.rs
+++ b/crates/ide/src/completion/completion_context.rs
@@ -185,7 +185,7 @@ impl<'a> CompletionContext<'a> {
             };
             if let (Some(actual_expansion), Some(hypothetical_expansion)) = (
                 ctx.sema.expand(&actual_macro_call),
-                ctx.sema.expand_hypothetical(
+                ctx.sema.speculative_expand(
                     &actual_macro_call,
                     &hypothetical_args,
                     fake_ident_token,
diff --git a/crates/ssr/src/resolving.rs b/crates/ssr/src/resolving.rs
index 4441fb426..b932132d5 100644
--- a/crates/ssr/src/resolving.rs
+++ b/crates/ssr/src/resolving.rs
@@ -212,13 +212,13 @@ impl<'db> ResolutionScope<'db> {
         // First try resolving the whole path. This will work for things like
         // `std::collections::HashMap`, but will fail for things like
         // `std::collections::HashMap::new`.
-        if let Some(resolution) = self.scope.resolve_hypothetical(&path) {
+        if let Some(resolution) = self.scope.speculative_resolve(&path) {
             return Some(resolution);
         }
         // Resolution failed, try resolving the qualifier (e.g. `std::collections::HashMap` and if
         // that succeeds, then iterate through the candidates on the resolved type with the provided
         // name.
-        let resolved_qualifier = self.scope.resolve_hypothetical(&path.qualifier()?)?;
+        let resolved_qualifier = self.scope.speculative_resolve(&path.qualifier()?)?;
         if let hir::PathResolution::Def(hir::ModuleDef::Adt(adt)) = resolved_qualifier {
             let name = path.segment()?.name_ref()?;
             adt.ty(self.scope.db).iterate_path_candidates(
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
index 04a42264e..944a702df 100644
--- a/crates/vfs/src/vfs_path.rs
+++ b/crates/vfs/src/vfs_path.rs
@@ -57,23 +57,42 @@ impl VfsPath {
         };
         buf.push(tag);
         match &self.0 {
-            VfsPathRepr::PathBuf(it) => {
-                let path: &std::ffi::OsStr = it.as_os_str();
+            VfsPathRepr::PathBuf(path) => {
                 #[cfg(windows)]
                 {
-                    use std::os::windows::ffi::OsStrExt;
-                    for wchar in path.encode_wide() {
-                        buf.extend(wchar.to_le_bytes().iter().copied());
+                    use windows_paths::Encode;
+                    let components = path.components();
+                    let mut add_sep = false;
+                    for component in components {
+                        if add_sep {
+                            windows_paths::SEP.encode(buf);
+                        }
+                        let len_before = buf.len();
+                        match component {
+                            std::path::Component::Prefix(prefix) => {
+                                // kind() returns a normalized and comparable path prefix.
+                                prefix.kind().encode(buf);
+                            }
+                            std::path::Component::RootDir => {
+                                if !add_sep {
+                                    component.as_os_str().encode(buf);
+                                }
+                            }
+                            _ => component.as_os_str().encode(buf),
+                        }
+
+                        // some components may be encoded empty
+                        add_sep = len_before != buf.len();
                     }
                 }
                 #[cfg(unix)]
                 {
                     use std::os::unix::ffi::OsStrExt;
-                    buf.extend(path.as_bytes());
+                    buf.extend(path.as_os_str().as_bytes());
                 }
                 #[cfg(not(any(windows, unix)))]
                 {
-                    buf.extend(path.to_string_lossy().as_bytes());
+                    buf.extend(path.as_os_str().to_string_lossy().as_bytes());
                 }
             }
             VfsPathRepr::VirtualPath(VirtualPath(s)) => buf.extend(s.as_bytes()),
@@ -81,6 +100,112 @@ impl VfsPath {
     }
 }
 
+#[cfg(windows)]
+mod windows_paths {
+    pub trait Encode {
+        fn encode(&self, buf: &mut Vec<u8>);
+    }
+
+    impl Encode for std::ffi::OsStr {
+        fn encode(&self, buf: &mut Vec<u8>) {
+            use std::os::windows::ffi::OsStrExt;
+            for wchar in self.encode_wide() {
+                buf.extend(wchar.to_le_bytes().iter().copied());
+            }
+        }
+    }
+
+    impl Encode for u8 {
+        fn encode(&self, buf: &mut Vec<u8>) {
+            let wide = *self as u16;
+            buf.extend(wide.to_le_bytes().iter().copied())
+        }
+    }
+
+    impl Encode for &str {
+        fn encode(&self, buf: &mut Vec<u8>) {
+            debug_assert!(self.is_ascii());
+            for b in self.as_bytes() {
+                b.encode(buf)
+            }
+        }
+    }
+
+    pub const SEP: &str = "\\";
+    const VERBATIM: &str = "\\\\?\\";
+    const UNC: &str = "UNC";
+    const DEVICE: &str = "\\\\.\\";
+    const COLON: &str = ":";
+
+    impl Encode for std::path::Prefix<'_> {
+        fn encode(&self, buf: &mut Vec<u8>) {
+            match self {
+                std::path::Prefix::Verbatim(c) => {
+                    VERBATIM.encode(buf);
+                    c.encode(buf);
+                }
+                std::path::Prefix::VerbatimUNC(server, share) => {
+                    VERBATIM.encode(buf);
+                    UNC.encode(buf);
+                    SEP.encode(buf);
+                    server.encode(buf);
+                    SEP.encode(buf);
+                    share.encode(buf);
+                }
+                std::path::Prefix::VerbatimDisk(d) => {
+                    VERBATIM.encode(buf);
+                    d.encode(buf);
+                    COLON.encode(buf);
+                }
+                std::path::Prefix::DeviceNS(device) => {
+                    DEVICE.encode(buf);
+                    device.encode(buf);
+                }
+                std::path::Prefix::UNC(server, share) => {
+                    SEP.encode(buf);
+                    SEP.encode(buf);
+                    server.encode(buf);
+                    SEP.encode(buf);
+                    share.encode(buf);
+                }
+                std::path::Prefix::Disk(d) => {
+                    d.encode(buf);
+                    COLON.encode(buf);
+                }
+            }
+        }
+    }
+    #[test]
+    fn paths_encoding() {
+        // drive letter casing agnostic
+        test_eq("C:/x.rs", "c:/x.rs");
+        // separator agnostic
+        test_eq("C:/x/y.rs", "C:\\x\\y.rs");
+
+        fn test_eq(a: &str, b: &str) {
+            let mut b1 = Vec::new();
+            let mut b2 = Vec::new();
+            vfs(a).encode(&mut b1);
+            vfs(b).encode(&mut b2);
+            assert_eq!(b1, b2);
+        }
+    }
+
+    #[test]
+    fn test_sep_root_dir_encoding() {
+        let mut buf = Vec::new();
+        vfs("C:/x/y").encode(&mut buf);
+        assert_eq!(&buf, &[0, 67, 0, 58, 0, 92, 0, 120, 0, 92, 0, 121, 0])
+    }
+
+    #[cfg(test)]
+    fn vfs(str: &str) -> super::VfsPath {
+        use super::{AbsPathBuf, VfsPath};
+        use std::convert::TryFrom;
+        VfsPath::from(AbsPathBuf::try_from(str).unwrap())
+    }
+}
+
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 enum VfsPathRepr {
     PathBuf(AbsPathBuf),