Windows device path fixes (nushell#16775)

## Release notes summary - What our users need to know
* On Windows, UNC and device paths no longer get a trailing `\` appended
when being cast to `path`
* On Windows, open, save and source now work with device paths like
`\\.\NUL` or `\\.\CON`, as well as reserved device names like `NUL` and
`CON`. Using full device paths is recommended.

## Tasks after submitting

Author: nome

crates/nu-command/src/filesystem/open.rs

@@ -1,5 +1,6 @@
 #[allow(deprecated)]
 use nu_engine::{command_prelude::*, current_dir, eval_call};
+use nu_path::is_windows_device_path;
 use nu_protocol::{
     DataSource, NuGlob, PipelineMetadata, ast,
     debugger::{WithDebug, WithoutDebug},
@@ -104,8 +105,17 @@ impl Command for Open {
             let arg_span = path.span;
             // let path_no_whitespace = &path.item.trim_end_matches(|x| matches!(x, '\x09'..='\x0d'));
 
-            for path in
-                nu_engine::glob_from(&path, &cwd, call_span, None, engine_state.signals().clone())
+            let matches: Box<dyn Iterator<Item = Result<PathBuf, ShellError>> + Send> =
+                if is_windows_device_path(Path::new(&path.item.to_string())) {
+                    Box::new(vec![Ok(PathBuf::from(path.item.to_string()))].into_iter())
+                } else {
+                    nu_engine::glob_from(
+                        &path,
+                        &cwd,
+                        call_span,
+                        None,
+                        engine_state.signals().clone(),
+                    )
                     .map_err(|err| match err {
                         ShellError::Io(mut err) => {
                             err.kind = err.kind.not_found_as(NotFound::File);
@@ -115,7 +125,8 @@ impl Command for Open {
                         _ => err,
                     })?
                     .1
-            {
+                };
+            for path in matches {
                 let path = path?;
                 let path = Path::new(&path);
 

crates/nu-command/src/filesystem/save.rs

@@ -2,7 +2,7 @@ use crate::progress_bar;
 use nu_engine::get_eval_block;
 #[allow(deprecated)]
 use nu_engine::{command_prelude::*, current_dir};
-use nu_path::expand_path_with;
+use nu_path::{expand_path_with, is_windows_device_path};
 use nu_protocol::{
     ByteStreamSource, DataSource, OutDest, PipelineMetadata, Signals, ast,
     byte_stream::copy_with_signals, process::ChildPipe, shell_error::io::IoError,
@@ -432,7 +432,8 @@ fn open_file(
     span: Span,
     append: bool,
 ) -> Result<File, ShellError> {
-    let file: std::io::Result<File> = match (append, path.exists()) {
+    let file: std::io::Result<File> = match (append, path.exists() || is_windows_device_path(path))
+    {
         (true, true) => std::fs::OpenOptions::new().append(true).open(path),
         _ => {
             // This is a temporary solution until `std::fs::File::create` is fixed on Windows (rust-lang/rust#134893)

crates/nu-command/src/misc/source.rs

@@ -1,5 +1,5 @@
 use nu_engine::{command_prelude::*, get_eval_block_with_early_return};
-use nu_path::canonicalize_with;
+use nu_path::{canonicalize_with, is_windows_device_path};
 use nu_protocol::{BlockId, engine::CommandType, shell_error::io::IoError};
 
 /// Source a file for environment variables.
@@ -55,8 +55,13 @@ impl Command for Source {
         let cwd = engine_state.cwd_as_string(Some(stack))?;
         let pb = std::path::PathBuf::from(block_id_name);
         let parent = pb.parent().unwrap_or(std::path::Path::new(""));
-        let file_path = canonicalize_with(pb.as_path(), cwd)
-            .map_err(|err| IoError::new(err.not_found_as(NotFound::File), call.head, pb.clone()))?;
+        let file_path = if is_windows_device_path(pb.as_path()) {
+            pb.clone()
+        } else {
+            canonicalize_with(pb.as_path(), cwd).map_err(|err| {
+                IoError::new(err.not_found_as(NotFound::File), call.head, pb.clone())
+            })?
+        };
 
         // Note: We intentionally left out PROCESS_PATH since it's supposed to
         // to work like argv[0] in C, which is the name of the program being executed.

crates/nu-parser/src/parse_keywords.rs

@@ -10,6 +10,7 @@ use crate::{
 
 use log::trace;
 use nu_path::canonicalize_with;
+use nu_path::is_windows_device_path;
 use nu_protocol::{
     Alias, BlockId, CommandWideCompleter, CustomExample, DeclId, FromValue, Module, ModuleId,
     ParseError, PositionalArg, ResolvedImportPattern, ShellError, Signature, Span, Spanned,
@@ -3950,6 +3951,10 @@ pub fn find_in_dirs(
     cwd: &str,
     dirs_var_name: Option<&str>,
 ) -> Option<ParserPath> {
+    if is_windows_device_path(Path::new(&filename)) {
+        return Some(ParserPath::RealPath(filename.into()));
+    }
+
     pub fn find_in_dirs_with_id(
         filename: &str,
         working_set: &StateWorkingSet,

crates/nu-path/src/dots.rs

@@ -1,6 +1,6 @@
 #[cfg(windows)]
 use omnipath::WinPathExt;
-use std::path::{Component, Path, PathBuf};
+use std::path::{Component, Path, PathBuf, Prefix};
 
 /// Normalize the path, expanding occurrences of n-dots.
 ///
@@ -17,6 +17,7 @@ pub fn expand_ndots(path: impl AsRef<Path>) -> PathBuf {
     let path = path.as_ref();
 
     let mut result = PathBuf::with_capacity(path.as_os_str().len());
+    let mut has_special_prefix = false;
     for component in crate::components(path) {
         match component {
             Component::Normal(s) if is_ndots(s) => {
@@ -26,6 +27,21 @@ pub fn expand_ndots(path: impl AsRef<Path>) -> PathBuf {
                     result.push("..");
                 }
             }
+            Component::Prefix(prefix) => {
+                match prefix.kind() {
+                    Prefix::Disk(_) => {
+                        // Here, only the disk letter gets parsed as prefix,
+                        // so the following RootDir component makes sense
+                    }
+                    _ => {
+                        has_special_prefix = true;
+                    }
+                }
+                result.push(component)
+            }
+            Component::RootDir if has_special_prefix => {
+                // Ignore; this would add a trailing backslash to the path that wasn't in the input
+            }
             _ => result.push(component),
         }
     }
@@ -51,6 +67,7 @@ pub fn expand_dots(path: impl AsRef<Path>) -> PathBuf {
 
     let path = path.as_ref();
 
+    let mut has_special_prefix = false;
     let mut result = PathBuf::with_capacity(path.as_os_str().len());
     for component in crate::components(path) {
         match component {
@@ -60,6 +77,21 @@ pub fn expand_dots(path: impl AsRef<Path>) -> PathBuf {
             Component::CurDir if last_component_is_normal(&result) => {
                 // no-op
             }
+            Component::Prefix(prefix) => {
+                match prefix.kind() {
+                    Prefix::Disk(_) => {
+                        // Here, only the disk letter gets parsed as prefix,
+                        // so the following RootDir component makes sense
+                    }
+                    _ => {
+                        has_special_prefix = true;
+                    }
+                }
+                result.push(component)
+            }
+            Component::RootDir if has_special_prefix => {
+                // Ignore; this would add a trailing backslash to the path that wasn't in the input
+            }
             _ => {
                 let prev_component = result.components().next_back();
                 if prev_component == Some(Component::RootDir) && component == Component::ParentDir {
@@ -192,6 +224,54 @@ mod test_expand_ndots {
         let path = Path::new("./...");
         assert_path_eq!(expand_ndots_safe(path), "./...");
     }
+
+    #[test]
+    fn unc_share_no_dots() {
+        let path = Path::new(r"\\server\share");
+        assert_path_eq!(expand_ndots(path), path);
+    }
+
+    #[test]
+    fn unc_file_no_dots() {
+        let path = Path::new(r"\\server\share\dir\file.nu");
+        assert_path_eq!(expand_ndots(path), path);
+    }
+
+    #[test]
+    fn verbatim_no_dots() {
+        let path = Path::new(r"\\?\pictures\elephants");
+        assert_path_eq!(expand_ndots(path), path);
+    }
+
+    #[test]
+    fn verbatim_unc_share_no_dots() {
+        let path = Path::new(r"\\?\UNC\server\share");
+        assert_path_eq!(expand_ndots(path), path);
+    }
+
+    #[test]
+    fn verbatim_unc_file_no_dots() {
+        let path = Path::new(r"\\?\UNC\server\share\dir\file.nu");
+        assert_path_eq!(expand_ndots(path), path);
+    }
+
+    #[test]
+    fn verbatim_disk_no_dots() {
+        let path = Path::new(r"\\?\c:\");
+        assert_path_eq!(expand_ndots(path), path);
+    }
+
+    #[test]
+    fn device_path_no_dots() {
+        let path = Path::new(r"\\.\CON");
+        assert_path_eq!(expand_ndots(path), path);
+    }
+
+    #[test]
+    fn disk_no_dots() {
+        let path = Path::new(r"c:\Users\Ellie\nu_scripts");
+        assert_path_eq!(expand_ndots(path), path);
+    }
 }
 
 #[cfg(test)]
@@ -247,4 +327,60 @@ mod test_expand_dots {
         let expected = if cfg!(windows) { r"\baz" } else { "/baz" };
         assert_path_eq!(expand_dots(path), expected);
     }
+
+    #[test]
+    fn unc_share_no_dots() {
+        let path = Path::new(r"\\server\share");
+        assert_path_eq!(expand_dots(path), path);
+    }
+
+    #[test]
+    fn unc_file_no_dots() {
+        let path = Path::new(r"\\server\share\dir\file.nu");
+        assert_path_eq!(expand_dots(path), path);
+    }
+
+    #[test]
+    #[ignore = "bug in upstream library"]
+    fn verbatim_no_dots() {
+        // omnipath::windows::sys::Path::to_winuser_path seems to turn this verbatim path into a device path
+        let path = Path::new(r"\\?\pictures\elephants");
+        assert_path_eq!(expand_dots(path), path);
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn verbatim_unc_share_no_dots() {
+        let path = Path::new(r"\\?\UNC\server\share");
+        let expected = Path::new(r"\\server\share");
+        assert_path_eq!(expand_dots(path), expected);
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn verbatim_unc_file_no_dots() {
+        let path = Path::new(r"\\?\UNC\server\share\dir\file.nu");
+        let expected = Path::new(r"\\server\share\dir\file.nu");
+        assert_path_eq!(expand_dots(path), expected);
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn verbatim_disk_no_dots() {
+        let path = Path::new(r"\\?\C:\");
+        let expected = Path::new(r"C:\");
+        assert_path_eq!(expand_dots(path), expected);
+    }
+
+    #[test]
+    fn device_path_no_dots() {
+        let path = Path::new(r"\\.\CON");
+        assert_path_eq!(expand_dots(path), path);
+    }
+
+    #[test]
+    fn disk_no_dots() {
+        let path = Path::new(r"c:\Users\Ellie\nu_scripts");
+        assert_path_eq!(expand_dots(path), path);
+    }
 }

crates/nu-path/src/helpers.rs

@@ -1,4 +1,6 @@
-use std::path::PathBuf;
+#[cfg(windows)]
+use std::path::{Component, Prefix};
+use std::path::{Path, PathBuf};
 
 use crate::AbsolutePathBuf;
 
@@ -34,3 +36,102 @@ fn configurable_dir_path(
         .or_else(|| dir().and_then(|path| AbsolutePathBuf::try_from(path).ok()))
         .map(|path| path.canonicalize().map(Into::into).unwrap_or(path))
 }
+
+// List of special paths that can be written to and/or read from, even though they
+// don't appear as directory entries.
+// See https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
+// In rare circumstances, reserved paths _can_ exist as regular files in a
+// directory which shadow their special counterpart, so the safe way of referring
+// to these paths is by prefixing them with '\\.\' (this instructs the Windows APIs
+// to access the Win32 device namespace instead of the Win32 file namespace)
+// https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
+#[cfg(windows)]
+pub fn is_windows_device_path(path: &Path) -> bool {
+    match path.components().next() {
+        Some(Component::Prefix(prefix)) if matches!(prefix.kind(), Prefix::DeviceNS(_)) => {
+            return true;
+        }
+        _ => {}
+    }
+    let special_paths: [&Path; 28] = [
+        Path::new("CON"),
+        Path::new("PRN"),
+        Path::new("AUX"),
+        Path::new("NUL"),
+        Path::new("COM1"),
+        Path::new("COM2"),
+        Path::new("COM3"),
+        Path::new("COM4"),
+        Path::new("COM5"),
+        Path::new("COM6"),
+        Path::new("COM7"),
+        Path::new("COM8"),
+        Path::new("COM9"),
+        Path::new("COM¹"),
+        Path::new("COM²"),
+        Path::new("COM³"),
+        Path::new("LPT1"),
+        Path::new("LPT2"),
+        Path::new("LPT3"),
+        Path::new("LPT4"),
+        Path::new("LPT5"),
+        Path::new("LPT6"),
+        Path::new("LPT7"),
+        Path::new("LPT8"),
+        Path::new("LPT9"),
+        Path::new("LPT¹"),
+        Path::new("LPT²"),
+        Path::new("LPT³"),
+    ];
+    if special_paths.contains(&path) {
+        return true;
+    }
+    false
+}
+
+#[cfg(not(windows))]
+pub fn is_windows_device_path(_path: &Path) -> bool {
+    false
+}
+
+#[cfg(test)]
+mod test_is_windows_device_path {
+    use crate::is_windows_device_path;
+    use std::path::Path;
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn device_namespace() {
+        assert!(is_windows_device_path(Path::new(r"\\.\CON")))
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn reserved_device_name() {
+        assert!(is_windows_device_path(Path::new(r"NUL")))
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn normal_path() {
+        assert!(!is_windows_device_path(Path::new(r"dir\file")))
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn absolute_path() {
+        assert!(!is_windows_device_path(Path::new(r"\dir\file")))
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn unc_path() {
+        assert!(!is_windows_device_path(Path::new(r"\\server\share")))
+    }
+
+    #[cfg_attr(not(windows), ignore = "only for Windows")]
+    #[test]
+    fn verbatim_path() {
+        assert!(!is_windows_device_path(Path::new(r"\\?\dir\file")))
+    }
+}