VFS: implement a Windows-specific Path subclass

The new subclass WindowsFileSystem.WindowsPath is
aware of Windows drives.

This change:
- introduces a new factory for Path objects so
  FileSystems can return a custom implementation
  that instantiates filesystem-specific Paths
- implements the WindowsPath subclass of Path that
  is aware of Windows drives
- introduces the bazel.windows_unix_root JVM
  argument that defines the MSYS root, which
  defines the absolute Windows path that is the
  root of all Unix paths that Bazel creates (e.g.
  "/usr/lib" -> "C:/tools/msys64/usr/lib") except
  if the path is of the form "/c/foo" which is
  treated as "C:/foo"
- removes all Windows-specific logic from Path

PathFragment is still aware of drive letters and
it has to remain so because it is unaware of file
systems.

WindowsPath restricts the allowed path strings to
absolute Unix paths where the first segment, if
any, is a volume specifier. From now on if Bazel
attempts to create a WindowsPath from an absolute
Unix path, Bazel will make it relative to
WindowsPath.UNIX_ROOT, unless the first component
is a single-letter name (e.g. "/c/foo" which is
"C:/foo").

Subclassing Path is necessary because a Unix-style
absolute path doesn't sufficiently define a full
Windows path, as it may be relative to any drive.

Fixes https://github.com/bazelbuild/bazel/issues/1463

--
MOS_MIGRATED_REVID=136350304

1 files changed, 16 insertions, 3 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/vfs/RootedPath.java b/src/main/java/com/google/devtools/build/lib/vfs/RootedPath.java
index a9825959a8..23e7ad79ed 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/RootedPath.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/RootedPath.java
@@ -14,7 +14,6 @@
 package com.google.devtools.build.lib.vfs;
 
 import com.google.devtools.build.lib.util.Preconditions;
-
 import java.io.Serializable;
 import java.util.Objects;
 
@@ -49,7 +48,21 @@ public class RootedPath implements Serializable {
    * Returns a rooted path representing {@code relativePath} relative to {@code root}.
    */
   public static RootedPath toRootedPath(Path root, PathFragment relativePath) {
-    return new RootedPath(root, relativePath);
+    if (relativePath.isAbsolute()) {
+      if (root.isRootDirectory()) {
+        return new RootedPath(
+            root.getRelative(relativePath.windowsVolume()), relativePath.toRelative());
+      } else {
+        Preconditions.checkArgument(
+            relativePath.startsWith(root.asFragment()),
+            "relativePath '%s' is absolute, but it's not under root '%s'",
+            relativePath,
+            root);
+        return new RootedPath(root, relativePath.relativeTo(root.asFragment()));
+      }
+    } else {
+      return new RootedPath(root, relativePath);
+    }
   }
 
   /**
@@ -57,7 +70,7 @@ public class RootedPath implements Serializable {
    */
   public static RootedPath toRootedPath(Path root, Path path) {
     Preconditions.checkState(path.startsWith(root), "path: %s root: %s", path, root);
-    return new RootedPath(root, path.relativeTo(root));
+    return toRootedPath(root, path.asFragment());
   }
 
   /**