fix: windows drive letters remap to unc paths

src/rez/config.py

@@ -415,6 +415,7 @@ def _parse_env_var(self, value):
     "suite_alias_prefix_char":                      Char,
     "cache_packages_path":                          OptionalStr,
     "package_definition_python_path":               OptionalStr,
+    "resolve_links_on_windows":                     Bool,
     "tmpdir":                                       OptionalStr,
     "context_tmpdir":                               OptionalStr,
     "default_shell":                                OptionalStr,

src/rez/resolved_context.py

@@ -17,7 +17,7 @@
 from rez.utils.formatting import columnise, PackageRequest, ENV_VAR_REGEX, \
     header_comment, minor_header_comment
 from rez.utils.data_utils import deep_del
-from rez.utils.filesystem import TempDirs, is_subdirectory, canonical_path
+from rez.utils.filesystem import TempDirs, is_subdirectory, canonical_path, real_path
 from rez.utils.memcached import pool_memcached_connections
 from rez.utils.logging_ import print_debug, print_error, print_warning
 from rez.utils.which import which
@@ -1896,8 +1896,8 @@ def _adjust_variant_for_bundling(cls, handle: dict, out: bool) -> None:
 
             if is_subdirectory(repo_path, bundle_path):
                 vars_["location"] = os.path.relpath(
-                    os.path.realpath(repo_path),
-                    os.path.realpath(bundle_path)
+                    real_path(repo_path),
+                    real_path(bundle_path)
                 )
 
         # serializing in, make repo absolute

src/rez/rezconfig.py

@@ -125,6 +125,26 @@
 # For further information, see :ref:`package-definition-sharing-code`.
 package_definition_python_path = None
 
+# On Windows, whether to resolve symbolic links and junction points when
+# normalising filesystem paths (primarily inside ``canonical_path``).
+#
+# When ``False`` (default), rez uses ``os.path.abspath``, which normalises
+# separators and ``.``/``..`` components without following symlinks and without
+# expanding mapped drive letters to their UNC equivalents. This preserves the
+# path style supplied by the caller (drive-letter input, drive-letter output,
+# UNC input, UNC output), effectively defaulting to pre-Python-3.8 behaviour of
+# ``os.path.realpath`` on Windows.
+#
+# When ``True``, rez performs a component-by-component walk using
+# ``os.path.islink`` / ``os.readlink``. This resolves actual symlinks and
+# junction points without the drive-letter-to-UNC side-effect that
+# ``os.path.realpath`` introduced in Python 3.8. Useful when package
+# repositories are accessed through directory symlinks or junctions.
+#
+# This setting is a no-op on non-Windows platforms, which always resolve
+# symlinks via ``os.path.realpath``.
+resolve_links_on_windows = False
+
 
 ###############################################################################
 # Extensions

src/rez/serialise.py

@@ -20,7 +20,7 @@
 from rez.package_resources import package_rex_keys
 from rez.utils.scope import ScopeContext
 from rez.utils.sourcecode import SourceCode, early, late, include
-from rez.utils.filesystem import TempDirs
+from rez.utils.filesystem import TempDirs, real_path, resolve_path
 from rez.utils.data_utils import ModifyList
 from rez.exceptions import ResourceError, InvalidPackageError
 from rez.utils.memcached import memcached
@@ -66,7 +66,13 @@ def open_file_for_write(filepath, mode=None):
     yield stream
     content = stream.getvalue()
 
-    filepath = os.path.realpath(filepath)
+    # Use real_path for the cache key so it matches load_from_file's key.
+    # Separately resolve symlinks for the write target so atomic_write
+    # replaces the symlink's target, not the symlink itself. Use
+    # resolve_path (not os.path.realpath) to avoid expanding drive letters
+    # to UNC paths on Windows.
+    cache_key = real_path(filepath)
+    filepath = resolve_path(cache_key)
     tmpdir = tmpdir_manager.mkdtemp()
     cache_filepath = os.path.join(tmpdir, os.path.basename(filepath))
 
@@ -103,7 +109,7 @@ def open_file_for_write(filepath, mode=None):
     with open(cache_filepath, 'w', encoding="utf-8") as f:
         f.write(content)
 
-    file_cache[filepath] = cache_filepath
+    file_cache[cache_key] = cache_filepath
 
 
 def load_from_file(filepath: str, format_=FileFormat.py, update_data_callback=None,
@@ -123,7 +129,7 @@ def load_from_file(filepath: str, format_=FileFormat.py, update_data_callback=No
     Returns:
         dict:
     """
-    filepath = os.path.realpath(filepath)
+    filepath = real_path(filepath)
     cache_filepath = file_cache.get(filepath)
 
     if cache_filepath:

src/rez/suite.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 from rez.utils.execution import create_forwarding_script
+from rez.utils.filesystem import real_path, resolve_path
 from rez.exceptions import SuiteError, ResolvedContextError
 from rez.resolved_context import ResolvedContext
 from rez.utils.data_utils import cached_property
@@ -458,14 +459,31 @@ def save(self, path, verbose: bool = False):
                 at `path`, then it will be overwritten. Otherwise, if `path`
                 exists, an error is raised.
         """
-        path = os.path.realpath(path)
+        path = real_path(path)
         if os.path.exists(path):
-            if self.load_path and self.load_path == path:
+            is_same_suite = False
+            if self.load_path:
+                # Use samefile() instead of raw string comparison so that
+                # symlinks, junctions, and case-only differences on Windows
+                # are handled correctly.
+                try:
+                    is_same_suite = os.path.samefile(self.load_path, path)
+                except OSError:
+                    is_same_suite = (self.load_path == path)
+
+            if is_same_suite:
                 if verbose:
                     print("saving over previous suite...")
                 for context_name in self.context_names:
                     self.context(context_name)  # load before dir deleted
-                safe_rmtree(path)
+                # Resolve symlinks/junctions before rmtree so we remove the
+                # directory contents rather than severing the link itself.
+                # On non-Windows this always resolves. On Windows, resolution
+                # only happens when resolve_links_on_windows is enabled;
+                # otherwise, rmtree operates on the path as-is (which may
+                # sever a symlink -- the user can enable the flag if needed).
+                rmtree_target = resolve_path(path)
+                safe_rmtree(rmtree_target)
             else:
                 raise SuiteError("Cannot save, path exists: %r" % path)
 
@@ -528,7 +546,7 @@ def load(cls, path: str) -> Suite:
             raise SuiteError("Failed loading suite: %s" % str(e))
 
         s = cls.from_dict(data)
-        s.load_path = os.path.realpath(path)
+        s.load_path = real_path(path)
         return s
 
     @classmethod

src/rez/system.py

@@ -13,6 +13,7 @@
 from rez.utils.platform_ import platform_
 from rez.exceptions import RezSystemError
 from rez.utils.data_utils import cached_property
+from rez.utils.filesystem import real_path
 
 
 class System(object):
@@ -242,7 +243,7 @@ def rez_bin_path(self):
 
         validation_file = os.path.join(binpath, ".rez_production_install")
         if os.path.exists(validation_file):
-            return os.path.realpath(binpath)
+            return real_path(binpath)
 
         return None