rubydex 0.2.9 → 0.4.0

data/rust/rubydex/src/model/name.rs

@@ -2,7 +2,11 @@ use std::fmt::Display;
 
 use crate::{
     assert_mem_size,
-    model::ids::{DeclarationId, NameId, StringId},
+    model::{
+        id::id_from_parts,
+        identity_maps::IdentityHashMap,
+        ids::{DeclarationId, NameId, StringId},
+    },
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -90,31 +94,58 @@ pub struct Name {
     /// list of names to represent the nesting
     nesting: Option<NameId>,
     ref_count: u32,
+    /// The depth of the name, which combines the depths of the parent scope and nesting
+    depth: u16,
 }
+assert_mem_size!(Name, 40);
 
 impl PartialEq for Name {
     fn eq(&self, other: &Self) -> bool {
         self.str == other.str && self.parent_scope == other.parent_scope && self.nesting == other.nesting
     }
 }
-assert_mem_size!(Name, 40);
 
 impl Name {
     #[must_use]
-    pub fn new(str: StringId, parent_scope: ParentScope, nesting: Option<NameId>) -> Self {
+    pub fn new(
+        names: &IdentityHashMap<NameId, NameRef>,
+        str: StringId,
+        parent_scope: ParentScope,
+        nesting: Option<NameId>,
+    ) -> Self {
         Self {
             str,
             parent_scope,
             nesting,
             ref_count: 1,
+            depth: Self::name_depth(names, parent_scope, nesting),
         }
     }
 
+    #[must_use]
+    fn name_depth(names: &IdentityHashMap<NameId, NameRef>, parent_scope: ParentScope, nesting: Option<NameId>) -> u16 {
+        if parent_scope.is_top_level() {
+            return 1;
+        }
+
+        let parent_depth = parent_scope
+            .as_ref()
+            .map_or(0, |id| names.get(id).map_or(0, NameRef::depth));
+        let nesting_depth = nesting.map_or(0, |id| names.get(&id).map_or(0, NameRef::depth));
+
+        parent_depth.saturating_add(nesting_depth).saturating_add(1)
+    }
+
     #[must_use]
     pub fn str(&self) -> &StringId {
         &self.str
     }
 
+    #[must_use]
+    pub fn depth(&self) -> u16 {
+        self.depth
+    }
+
     #[must_use]
     pub fn parent_scope(&self) -> &ParentScope {
         &self.parent_scope
@@ -127,12 +158,19 @@ impl Name {
 
     #[must_use]
     pub fn id(&self) -> NameId {
-        NameId::from(&format!(
-            "{}{}{}",
-            self.str,
-            self.parent_scope,
-            self.nesting.map_or(String::from("None"), |id| id.to_string())
-        ))
+        // We need to include both the variant and the bytes of the parent scope when present
+        let (parent_tag, parent_id): (u8, u64) = match self.parent_scope {
+            ParentScope::None => (0, 0),
+            ParentScope::TopLevel => (1, 0),
+            ParentScope::Some(id) => (2, id.get()),
+            ParentScope::Attached(id) => (3, id.get()),
+        };
+        let (nesting_tag, nesting_id): (u8, u64) = match self.nesting {
+            None => (0, 0),
+            Some(id) => (1, id.get()),
+        };
+
+        id_from_parts!(NameId; self.str.get(), parent_tag, parent_id, nesting_tag, nesting_id)
     }
 }
 
@@ -217,6 +255,14 @@ impl NameRef {
         }
     }
 
+    #[must_use]
+    pub fn depth(&self) -> u16 {
+        match self {
+            NameRef::Unresolved(name) => name.depth(),
+            NameRef::Resolved(resolved_name) => resolved_name.name.depth(),
+        }
+    }
+
     /// # Panics
     ///
     /// Panics if we exceed the maximum size of the reference count
@@ -271,30 +317,53 @@ mod tests {
 
     #[test]
     fn same_parent_scope_and_nesting() {
-        let name_1 = Name::new(StringId::from("Foo"), ParentScope::None, None);
-        let name_2 = Name::new(StringId::from("Foo"), ParentScope::None, None);
+        let names = IdentityHashMap::default();
+
+        let name_1 = Name::new(&names, StringId::from("Foo"), ParentScope::None, None);
+        let name_2 = Name::new(&names, StringId::from("Foo"), ParentScope::None, None);
         assert_eq!(name_1.id(), name_2.id());
 
-        let name_3 = Name::new(StringId::from("Foo"), ParentScope::Some(name_1.id()), None);
-        let name_4 = Name::new(StringId::from("Foo"), ParentScope::Some(name_2.id()), None);
+        let name_3 = Name::new(&names, StringId::from("Foo"), ParentScope::Some(name_1.id()), None);
+        let name_4 = Name::new(&names, StringId::from("Foo"), ParentScope::Some(name_2.id()), None);
         assert_eq!(name_3.id(), name_4.id());
 
-        let name_5 = Name::new(StringId::from("Foo"), ParentScope::None, Some(name_1.id()));
-        let name_6 = Name::new(StringId::from("Foo"), ParentScope::None, Some(name_2.id()));
+        let name_5 = Name::new(&names, StringId::from("Foo"), ParentScope::None, Some(name_1.id()));
+        let name_6 = Name::new(&names, StringId::from("Foo"), ParentScope::None, Some(name_2.id()));
         assert_eq!(name_5.id(), name_6.id());
         assert_ne!(name_3.id(), name_5.id());
         assert_ne!(name_4.id(), name_6.id());
 
         let name_7 = Name::new(
+            &names,
             StringId::from("Foo"),
-            ParentScope::Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
-            Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
+            ParentScope::Some(Name::new(&names, StringId::from("Foo"), ParentScope::None, None).id()),
+            Some(Name::new(&names, StringId::from("Foo"), ParentScope::None, None).id()),
         );
         let name_8 = Name::new(
+            &names,
             StringId::from("Foo"),
-            ParentScope::Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
-            Some(Name::new(StringId::from("Foo"), ParentScope::None, None).id()),
+            ParentScope::Some(Name::new(&names, StringId::from("Foo"), ParentScope::None, None).id()),
+            Some(Name::new(&names, StringId::from("Foo"), ParentScope::None, None).id()),
         );
         assert_eq!(name_7.id(), name_8.id());
     }
+
+    #[test]
+    fn parent_scope_variants_are_distinct() {
+        let names = IdentityHashMap::default();
+        let inner = Name::new(&names, StringId::from("Foo"), ParentScope::None, None).id();
+
+        let ids = [
+            Name::new(&names, StringId::from("Foo"), ParentScope::None, None).id(),
+            Name::new(&names, StringId::from("Foo"), ParentScope::TopLevel, None).id(),
+            Name::new(&names, StringId::from("Foo"), ParentScope::Some(inner), None).id(),
+            Name::new(&names, StringId::from("Foo"), ParentScope::Attached(inner), None).id(),
+        ];
+
+        for (i, a) in ids.iter().enumerate() {
+            for b in &ids[i + 1..] {
+                assert_ne!(a, b);
+            }
+        }
+    }
 }

data/rust/rubydex/src/model/references.rs

@@ -1,6 +1,9 @@
 use crate::{
     assert_mem_size,
-    model::ids::{ConstantReferenceId, MethodReferenceId, NameId, StringId, UriId},
+    model::{
+        id::id_from_parts,
+        ids::{ConstantReferenceId, MethodReferenceId, NameId, StringId, UriId},
+    },
     offset::Offset,
 };
 
@@ -43,13 +46,13 @@ impl ConstantReference {
 
     #[must_use]
     pub fn id(&self) -> ConstantReferenceId {
-        ConstantReferenceId::from(&format!(
-            "{}:{}:{}-{}",
-            self.name_id,
-            self.uri_id,
+        id_from_parts!(
+            ConstantReferenceId;
+            self.name_id.get(),
+            self.uri_id.get(),
             self.offset.start(),
-            self.offset.end()
-        ))
+            self.offset.end(),
+        )
     }
 }
 
@@ -100,12 +103,12 @@ impl MethodRef {
 
     #[must_use]
     pub fn id(&self) -> MethodReferenceId {
-        MethodReferenceId::from(&format!(
-            "{}:{}:{}-{}",
-            self.str,
-            self.uri_id,
+        id_from_parts!(
+            MethodReferenceId;
+            self.str.get(),
+            self.uri_id.get(),
             self.offset.start(),
-            self.offset.end()
-        ))
+            self.offset.end(),
+        )
     }
 }

data/rust/rubydex/src/operation/ruby_builder.rs

@@ -154,7 +154,8 @@ impl<'a> RubyOperationBuilder<'a> {
         string_id
     }
 
-    fn add_name(&mut self, name: Name) -> NameId {
+    fn add_name(&mut self, str: StringId, parent_scope: ParentScope, nesting: Option<NameId>) -> NameId {
+        let name = Name::new(&self.names, str, parent_scope, nesting);
         let name_id = name.id();
 
         match self.names.entry(name_id) {
@@ -360,11 +361,7 @@ impl<'a> RubyOperationBuilder<'a> {
         let offset = Offset::from_prism_location(&location);
         let name = Self::location_to_string(&location);
         let string_id = self.intern_string(name);
-        let name_id = self.add_name(Name::new(
-            string_id,
-            parent_scope_id,
-            self.current_lexical_scope_name_id(),
-        ));
+        let name_id = self.add_name(string_id, parent_scope_id, self.current_lexical_scope_name_id());
 
         if push_final_reference {
             self.operations
@@ -443,7 +440,7 @@ impl<'a> RubyOperationBuilder<'a> {
                 }
                 None => {
                     let str_id = self.intern_string("Object".into());
-                    Some(self.add_name(Name::new(str_id, ParentScope::None, None)))
+                    Some(self.add_name(str_id, ParentScope::None, None))
                 }
             },
             Some(ruby_prism::Node::CallNode { .. }) => {
@@ -477,7 +474,7 @@ impl<'a> RubyOperationBuilder<'a> {
         };
 
         let string_id = self.intern_string(singleton_class_name);
-        let new_name_id = self.add_name(Name::new(string_id, ParentScope::Attached(name_id), None));
+        let new_name_id = self.add_name(string_id, ParentScope::Attached(name_id), None);
 
         let location = receiver.map_or(fallback_location, ruby_prism::Node::location);
         let offset = Offset::from_prism_location(&location);
@@ -611,20 +608,8 @@ impl<'a> RubyOperationBuilder<'a> {
     {
         if let Some(arguments) = node.arguments() {
             for argument in &arguments.arguments() {
-                match argument {
-                    ruby_prism::Node::SymbolNode { .. } => {
-                        let symbol = argument.as_symbol_node().unwrap();
-                        if let Some(value_loc) = symbol.value_loc() {
-                            let name = Self::location_to_string(&value_loc);
-                            f(name, value_loc);
-                        }
-                    }
-                    ruby_prism::Node::StringNode { .. } => {
-                        let string = argument.as_string_node().unwrap();
-                        let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                        f(name, argument.location());
-                    }
-                    _ => {}
+                if let Some((name, location)) = Self::extract_literal_name(&argument) {
+                    f(name, location);
                 }
             }
         }
@@ -701,10 +686,7 @@ impl<'a> RubyOperationBuilder<'a> {
             )
         } else {
             let string_id = self.intern_string(format!("{}:{}<anonymous>", self.uri_id, offset.start()));
-            (
-                Some(self.add_name(Name::new(string_id, ParentScope::None, None))),
-                offset.clone(),
-            )
+            (Some(self.add_name(string_id, ParentScope::None, None)), offset.clone())
         };
 
         if let Some(name_id) = name_id {
@@ -766,10 +748,7 @@ impl<'a> RubyOperationBuilder<'a> {
             )
         } else {
             let string_id = self.intern_string(format!("{}:{}<anonymous>", self.uri_id, offset.start()));
-            (
-                Some(self.add_name(Name::new(string_id, ParentScope::None, None))),
-                offset.clone(),
-            )
+            (Some(self.add_name(string_id, ParentScope::None, None)), offset.clone())
         };
 
         if let Some(name_id) = name_id {
@@ -861,7 +840,7 @@ impl<'a> RubyOperationBuilder<'a> {
                     }
 
                     Some((
-                        self.current_lexical_scope_name_id().unwrap(),
+                        self.current_owner_name_id().unwrap(),
                         Offset::from_prism_location(&arg.location()),
                     ))
                 } else if let Some(name_id) = self.index_constant_reference(&arg, false) {
@@ -899,28 +878,29 @@ impl<'a> RubyOperationBuilder<'a> {
 
     fn handle_constant_visibility(&mut self, node: &ruby_prism::CallNode, visibility: Visibility) {
         let receiver = node.receiver();
+        let call_name = String::from_utf8_lossy(node.name().as_slice());
 
-        let receiver_name_id = match receiver {
+        let receiver_name_id = match &receiver {
             Some(ruby_prism::Node::ConstantPathNode { .. } | ruby_prism::Node::ConstantReadNode { .. }) => {
-                self.index_constant_reference(&receiver.unwrap(), true)
+                self.index_constant_reference(receiver.as_ref().unwrap(), true)
             }
             Some(ruby_prism::Node::SelfNode { .. }) | None => match self.nesting_stack.last() {
                 Some(Nesting::Method { .. }) => return,
                 None => {
                     self.add_diagnostic(
-                        Rule::InvalidPrivateConstant,
+                        Rule::InvalidConstantVisibility,
                         Offset::from_prism_location(&node.location()),
-                        "Private constant called at top level".to_string(),
+                        format!("`{call_name}` called at top level"),
                     );
                     return;
                 }
                 _ => None,
             },
-            _ => {
+            Some(other) => {
                 self.add_diagnostic(
-                    Rule::InvalidPrivateConstant,
-                    Offset::from_prism_location(&node.location()),
-                    "Dynamic receiver for private constant".to_string(),
+                    Rule::InvalidConstantVisibility,
+                    Offset::from_prism_location(&other.location()),
+                    format!("Dynamic receiver for `{call_name}`"),
                 );
                 return;
             }
@@ -931,28 +911,13 @@ impl<'a> RubyOperationBuilder<'a> {
         };
 
         for argument in &arguments.arguments() {
-            let (name, location) = match argument {
-                ruby_prism::Node::SymbolNode { .. } => {
-                    let symbol = argument.as_symbol_node().unwrap();
-                    if let Some(value_loc) = symbol.value_loc() {
-                        (Self::location_to_string(&value_loc), value_loc)
-                    } else {
-                        continue;
-                    }
-                }
-                ruby_prism::Node::StringNode { .. } => {
-                    let string = argument.as_string_node().unwrap();
-                    let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                    (name, argument.location())
-                }
-                _ => {
-                    self.add_diagnostic(
-                        Rule::InvalidPrivateConstant,
-                        Offset::from_prism_location(&argument.location()),
-                        "Private constant called with non-symbol argument".to_string(),
-                    );
-                    continue;
-                }
+            let Some((name, location)) = Self::extract_literal_name(&argument) else {
+                self.add_diagnostic(
+                    Rule::InvalidConstantVisibility,
+                    Offset::from_prism_location(&argument.location()),
+                    format!("`{call_name}` called with a non-literal argument"),
+                );
+                continue;
             };
 
             let str_id = self.intern_string(name);
@@ -1067,6 +1032,22 @@ impl<'a> RubyOperationBuilder<'a> {
         Some(())
     }
 
+    fn extract_literal_name<'b>(arg: &ruby_prism::Node<'b>) -> Option<(String, ruby_prism::Location<'b>)> {
+        match arg {
+            ruby_prism::Node::SymbolNode { .. } => {
+                let symbol = arg.as_symbol_node().unwrap();
+                let value_loc = symbol.value_loc()?;
+                Some((Self::location_to_string(&value_loc), value_loc))
+            }
+            ruby_prism::Node::StringNode { .. } => {
+                let string = arg.as_string_node().unwrap();
+                let name = String::from_utf8_lossy(string.unescaped()).to_string();
+                Some((name, arg.location()))
+            }
+            _ => None,
+        }
+    }
+
     fn is_attr_call(arg: &ruby_prism::Node) -> bool {
         arg.as_call_node().is_some_and(|call| {
             let receiver = call.receiver();
@@ -1116,6 +1097,18 @@ impl<'a> RubyOperationBuilder<'a> {
                 ruby_prism::Node::SymbolNode { .. } | ruby_prism::Node::StringNode { .. }
             ) {
                 self.create_method_visibility_operation(&arg, visibility, DefinitionFlags::empty());
+                if visibility == Visibility::ModuleFunction {
+                    // `module_function` also creates a public singleton method, so we emit a
+                    // second def for the singleton side. The two defs stay separate (rather than
+                    // shared) so reverse-lookup invalidation can detach `Foo#bar` and
+                    // `Foo::<Foo>#bar` independently. The `SINGLETON_METHOD_VISIBILITY` flag
+                    // routes this one to the singleton class.
+                    self.create_method_visibility_operation(
+                        &arg,
+                        visibility,
+                        DefinitionFlags::SINGLETON_METHOD_VISIBILITY,
+                    );
+                }
             } else {
                 let arg_offset = Offset::from_prism_location(&arg.location());
                 let message = if Self::is_attr_call(&arg) {
@@ -1135,21 +1128,8 @@ impl<'a> RubyOperationBuilder<'a> {
         visibility: Visibility,
         flags: DefinitionFlags,
     ) {
-        let (name, location) = match arg {
-            ruby_prism::Node::SymbolNode { .. } => {
-                let symbol = arg.as_symbol_node().unwrap();
-                if let Some(value_loc) = symbol.value_loc() {
-                    (Self::location_to_string(&value_loc), value_loc)
-                } else {
-                    return;
-                }
-            }
-            ruby_prism::Node::StringNode { .. } => {
-                let string = arg.as_string_node().unwrap();
-                let name = String::from_utf8_lossy(string.unescaped()).to_string();
-                (name, arg.location())
-            }
-            _ => return,
+        let Some((name, location)) = Self::extract_literal_name(arg) else {
+            return;
         };
 
         let str_id = self.intern_string(format!("{name}()"));
@@ -1372,6 +1352,14 @@ impl<'a> RubyOperationBuilder<'a> {
                 flags,
             }));
     }
+
+    fn visit_method_body(&mut self, receiver: Option<NestingReceiver>, body: Option<&ruby_prism::Node<'_>>) {
+        self.nesting_stack.push(Nesting::Method { receiver });
+        if let Some(body) = body {
+            self.visit(body);
+        }
+        self.nesting_stack.pop();
+    }
 }
 
 struct CommentGroup {
@@ -1494,7 +1482,7 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
 
         let string_id = self.intern_string(singleton_class_name);
         let nesting = self.current_lexical_scope_name_id();
-        let name_id = self.add_name(Name::new(string_id, ParentScope::Attached(attached_target), nesting));
+        let name_id = self.add_name(string_id, ParentScope::Attached(attached_target), nesting);
         self.operations
             .push(Operation::EnterSingletonClass(op::EnterSingletonClass {
                 name_id,
@@ -1578,8 +1566,10 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
         };
 
         if receiver.is_none() && visibility == Visibility::ModuleFunction {
-            // module_function: emit two EnterMethod/ExitScope pairs (singleton + instance),
-            // each visiting the body so ivars are associated with both methods.
+            // Each EnterMethod creates a method definition, so emit one for the public singleton
+            // method and one for the private instance method. Emit body definitions and references
+            // only under the instance method because emitting them in both scopes would duplicate
+            // their source-based IDs.
             let singleton_receiver = Some(Target::ExplicitSelf);
             let body = node.body();
 
@@ -1593,13 +1583,6 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
                 signatures: Signatures::Simple(parameters.clone().into_boxed_slice()),
                 receiver: singleton_receiver,
             }));
-            self.nesting_stack.push(Nesting::Method {
-                receiver: method_nesting_receiver,
-            });
-            if let Some(ref body) = body {
-                self.visit(body);
-            }
-            self.nesting_stack.pop();
             self.operations.push(Operation::ExitScope);
 
             self.operations.push(Operation::EnterMethod(op::EnterMethod {
@@ -1612,13 +1595,7 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
                 signatures: Signatures::Simple(parameters.into_boxed_slice()),
                 receiver,
             }));
-            self.nesting_stack.push(Nesting::Method {
-                receiver: method_nesting_receiver,
-            });
-            if let Some(ref body) = body {
-                self.visit(body);
-            }
-            self.nesting_stack.pop();
+            self.visit_method_body(method_nesting_receiver, body.as_ref());
             self.operations.push(Operation::ExitScope);
         } else {
             // Singleton methods at top level have receiver=None (no class to point self to).
@@ -1647,13 +1624,8 @@ impl Visit<'_> for RubyOperationBuilder<'_> {
                 signatures: Signatures::Simple(parameters.into_boxed_slice()),
                 receiver,
             }));
-            self.nesting_stack.push(Nesting::Method {
-                receiver: method_nesting_receiver,
-            });
-            if let Some(body) = node.body() {
-                self.visit(&body);
-            }
-            self.nesting_stack.pop();
+            let body = node.body();
+            self.visit_method_body(method_nesting_receiver, body.as_ref());
             self.operations.push(Operation::ExitScope);
 
             if let Some(prev) = previous_visibility {
@@ -2475,14 +2447,15 @@ mod tests {
     }
 
     #[test]
-    fn build_module_function_with_ivar() {
-        assert_operations(
+    fn build_module_function_with_body() {
+        assert_operations_with_references(
             "
             module Foo
               module_function
 
               def bar
-                @x = 1
+                @x = CONST
+                baz(1)
               end
             end
             ",
@@ -2490,10 +2463,11 @@ mod tests {
             EnterModule(Foo)
               SetDefaultVisibility(module_function)
               EnterMethod(self.bar())
-                DefineInstanceVariable(@x)
               ExitScope
               EnterMethod(bar())
                 DefineInstanceVariable(@x)
+                ReferenceConstant(CONST)
+                ReferenceMethod(baz)
               ExitScope
             ExitScope
             ",

data/rust/rubydex/src/path_helpers.rs

@@ -0,0 +1,77 @@
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+
+/// Resolves `path` into the spelling rubydex knows a path by: absolute, with symlinks expanded and, on Windows, spelled
+/// plainly instead of verbatim.
+///
+/// # Errors
+///
+/// Returns an error if the path cannot be canonicalized, as for one that does not exist.
+pub(crate) fn resolved(path: &Path) -> io::Result<PathBuf> {
+    Ok(simplified(fs::canonicalize(path)?))
+}
+
+/// Only Windows spells a path verbatim, so everywhere else there is nothing to simplify.
+#[cfg(not(windows))]
+pub(crate) fn simplified(path: PathBuf) -> PathBuf {
+    path
+}
+
+/// Since we canonicalize paths, we must simplify Windows paths in order to use them correctly with glob patterns, like
+/// stripping the `\\?\` prefix.
+#[cfg(windows)]
+pub(crate) fn simplified(path: PathBuf) -> PathBuf {
+    use std::path::Component;
+    use std::path::Prefix;
+
+    let mut components = path.components();
+    let Some(Component::Prefix(prefix)) = components.next() else {
+        return path;
+    };
+
+    // Only a verbatim drive or share has a plain equivalent: `\\?\D:\dir` is `D:\dir`, and `\\?\UNC\server\share` is
+    // the share `\\server\share`. Any other verbatim prefix names a device, such as `\\?\pipe\name`, which has none.
+    let root = match prefix.kind() {
+        Prefix::VerbatimDisk(drive) => format!("{}:\\", char::from(drive)),
+        Prefix::VerbatimUNC(server, share) => {
+            format!(r"\\{}\{}\", server.to_string_lossy(), share.to_string_lossy())
+        }
+        _ => return path,
+    };
+
+    // The root already carries the separator that follows it, so the one spelled as its own component is dropped rather
+    // than pushed, which would otherwise reset the path back to the root it was just given.
+    let mut simplified = PathBuf::from(root);
+    simplified.extend(components.filter(|component| !matches!(component, Component::RootDir)));
+    simplified
+}
+
+#[cfg(all(test, windows))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn simplified_rewrites_a_verbatim_path_into_its_plain_spelling() {
+        assert_eq!(
+            simplified(PathBuf::from(r"\\?\D:\a\project")),
+            PathBuf::from(r"D:\a\project")
+        );
+    }
+
+    #[test]
+    fn simplified_keeps_a_verbatim_share_rooted_on_that_share() {
+        assert_eq!(
+            simplified(PathBuf::from(r"\\?\UNC\server\share\project")),
+            PathBuf::from(r"\\server\share\project")
+        );
+    }
+
+    #[test]
+    fn simplified_leaves_a_path_with_no_plain_equivalent_alone() {
+        // A device path is not addressable without the prefix, and a plain path has nothing to simplify.
+        for path in [r"\\?\pipe\rubydex", r"D:\a\project", r"\\server\share\project"] {
+            assert_eq!(simplified(PathBuf::from(path)), PathBuf::from(path));
+        }
+    }
+}