diff --git a/src/main/java/com/google/devtools/build/lib/actions/Actions.java b/src/main/java/com/google/devtools/build/lib/actions/Actions.java
index 9143826..9b49d5c 100644
--- a/src/main/java/com/google/devtools/build/lib/actions/Actions.java
+++ b/src/main/java/com/google/devtools/build/lib/actions/Actions.java
@@ -23,7 +23,9 @@
 import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
+import com.google.devtools.build.lib.vfs.OsPathPolicy;
 import com.google.devtools.build.lib.vfs.PathFragment;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
@@ -149,7 +151,7 @@
    */
   public static Map<ActionAnalysisMetadata, ArtifactPrefixConflictException>
       findArtifactPrefixConflicts(Map<Artifact, ActionAnalysisMetadata> generatingActions) {
-    TreeMap<PathFragment, Artifact> artifactPathMap = new TreeMap();
+    TreeMap<PathFragment, Artifact> artifactPathMap = new TreeMap<>(comparatorForPrefixConflicts());
     for (Artifact artifact : generatingActions.keySet()) {
       artifactPathMap.put(artifact.getExecPath(), artifact);
     }
@@ -159,18 +161,63 @@
   }
 
   /**
+   * Returns a comparator for use with {@link #findArtifactPrefixConflicts(ActionGraph, SortedMap)}.
+   */
+  public static Comparator<PathFragment> comparatorForPrefixConflicts() {
+    return PathFragmentPrefixComparator.INSTANCE;
+  }
+
+  private static class PathFragmentPrefixComparator implements Comparator<PathFragment> {
+    private static final PathFragmentPrefixComparator INSTANCE = new PathFragmentPrefixComparator();
+
+    @Override
+    public int compare(PathFragment lhs, PathFragment rhs) {
+      // We need to use the OS path policy in case the OS is case insensitive.
+      OsPathPolicy os = OsPathPolicy.getFilePathOs();
+      String str1 = lhs.getPathString();
+      String str2 = rhs.getPathString();
+      int len1 = str1.length();
+      int len2 = str2.length();
+      int n = Math.min(len1, len2);
+      for (int i = 0; i < n; ++i) {
+        char c1 = str1.charAt(i);
+        char c2 = str2.charAt(i);
+        int res = os.compare(c1, c2);
+        if (res != 0) {
+          if (c1 == PathFragment.SEPARATOR_CHAR) {
+            return -1;
+          } else if (c2 == PathFragment.SEPARATOR_CHAR) {
+            return 1;
+          }
+          return res;
+        }
+      }
+      return len1 - len2;
+    }
+  }
+
+  /**
    * Finds Artifact prefix conflicts between generated artifacts. An artifact prefix conflict
    * happens if one action generates an artifact whose path is a prefix of another artifact's path.
    * Those two artifacts cannot exist simultaneously in the output tree.
    *
    * @param actionGraph the {@link ActionGraph} to query for artifact conflicts
-   * @param artifactPathMap a map mapping generated artifacts to their exec paths
+   * @param artifactPathMap a map mapping generated artifacts to their exec paths. The map must be
+   *     sorted using the comparator from {@link #comparatorForPrefixConflicts()}.
    * @return A map between actions that generated the conflicting artifacts and their associated
    *     {@link ArtifactPrefixConflictException}.
    */
   public static Map<ActionAnalysisMetadata, ArtifactPrefixConflictException>
-      findArtifactPrefixConflicts(ActionGraph actionGraph,
-      SortedMap<PathFragment, Artifact> artifactPathMap) {
+      findArtifactPrefixConflicts(
+          ActionGraph actionGraph, SortedMap<PathFragment, Artifact> artifactPathMap) {
+    // You must construct the sorted map using this comparator for the algorithm to work.
+    // The algorithm requires subdirectories to immediately follow parent directories,
+    // before any files in that directory.
+    // Example: "foo", "foo.obj", foo/bar" must be sorted
+    // "foo", "foo/bar", foo.obj"
+    Preconditions.checkArgument(
+        artifactPathMap.comparator() instanceof PathFragmentPrefixComparator,
+        "artifactPathMap must be sorted with PathFragmentPrefixComparator");
     // No actions in graph -- currently happens only in tests. Special-cased because .next() call
     // below is unconditional.
     if (artifactPathMap.isEmpty()) {
diff --git a/src/main/java/com/google/devtools/build/lib/actions/Artifact.java b/src/main/java/com/google/devtools/build/lib/actions/Artifact.java
index 395f5df..964b05d 100644
--- a/src/main/java/com/google/devtools/build/lib/actions/Artifact.java
+++ b/src/main/java/com/google/devtools/build/lib/actions/Artifact.java
@@ -176,7 +176,6 @@
   public static final Predicate<Artifact> MIDDLEMAN_FILTER = input -> !input.isMiddlemanArtifact();
 
   private final int hashCode;
-  private final Path path;
   private final ArtifactRoot root;
   private final PathFragment execPath;
   private final PathFragment rootRelativePath;
@@ -203,35 +202,26 @@
    */
   @VisibleForTesting
   @AutoCodec.Instantiator
-  public Artifact(Path path, ArtifactRoot root, PathFragment execPath, ArtifactOwner owner) {
-    if (root == null || !root.getRoot().contains(path)) {
-      throw new IllegalArgumentException(root + ": illegal root for " + path
-          + " (execPath: " + execPath + ")");
-    }
-    if (execPath == null
-        || execPath.isAbsolute() != root.getRoot().isAbsolute()
-        || !path.asFragment().endsWith(execPath)) {
-      throw new IllegalArgumentException(execPath + ": illegal execPath for " + path
-          + " (root: " + root + ")");
+  public Artifact(ArtifactRoot root, PathFragment execPath, ArtifactOwner owner) {
+    Preconditions.checkNotNull(root);
+    if (execPath == null || execPath.isAbsolute() != root.getRoot().isAbsolute()) {
+      throw new IllegalArgumentException(
+          execPath + ": illegal execPath for " + execPath + " (root: " + root + ")");
     }
     if (execPath.isEmpty()) {
       throw new IllegalArgumentException(
           "it is illegal to create an artifact with an empty execPath");
     }
-    this.hashCode = path.hashCode();
-    this.path = path;
+    this.hashCode = execPath.hashCode();
     this.root = root;
     this.execPath = execPath;
-    // These two lines establish the invariant that
-    // execPath == rootRelativePath <=> execPath.equals(rootRelativePath)
-    // This is important for isSourceArtifact.
-    PathFragment rootRel = root.getRoot().relativize(path);
-    if (!execPath.endsWith(rootRel)) {
-      throw new IllegalArgumentException(execPath + ": illegal execPath doesn't end with "
-          + rootRel + " at " + path + " with root " + root);
+    PathFragment rootExecPath = root.getExecPath();
+    if (rootExecPath.isEmpty()) {
+      this.rootRelativePath = execPath;
+    } else {
+      this.rootRelativePath = execPath.relativeTo(root.getExecPath());
     }
-    this.rootRelativePath = rootRel.equals(execPath) ? execPath : rootRel;
-    this.owner = Preconditions.checkNotNull(owner, path);
+    this.owner = Preconditions.checkNotNull(owner);
   }
 
   /**
@@ -251,8 +241,8 @@
    * <pre>
    */
   @VisibleForTesting
-  public Artifact(Path path, ArtifactRoot root, PathFragment execPath) {
-    this(path, root, execPath, ArtifactOwner.NullArtifactOwner.INSTANCE);
+  public Artifact(ArtifactRoot root, PathFragment execPath) {
+    this(root, execPath, ArtifactOwner.NullArtifactOwner.INSTANCE);
   }
 
   /**
@@ -262,7 +252,6 @@
   @VisibleForTesting // Only exists for testing.
   public Artifact(Path path, ArtifactRoot root) {
     this(
-        path,
         root,
         root.getExecPath().getRelative(root.getRoot().relativize(path)),
         ArtifactOwner.NullArtifactOwner.INSTANCE);
@@ -272,14 +261,13 @@
   @VisibleForTesting // Only exists for testing.
   public Artifact(PathFragment rootRelativePath, ArtifactRoot root) {
     this(
-        root.getRoot().getRelative(rootRelativePath),
         root,
         root.getExecPath().getRelative(rootRelativePath),
         ArtifactOwner.NullArtifactOwner.INSTANCE);
   }
 
   public final Path getPath() {
-    return path;
+    return root.getRoot().getRelative(rootRelativePath);
   }
 
   public boolean hasParent() {
@@ -412,9 +400,8 @@
     structField = true,
     doc = "Returns true if this is a source file, i.e. it is not generated."
   )
-  @SuppressWarnings("ReferenceEquality")  // == is an optimization
   public final boolean isSourceArtifact() {
-    return execPath == rootRelativePath;
+    return root.isSourceRoot();
   }
 
   /**
@@ -479,12 +466,8 @@
 
     @VisibleForSerialization
     public SpecialArtifact(
-        Path path,
-        ArtifactRoot root,
-        PathFragment execPath,
-        ArtifactOwner owner,
-        SpecialArtifactType type) {
-      super(path, root, execPath, owner);
+        ArtifactRoot root, PathFragment execPath, ArtifactOwner owner, SpecialArtifactType type) {
+      super(root, execPath, owner);
       this.type = type;
     }
 
@@ -559,17 +542,16 @@
     TreeFileArtifact(
         SpecialArtifact parentTreeArtifact, PathFragment parentRelativePath, ArtifactOwner owner) {
       super(
-          parentTreeArtifact.getPath().getRelative(parentRelativePath),
           parentTreeArtifact.getRoot(),
           parentTreeArtifact.getExecPath().getRelative(parentRelativePath),
           owner);
-      Preconditions.checkState(
+      Preconditions.checkArgument(
           parentTreeArtifact.isTreeArtifact(),
           "The parent of TreeFileArtifact (parent-relative path: %s) is not a TreeArtifact: %s",
           parentRelativePath,
           parentTreeArtifact);
-      Preconditions.checkState(
-          parentRelativePath.isNormalized() && !parentRelativePath.isAbsolute(),
+      Preconditions.checkArgument(
+          !parentRelativePath.containsUplevelReferences() && !parentRelativePath.isAbsolute(),
           "%s is not a proper normalized relative path",
           parentRelativePath);
       this.parentTreeArtifact = parentTreeArtifact;
@@ -668,7 +650,7 @@
     // We don't bother to check root in the equivalence relation, because we
     // assume that no root is an ancestor of another one.
     Artifact that = (Artifact) other;
-    return Objects.equals(this.path, that.path);
+    return Objects.equals(this.execPath, that.execPath) && Objects.equals(this.root, that.root);
   }
 
   @Override
@@ -702,7 +684,7 @@
       return "[" + root + "]" + rootRelativePath;
     } else {
       // Derived Artifact: path and root are under execRoot
-      PathFragment execRoot = trimTail(path.asFragment(), execPath);
+      PathFragment execRoot = trimTail(getPath().asFragment(), execPath);
       return "[["
           + execRoot
           + "]"
diff --git a/src/main/java/com/google/devtools/build/lib/actions/ArtifactFactory.java b/src/main/java/com/google/devtools/build/lib/actions/ArtifactFactory.java
index 7a0f88b..d23637a 100644
--- a/src/main/java/com/google/devtools/build/lib/actions/ArtifactFactory.java
+++ b/src/main/java/com/google/devtools/build/lib/actions/ArtifactFactory.java
@@ -149,8 +149,7 @@
     Preconditions.checkArgument(
         execPath.isAbsolute() == root.getRoot().isAbsolute(), "%s %s %s", execPath, root, owner);
     Preconditions.checkNotNull(owner, "%s %s", execPath, root);
-    execPath = execPath.normalize();
-    return getArtifact(root.getRoot().getRelative(execPath), root, execPath, owner, null);
+    return getArtifact(root, execPath, owner, null);
   }
 
   @Override
@@ -162,7 +161,7 @@
     Preconditions.checkArgument(!root.isSourceRoot());
     Preconditions.checkArgument(
         rootRelativePath.isAbsolute() == root.getRoot().isAbsolute(), rootRelativePath);
-    Preconditions.checkArgument(rootRelativePath.isNormalized(), rootRelativePath);
+    Preconditions.checkArgument(!rootRelativePath.containsUplevelReferences(), rootRelativePath);
     Preconditions.checkArgument(
         root.getRoot().asPath().startsWith(execRootParent), "%s %s", root, execRootParent);
     Preconditions.checkArgument(
@@ -182,8 +181,7 @@
   public Artifact getDerivedArtifact(
       PathFragment rootRelativePath, ArtifactRoot root, ArtifactOwner owner) {
     validatePath(rootRelativePath, root);
-    Path path = root.getRoot().getRelative(rootRelativePath);
-    return getArtifact(path, root, root.getExecPath().getRelative(rootRelativePath), owner, null);
+    return getArtifact(root, root.getExecPath().getRelative(rootRelativePath), owner, null);
   }
 
   /**
@@ -197,13 +195,8 @@
   public Artifact getFilesetArtifact(
       PathFragment rootRelativePath, ArtifactRoot root, ArtifactOwner owner) {
     validatePath(rootRelativePath, root);
-    Path path = root.getRoot().getRelative(rootRelativePath);
     return getArtifact(
-        path,
-        root,
-        root.getExecPath().getRelative(rootRelativePath),
-        owner,
-        SpecialArtifactType.FILESET);
+        root, root.getExecPath().getRelative(rootRelativePath), owner, SpecialArtifactType.FILESET);
   }
 
   /**
@@ -216,21 +209,14 @@
   public Artifact getTreeArtifact(
       PathFragment rootRelativePath, ArtifactRoot root, ArtifactOwner owner) {
     validatePath(rootRelativePath, root);
-    Path path = root.getRoot().getRelative(rootRelativePath);
     return getArtifact(
-        path,
-        root,
-        root.getExecPath().getRelative(rootRelativePath),
-        owner,
-        SpecialArtifactType.TREE);
+        root, root.getExecPath().getRelative(rootRelativePath), owner, SpecialArtifactType.TREE);
   }
 
   public Artifact getConstantMetadataArtifact(
       PathFragment rootRelativePath, ArtifactRoot root, ArtifactOwner owner) {
     validatePath(rootRelativePath, root);
-    Path path = root.getRoot().getRelative(rootRelativePath);
     return getArtifact(
-        path,
         root,
         root.getExecPath().getRelative(rootRelativePath),
         owner,
@@ -242,7 +228,6 @@
    * root</code> and <code>execPath</code> to the specified values.
    */
   private synchronized Artifact getArtifact(
-      Path path,
       ArtifactRoot root,
       PathFragment execPath,
       ArtifactOwner owner,
@@ -251,7 +236,7 @@
     Preconditions.checkNotNull(execPath);
 
     if (!root.isSourceRoot()) {
-      return createArtifact(path, root, execPath, owner, type);
+      return createArtifact(root, execPath, owner, type);
     }
 
     Artifact artifact = sourceArtifactCache.getArtifact(execPath);
@@ -260,23 +245,22 @@
       // There really should be a safety net that makes it impossible to create two Artifacts
       // with the same exec path but a different Owner, but we also need to reuse Artifacts from
       // previous builds.
-      artifact = createArtifact(path, root, execPath, owner, type);
+      artifact = createArtifact(root, execPath, owner, type);
       sourceArtifactCache.putArtifact(execPath, artifact);
     }
     return artifact;
   }
 
   private Artifact createArtifact(
-      Path path,
       ArtifactRoot root,
       PathFragment execPath,
       ArtifactOwner owner,
       @Nullable SpecialArtifactType type) {
-    Preconditions.checkNotNull(owner, path);
+    Preconditions.checkNotNull(owner);
     if (type == null) {
-      return new Artifact(path, root, execPath, owner);
+      return new Artifact(root, execPath, owner);
     } else {
-      return new Artifact.SpecialArtifact(path, root, execPath, owner, type);
+      return new Artifact.SpecialArtifact(root, execPath, owner, type);
     }
   }
 
@@ -301,7 +285,6 @@
         !relativePath.isEmpty(), "%s %s %s", relativePath, baseExecPath, baseRoot);
     PathFragment execPath =
         baseExecPath == null ? relativePath : baseExecPath.getRelative(relativePath);
-    execPath = execPath.normalize();
     if (execPath.containsUplevelReferences()) {
       // Source exec paths cannot escape the source root.
       return null;
@@ -371,17 +354,16 @@
     ArrayList<PathFragment> unresolvedPaths = new ArrayList<>();
 
     for (PathFragment execPath : execPaths) {
-      PathFragment execPathNormalized = execPath.normalize();
-      if (execPathNormalized.containsUplevelReferences()) {
+      if (execPath.containsUplevelReferences()) {
         // Source exec paths cannot escape the source root.
         result.put(execPath, null);
         continue;
       }
       // First try a quick map lookup to see if the artifact already exists.
-      Artifact a = sourceArtifactCache.getArtifactIfValid(execPathNormalized);
+      Artifact a = sourceArtifactCache.getArtifactIfValid(execPath);
       if (a != null) {
         result.put(execPath, a);
-      } else if (isDerivedArtifact(execPathNormalized)) {
+      } else if (isDerivedArtifact(execPath)) {
         // Don't create an artifact if it's derived.
         result.put(execPath, null);
       } else {
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactAction.java b/src/main/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactAction.java
index fb5eafd..fb9dc28 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactAction.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactAction.java
@@ -273,7 +273,7 @@
       if (!line.isEmpty()) {
         PathFragment path = PathFragment.create(line);
 
-        if (!path.isNormalized() || path.isAbsolute()) {
+        if (!PathFragment.isNormalized(line) || path.isAbsolute()) {
           throw new IllegalManifestFileException(
               path + " is not a proper relative path");
         }
diff --git a/src/main/java/com/google/devtools/build/lib/analysis/config/BuildConfiguration.java b/src/main/java/com/google/devtools/build/lib/analysis/config/BuildConfiguration.java
index d5aa190..8652028 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/config/BuildConfiguration.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/config/BuildConfiguration.java
@@ -1307,6 +1307,16 @@
     return Objects.hash(isActionsEnabled(), fragments, buildOptions.getOptions());
   }
 
+  public void describe(StringBuilder sb) {
+    sb.append(isActionsEnabled()).append('\n');
+    for (Fragment fragment : fragments.values()) {
+      sb.append(fragment.getClass().getName()).append('\n');
+    }
+    for (String s : buildOptions.toString().split(" ")) {
+      sb.append(s).append('\n');
+    }
+  }
+
   @Override
   public int hashCode() {
     return hashCode;
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/repository/StripPrefixedPath.java b/src/main/java/com/google/devtools/build/lib/bazel/repository/StripPrefixedPath.java
index a957a00..ea3f887 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/repository/StripPrefixedPath.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/repository/StripPrefixedPath.java
@@ -64,10 +64,9 @@
    * Normalize the path and, if it is absolute, make it relative (e.g., /foo/bar becomes foo/bar).
    */
   private static PathFragment relativize(String path) {
-    PathFragment entryPath = PathFragment.create(path).normalize();
+    PathFragment entryPath = PathFragment.create(path);
     if (entryPath.isAbsolute()) {
-      entryPath = PathFragment.create(entryPath.getSafePathString().substring(
-          entryPath.windowsVolume().length() + 1));
+      entryPath = entryPath.toRelative();
     }
     return entryPath;
   }
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/repository/ZipDecompressor.java b/src/main/java/com/google/devtools/build/lib/bazel/repository/ZipDecompressor.java
index 71d26fc..0f32e75 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/repository/ZipDecompressor.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/repository/ZipDecompressor.java
@@ -124,19 +124,17 @@
       // For symlinks, the "compressed data" is actually the target name.
       int read = reader.getInputStream(entry).read(buffer);
       Preconditions.checkState(read == buffer.length);
-      PathFragment target = PathFragment.create(new String(buffer, Charset.defaultCharset()))
-          .normalize();
-      if (!target.isNormalized()) {
-        PathFragment pointsTo =
-            PathFragment.create(strippedRelativePath.getParentDirectory(), target).normalize();
-        if (!pointsTo.isNormalized()) {
+      PathFragment target = PathFragment.create(new String(buffer, Charset.defaultCharset()));
+      if (target.containsUplevelReferences()) {
+        PathFragment pointsTo = strippedRelativePath.getParentDirectory().getRelative(target);
+        if (pointsTo.containsUplevelReferences()) {
           throw new IOException("Zip entries cannot refer to files outside of their directory: "
               + reader.getFilename() + " has a symlink " + strippedRelativePath + " pointing to "
               + target);
         }
       }
       if (target.isAbsolute()) {
-        target = target.relativeTo(PathFragment.ROOT_DIR);
+        target = target.relativeTo("/");
         target = destinationDirectory.getRelative(target).asFragment();
       }
       outputPath.createSymbolicLink(target);
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/java/BazelJavaSemantics.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/java/BazelJavaSemantics.java
index 50c65c1..21f5ae5 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/java/BazelJavaSemantics.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/java/BazelJavaSemantics.java
@@ -236,8 +236,8 @@
         if (!isRunfilesEnabled) {
           buffer.append("$(rlocation ");
           PathFragment runfilePath =
-              PathFragment.create(PathFragment.create(workspacePrefix), artifact.getRunfilesPath());
-          buffer.append(runfilePath.normalize().getPathString());
+              PathFragment.create(workspacePrefix).getRelative(artifact.getRunfilesPath());
+          buffer.append(runfilePath.getPathString());
           buffer.append(")");
         } else {
           buffer.append("${RUNPATH}");
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/python/BazelPythonSemantics.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/python/BazelPythonSemantics.java
index 0227f75..8f9ede0 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/python/BazelPythonSemantics.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/python/BazelPythonSemantics.java
@@ -107,8 +107,8 @@
             "ignoring invalid absolute path '" + importsAttr + "'");
         continue;
       }
-      PathFragment importsPath = packageFragment.getRelative(importsAttr).normalize();
-      if (!importsPath.isNormalized()) {
+      PathFragment importsPath = packageFragment.getRelative(importsAttr);
+      if (importsPath.containsUplevelReferences()) {
         ruleContext.attributeError("imports",
             "Path " + importsAttr + " references a path above the execution root");
       }
@@ -239,10 +239,10 @@
     String zipRunfilesPath;
     if (isUnderWorkspace(path)) {
       // If the file is under workspace, add workspace name as prefix
-      zipRunfilesPath = workspaceName.getRelative(path).normalize().toString();
+      zipRunfilesPath = workspaceName.getRelative(path).toString();
     } else {
       // If the file is in external package, strip "external"
-      zipRunfilesPath = path.relativeTo(Label.EXTERNAL_PATH_PREFIX).normalize().toString();
+      zipRunfilesPath = path.relativeTo(Label.EXTERNAL_PATH_PREFIX).toString();
     }
     // We put the whole runfiles tree under the ZIP_RUNFILES_DIRECTORY_NAME directory, by doing this
     // , we avoid the conflict between default workspace name "__main__" and __main__.py file.
diff --git a/src/main/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactory.java b/src/main/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactory.java
index d07f6a5..8c39215 100644
--- a/src/main/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactory.java
+++ b/src/main/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactory.java
@@ -22,6 +22,8 @@
 import com.google.devtools.build.lib.buildeventstream.PathConverter;
 import com.google.devtools.build.lib.vfs.Path;
 import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
 
 /** Factory used to create a Set of BuildEventTransports from BuildEventStreamOptions. */
 public enum BuildEventTransportFactory {
@@ -101,7 +103,41 @@
   private static class NullPathConverter implements PathConverter {
     @Override
     public String apply(Path path) {
-      return path.toURI().toString();
+      return pathToUriString(path.getPathString());
+    }
+  }
+
+  /**
+   * Returns the path encoded as an {@link URI}.
+   *
+   * <p>This concrete implementation returns URIs with "file" as the scheme. For Example: - On Unix
+   * the path "/tmp/foo bar.txt" will be encoded as "file:///tmp/foo%20bar.txt". - On Windows the
+   * path "C:\Temp\Foo Bar.txt" will be encoded as "file:///C:/Temp/Foo%20Bar.txt"
+   *
+   * <p>Implementors extending this class for special filesystems will likely need to override this
+   * method.
+   *
+   * @throws URISyntaxException if the URI cannot be constructed.
+   */
+  static String pathToUriString(String path) {
+    if (!path.startsWith("/")) {
+      // On Windows URI's need to start with a '/'. i.e. C:\Foo\Bar would be file:///C:/Foo/Bar
+      path = "/" + path;
+    }
+    try {
+      return new URI(
+              "file",
+              // Needs to be "" instead of null, so that toString() will append "//" after the
+              // scheme.
+              // We need this for backwards compatibility reasons as some consumers of the BEP are
+              // broken.
+              "",
+              path,
+              null,
+              null)
+          .toString();
+    } catch (URISyntaxException e) {
+      throw new IllegalStateException(e);
     }
   }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/cmdline/Label.java b/src/main/java/com/google/devtools/build/lib/cmdline/Label.java
index 2fbb2a4..054648d 100644
--- a/src/main/java/com/google/devtools/build/lib/cmdline/Label.java
+++ b/src/main/java/com/google/devtools/build/lib/cmdline/Label.java
@@ -345,8 +345,17 @@
     return packageIdentifier.getPackageFragment();
   }
 
-  /** Returns the label as a path fragment, using the package and the label name. */
+  /**
+   * Returns the label as a path fragment, using the package and the label name.
+   *
+   * <p>Make sure that the label refers to a file. Non-file labels do not necessarily have
+   * PathFragment representations.
+   */
   public PathFragment toPathFragment() {
+    // PathFragments are normalized, so if we do this on a non-file target named '.'
+    // then the package would be returned. Detect this and throw.
+    // A target named '.' can never refer to a file.
+    Preconditions.checkArgument(!name.equals("."));
     return packageIdentifier.getPackageFragment().getRelative(name);
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/cmdline/PackageIdentifier.java b/src/main/java/com/google/devtools/build/lib/cmdline/PackageIdentifier.java
index ac62a3a..2067b64 100644
--- a/src/main/java/com/google/devtools/build/lib/cmdline/PackageIdentifier.java
+++ b/src/main/java/com/google/devtools/build/lib/cmdline/PackageIdentifier.java
@@ -87,7 +87,7 @@
       // TODO(ulfjack): Remove this when kchodorow@'s exec root rearrangement has been rolled out.
       RepositoryName repository = RepositoryName.create("@" + tofind.getSegment(1));
       return PackageIdentifier.create(repository, tofind.subFragment(2));
-    } else if (!tofind.normalize().isNormalized()) {
+    } else if (tofind.containsUplevelReferences()) {
       RepositoryName repository = RepositoryName.create("@" + tofind.getSegment(1));
       return PackageIdentifier.create(repository, tofind.subFragment(2));
     } else {
@@ -112,9 +112,6 @@
 
   private PackageIdentifier(RepositoryName repository, PathFragment pkgName) {
     this.repository = Preconditions.checkNotNull(repository);
-    if (!pkgName.isNormalized()) {
-      pkgName = pkgName.normalize();
-    }
     this.pkgName = Canonicalizer.fragments().intern(Preconditions.checkNotNull(pkgName));
     this.hashCode = Objects.hash(repository, pkgName);
   }
diff --git a/src/main/java/com/google/devtools/build/lib/packages/Package.java b/src/main/java/com/google/devtools/build/lib/packages/Package.java
index 4bbd3bf..8a1f02a 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/Package.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/Package.java
@@ -536,7 +536,7 @@
     // stat(2) is executed.
     Path filename = getPackageDirectory().getRelative(targetName);
     String suffix;
-    if (!PathFragment.create(targetName).isNormalized()) {
+    if (!PathFragment.isNormalized(targetName)) {
       // Don't check for file existence in this case because the error message
       // would be confusing and wrong. If the targetName is "foo/bar/.", and
       // there is a directory "foo/bar", it doesn't mean that "//pkg:foo/bar/."
diff --git a/src/main/java/com/google/devtools/build/lib/packages/RelativePackageNameResolver.java b/src/main/java/com/google/devtools/build/lib/packages/RelativePackageNameResolver.java
index 8710807..bc314a4 100644
--- a/src/main/java/com/google/devtools/build/lib/packages/RelativePackageNameResolver.java
+++ b/src/main/java/com/google/devtools/build/lib/packages/RelativePackageNameResolver.java
@@ -72,7 +72,6 @@
     }
 
     PathFragment result = isAbsolute ? relative : offset.getRelative(relative);
-    result = result.normalize();
     if (result.containsUplevelReferences()) {
       throw new InvalidPackageNameException(
           PackageIdentifier.createInMainRepo(pkg),
diff --git a/src/main/java/com/google/devtools/build/lib/remote/TreeNodeRepository.java b/src/main/java/com/google/devtools/build/lib/remote/TreeNodeRepository.java
index 0e57b17..8a1dfe9 100644
--- a/src/main/java/com/google/devtools/build/lib/remote/TreeNodeRepository.java
+++ b/src/main/java/com/google/devtools/build/lib/remote/TreeNodeRepository.java
@@ -110,8 +110,8 @@
           return false;
         }
         ChildEntry other = (ChildEntry) o;
-        // Pointer comparisons only, because both the Path segments and the TreeNodes are interned.
-        return other.segment == segment && other.child == child;
+        // Pointer comparison for the TreeNode as it is interned
+        return other.segment.equals(segment) && other.child == child;
       }
 
       @Override
@@ -322,7 +322,7 @@
     String segment = segments.get(inputsStart).get(segmentIndex);
     for (int inputIndex = inputsStart; inputIndex < inputsEnd; ++inputIndex) {
       if (inputIndex + 1 == inputsEnd
-          || segment != segments.get(inputIndex + 1).get(segmentIndex)) {
+          || !segment.equals(segments.get(inputIndex + 1).get(segmentIndex))) {
         entries.add(
             new TreeNode.ChildEntry(
                 segment,
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCommon.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCommon.java
index fa2c96e..e9ae312 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCommon.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCommon.java
@@ -545,8 +545,8 @@
             "ignoring invalid absolute path '" + includesAttr + "'");
         continue;
       }
-      PathFragment includesPath = packageFragment.getRelative(includesAttr).normalize();
-      if (!includesPath.isNormalized()) {
+      PathFragment includesPath = packageFragment.getRelative(includesAttr);
+      if (includesPath.containsUplevelReferences()) {
         ruleContext.attributeError("includes",
             "Path references a path above the execution root.");
       }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
index d6464d1..a7c1615 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
@@ -757,15 +757,25 @@
           null);
     }
 
-    PathFragment prefix =
-        ruleContext.attributes().isAttributeValueExplicitlySpecified("include_prefix")
-            ? PathFragment.create(ruleContext.attributes().get("include_prefix", Type.STRING))
-            : null;
+    PathFragment prefix = null;
+    if (ruleContext.attributes().isAttributeValueExplicitlySpecified("include_prefix")) {
+      String prefixAttr = ruleContext.attributes().get("include_prefix", Type.STRING);
+      prefix = PathFragment.create(prefixAttr);
+      if (PathFragment.containsUplevelReferences(prefixAttr)) {
+        ruleContext.attributeError("include_prefix", "should not contain uplevel references");
+      }
+      if (prefix.isAbsolute()) {
+        ruleContext.attributeError("include_prefix", "should be a relative path");
+      }
+    }
 
     PathFragment stripPrefix;
     if (ruleContext.attributes().isAttributeValueExplicitlySpecified("strip_include_prefix")) {
-      stripPrefix =
-          PathFragment.create(ruleContext.attributes().get("strip_include_prefix", Type.STRING));
+      String stripPrefixAttr = ruleContext.attributes().get("strip_include_prefix", Type.STRING);
+      if (PathFragment.containsUplevelReferences(stripPrefixAttr)) {
+        ruleContext.attributeError("strip_include_prefix", "should not contain uplevel references");
+      }
+      stripPrefix = PathFragment.create(stripPrefixAttr);
       if (stripPrefix.isAbsolute()) {
         stripPrefix =
             ruleContext
@@ -791,18 +801,6 @@
           null);
     }
 
-    if (stripPrefix.containsUplevelReferences()) {
-      ruleContext.attributeError("strip_include_prefix", "should not contain uplevel references");
-    }
-
-    if (prefix != null && prefix.containsUplevelReferences()) {
-      ruleContext.attributeError("include_prefix", "should not contain uplevel references");
-    }
-
-    if (prefix != null && prefix.isAbsolute()) {
-      ruleContext.attributeError("include_prefix", "should be a relative path");
-    }
-
     if (ruleContext.hasErrors()) {
       return new PublicHeaders(ImmutableList.<Artifact>of(), ImmutableList.<Artifact>of(), null);
     }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcIncLibrary.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcIncLibrary.java
index a844ef6..9101e9b 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcIncLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcIncLibrary.java
@@ -98,13 +98,12 @@
 
     // For every source artifact, we compute a virtual artifact that is below the include directory.
     // These are used for include checking.
-    PathFragment prefixFragment = packageFragment.getRelative(expandedIncSymlinkAttr);
-    if (!prefixFragment.isNormalized()) {
+    if (!PathFragment.isNormalized(expandedIncSymlinkAttr)) {
       ruleContext.attributeWarning("prefix", "should not contain '.' or '..' elements");
     }
+    PathFragment prefixFragment = packageFragment.getRelative(expandedIncSymlinkAttr);
     ImmutableSortedMap.Builder<Artifact, Artifact> virtualArtifactMapBuilder =
         ImmutableSortedMap.orderedBy(Artifact.EXEC_PATH_COMPARATOR);
-    prefixFragment = prefixFragment.normalize();
     ImmutableList<Artifact> hdrs = ruleContext.getPrerequisiteArtifacts("hdrs", Mode.TARGET).list();
     for (Artifact src : hdrs) {
       // All declared header files must start with package/targetPrefix.
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java
index 122fc14..5f848b4 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchain.java
@@ -169,10 +169,10 @@
       }
     }
 
-    PathFragment path = PathFragment.create(pathString);
-    if (!path.isNormalized()) {
+    if (!PathFragment.isNormalized(pathString)) {
       throw new InvalidConfigurationException("The include path '" + s + "' is not normalized.");
     }
+    PathFragment path = PathFragment.create(pathString);
     return pathPrefix.getRelative(path);
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompilationContext.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompilationContext.java
index da8827d..ea12fad 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompilationContext.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompilationContext.java
@@ -512,7 +512,7 @@
      * absolute. Before it is stored, the include directory is normalized.
      */
     public Builder addIncludeDir(PathFragment includeDir) {
-      includeDirs.add(includeDir.normalize());
+      includeDirs.add(includeDir);
       return this;
     }
 
@@ -536,7 +536,7 @@
      * is stored, the include directory is normalized.
      */
     public Builder addQuoteIncludeDir(PathFragment quoteIncludeDir) {
-      quoteIncludeDirs.add(quoteIncludeDir.normalize());
+      quoteIncludeDirs.add(quoteIncludeDir);
       return this;
     }
 
@@ -547,7 +547,7 @@
      * is stored, the include directory is normalized.
      */
     public Builder addSystemIncludeDir(PathFragment systemIncludeDir) {
-      systemIncludeDirs.add(systemIncludeDir.normalize());
+      systemIncludeDirs.add(systemIncludeDir);
       return this;
     }
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileActionBuilder.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileActionBuilder.java
index 247d3ef..e462a03 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileActionBuilder.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppCompileActionBuilder.java
@@ -488,8 +488,7 @@
       if (includePath.startsWith(Label.EXTERNAL_PATH_PREFIX)) {
         includePath = includePath.relativeTo(Label.EXTERNAL_PATH_PREFIX);
       }
-      if (includePath.isAbsolute()
-          || !PathFragment.EMPTY_FRAGMENT.getRelative(includePath).normalize().isNormalized()) {
+      if (includePath.isAbsolute() || includePath.containsUplevelReferences()) {
         errorReporter.accept(
             String.format(
                 "The include path '%s' references a path outside of the execution root.",
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
index 058f34d..107a4cc 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
@@ -1381,15 +1381,15 @@
   }
 
   public static PathFragment computeDefaultSysroot(CToolchain toolchain) {
-    PathFragment defaultSysroot =
-        toolchain.getBuiltinSysroot().length() == 0
-            ? null
-            : PathFragment.create(toolchain.getBuiltinSysroot());
-    if ((defaultSysroot != null) && !defaultSysroot.isNormalized()) {
-      throw new IllegalArgumentException(
-          "The built-in sysroot '" + defaultSysroot + "' is not normalized.");
+    String builtInSysroot = toolchain.getBuiltinSysroot();
+    if (builtInSysroot.isEmpty()) {
+      return null;
     }
-    return defaultSysroot;
+    if (!PathFragment.isNormalized(builtInSysroot)) {
+      throw new IllegalArgumentException(
+          "The built-in sysroot '" + builtInSysroot + "' is not normalized.");
+    }
+    return PathFragment.create(builtInSysroot);
   }
 
   @Override
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java
index 135b70b..91f9502 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppToolchainInfo.java
@@ -794,11 +794,11 @@
       CToolchain toolchain, PathFragment crosstoolTopPathFragment) {
     Map<String, PathFragment> toolPathsCollector = Maps.newHashMap();
     for (CrosstoolConfig.ToolPath tool : toolchain.getToolPathList()) {
-      PathFragment path = PathFragment.create(tool.getPath());
-      if (!path.isNormalized()) {
-        throw new IllegalArgumentException(
-            "The include path '" + tool.getPath() + "' is not normalized.");
+      String pathStr = tool.getPath();
+      if (!PathFragment.isNormalized(pathStr)) {
+        throw new IllegalArgumentException("The include path '" + pathStr + "' is not normalized.");
       }
+      PathFragment path = PathFragment.create(pathStr);
       toolPathsCollector.put(tool.getName(), crosstoolTopPathFragment.getRelative(path));
     }
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/java/JavaCommon.java b/src/main/java/com/google/devtools/build/lib/rules/java/JavaCommon.java
index 458ac57..b2394ca 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/java/JavaCommon.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/java/JavaCommon.java
@@ -505,9 +505,9 @@
 
     if (!javaExecutable.isAbsolute()) {
       javaExecutable =
-          PathFragment.create(PathFragment.create(ruleContext.getWorkspaceName()), javaExecutable);
+          PathFragment.create(ruleContext.getWorkspaceName()).getRelative(javaExecutable);
     }
-    return javaExecutable.normalize().getPathString();
+    return javaExecutable.getPathString();
   }
 
   /**
diff --git a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
index 7f6437e..e15c748 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/nativedeps/NativeDepsHelper.java
@@ -312,7 +312,7 @@
     PathFragment libParentDir =
         relativePath.replaceName(lib.getExecPath().getParentDirectory().getBaseName());
     String libName = lib.getExecPath().getBaseName();
-    return PathFragment.create(libParentDir, PathFragment.create(libName));
+    return libParentDir.getRelative(libName);
   }
 
   /**
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/AppleStubBinary.java b/src/main/java/com/google/devtools/build/lib/rules/objc/AppleStubBinary.java
index 2e84f6f..e73c665 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/AppleStubBinary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/AppleStubBinary.java
@@ -188,8 +188,7 @@
 
     makeVariableContext.validatePathRoot(pathString);
 
-    PathFragment pathFragment = PathFragment.create(pathString);
-    if (!pathFragment.isNormalized()) {
+    if (!PathFragment.isNormalized(pathString)) {
       throw ruleContext.throwWithAttributeError(
           AppleStubBinaryRule.XCENV_BASED_PATH_ATTR, PATH_NOT_NORMALIZED_ERROR);
     }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationAttributes.java b/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationAttributes.java
index 39c28b7..f3c79b2 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationAttributes.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationAttributes.java
@@ -403,7 +403,7 @@
           Iterables.filter(includes(), Predicates.not(PathFragment::isAbsolute));
       for (PathFragment include : relativeIncludes) {
         for (PathFragment rootFragment : rootFragments) {
-          paths.add(rootFragment.getRelative(include).normalize());
+          paths.add(rootFragment.getRelative(include));
         }
       }
     }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcLibrary.java b/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcLibrary.java
index 27c1f67..61bbb37 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcLibrary.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/J2ObjcLibrary.java
@@ -130,7 +130,7 @@
     // We add another header search path with gen root if we have generated sources to translate.
     for (Artifact sourceToTranslate : sourcesToTranslate) {
       if (!sourceToTranslate.isSourceArtifact()) {
-        headerSearchPaths.add(PathFragment.create(objcFileRootExecPath, genRoot));
+        headerSearchPaths.add(objcFileRootExecPath.getRelative(genRoot));
         return headerSearchPaths.build();
       }
     }
diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/ProtobufSupport.java b/src/main/java/com/google/devtools/build/lib/rules/objc/ProtobufSupport.java
index 1a7e1e2..b3c6d7e 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/ProtobufSupport.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/ProtobufSupport.java
@@ -515,8 +515,7 @@
     // of dependers.
     PathFragment rootRelativeOutputDir = ruleContext.getUniqueDirectory(UNIQUE_DIRECTORY_NAME);
 
-    return PathFragment.create(
-        buildConfiguration.getBinDirectory().getExecPath(), rootRelativeOutputDir);
+    return buildConfiguration.getBinDirectory().getExecPath().getRelative(rootRelativeOutputDir);
   }
 
   private Iterable<Artifact> getGeneratedProtoOutputs(
@@ -526,9 +525,8 @@
       String protoFileName = FileSystemUtils.removeExtension(protoFile.getFilename());
       String generatedOutputName = attributes.getGeneratedProtoFilename(protoFileName, true);
 
-      PathFragment generatedFilePath = PathFragment.create(
-          protoFile.getRootRelativePath().getParentDirectory(),
-          PathFragment.create(generatedOutputName));
+      PathFragment generatedFilePath =
+          protoFile.getRootRelativePath().getParentDirectory().getRelative(generatedOutputName);
 
       PathFragment outputFile = FileSystemUtils.appendExtension(generatedFilePath, extension);
 
diff --git a/src/main/java/com/google/devtools/build/lib/runtime/commands/DumpCommand.java b/src/main/java/com/google/devtools/build/lib/runtime/commands/DumpCommand.java
index c4b1e5f..87cddd7 100644
--- a/src/main/java/com/google/devtools/build/lib/runtime/commands/DumpCommand.java
+++ b/src/main/java/com/google/devtools/build/lib/runtime/commands/DumpCommand.java
@@ -33,7 +33,6 @@
 import com.google.devtools.build.lib.skyframe.SkyframeExecutor;
 import com.google.devtools.build.lib.skyframe.SkyframeExecutor.RuleStat;
 import com.google.devtools.build.lib.util.ExitCode;
-import com.google.devtools.build.lib.vfs.FileSystemUtils;
 import com.google.devtools.common.options.EnumConverter;
 import com.google.devtools.common.options.Option;
 import com.google.devtools.common.options.OptionDocumentationCategory;
@@ -207,8 +206,9 @@
       }
 
       if (dumpOptions.dumpVfs) {
+        // TODO(b/72498697): Remove this flag
         out.println("Filesystem cache");
-        FileSystemUtils.dump(env.getOutputBase().getFileSystem(), out);
+        out.println("dump --vfs is no longer meaningful");
         out.println();
       }
 
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/LocalRepositoryLookupFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/LocalRepositoryLookupFunction.java
index 6d6d2eb..4c699ab 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/LocalRepositoryLookupFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/LocalRepositoryLookupFunction.java
@@ -217,8 +217,7 @@
           String path = (String) rule.getAttributeContainer().getAttr("path");
           return Optional.of(
               LocalRepositoryLookupValue.success(
-                  RepositoryName.create("@" + rule.getName()),
-                  PathFragment.create(path).normalize()));
+                  RepositoryName.create("@" + rule.getName()), PathFragment.create(path)));
         } catch (LabelSyntaxException e) {
           // This shouldn't be possible if the rule name is valid, and it should already have been
           // validated.
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java
index 6da94fd..6114f1d 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/PackageFunction.java
@@ -814,7 +814,13 @@
     Set<SkyKey> containingPkgLookupKeys = Sets.newHashSet();
     Map<Target, SkyKey> targetToKey = new HashMap<>();
     for (Target target : pkgBuilder.getTargets()) {
-      PathFragment dir = target.getLabel().toPathFragment().getParentDirectory();
+      PathFragment dir = getContainingDirectory(target.getLabel());
+      if (dir == null) {
+        throw new IllegalStateException(
+            String.format(
+                "Null pkg for label %s as path fragment %s in pkg %s",
+                target.getLabel(), target.getLabel().getPackageFragment(), pkgId));
+      }
       PackageIdentifier dirId = PackageIdentifier.create(pkgId.getRepository(), dir);
       if (dir.equals(pkgId.getPackageFragment())) {
         continue;
@@ -825,7 +831,7 @@
     }
     Map<Label, SkyKey> subincludeToKey = new HashMap<>();
     for (Label subincludeLabel : pkgBuilder.getSubincludeLabels()) {
-      PathFragment dir = subincludeLabel.toPathFragment().getParentDirectory();
+      PathFragment dir = getContainingDirectory(subincludeLabel);
       PackageIdentifier dirId = PackageIdentifier.create(pkgId.getRepository(), dir);
       if (dir.equals(pkgId.getPackageFragment())) {
         continue;
@@ -870,6 +876,12 @@
     }
   }
 
+  private static PathFragment getContainingDirectory(Label label) {
+    PathFragment pkg = label.getPackageFragment();
+    String name = label.getName();
+    return name.equals(".") ? pkg : pkg.getRelative(name).getParentDirectory();
+  }
+
   @Nullable
   private static ContainingPackageLookupValue
   getContainingPkgLookupValueAndPropagateInconsistentFilesystemExceptions(
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeActionExecutor.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeActionExecutor.java
index 97d257c..ff12e07 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeActionExecutor.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeActionExecutor.java
@@ -266,7 +266,8 @@
           ConcurrentMap<ActionAnalysisMetadata, ConflictException> badActionMap)
           throws InterruptedException {
     MutableActionGraph actionGraph = new MapBasedActionGraph(actionKeyContext);
-    ConcurrentNavigableMap<PathFragment, Artifact> artifactPathMap = new ConcurrentSkipListMap<>();
+    ConcurrentNavigableMap<PathFragment, Artifact> artifactPathMap =
+        new ConcurrentSkipListMap<>(Actions.comparatorForPrefixConflicts());
     // Action graph construction is CPU-bound.
     int numJobs = Runtime.getRuntime().availableProcessors();
     // No great reason for expecting 5000 action lookup values, but not worth counting size of
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/TargetMarkerFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/TargetMarkerFunction.java
index 2aeba41..1758fb3 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/TargetMarkerFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/TargetMarkerFunction.java
@@ -57,7 +57,7 @@
     if (label.getName().contains("/")) {
       // This target is in a subdirectory, therefore it could potentially be invalidated by
       // a new BUILD file appearing in the hierarchy.
-      PathFragment containingDirectory = label.toPathFragment().getParentDirectory();
+      PathFragment containingDirectory = getContainingDirectory(label);
       ContainingPackageLookupValue containingPackageLookupValue;
       try {
         PackageIdentifier newPkgId = PackageIdentifier.create(
@@ -109,6 +109,12 @@
     return TargetMarkerValue.TARGET_MARKER_INSTANCE;
   }
 
+  private static PathFragment getContainingDirectory(Label label) {
+    PathFragment pkg = label.getPackageFragment();
+    String name = label.getName();
+    return name.equals(".") ? pkg : pkg.getRelative(name).getParentDirectory();
+  }
+
   @Override
   public String extractTag(SkyKey skyKey) {
     return Label.print((Label) skyKey.argument());
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/TreeArtifactValue.java b/src/main/java/com/google/devtools/build/lib/skyframe/TreeArtifactValue.java
index 783899a..f54522f 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/TreeArtifactValue.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/TreeArtifactValue.java
@@ -182,8 +182,7 @@
       PathFragment pathToExplode, ImmutableSet.Builder<PathFragment> valuesBuilder)
       throws IOException {
     for (Path subpath : treeArtifact.getPath().getRelative(pathToExplode).getDirectoryEntries()) {
-      PathFragment canonicalSubpathFragment =
-          pathToExplode.getChild(subpath.getBaseName()).normalize();
+      PathFragment canonicalSubpathFragment = pathToExplode.getChild(subpath.getBaseName());
       if (subpath.isDirectory()) {
         explodeDirectory(treeArtifact,
             pathToExplode.getChild(subpath.getBaseName()), valuesBuilder);
@@ -202,7 +201,7 @@
         // TreeArtifact into a/b/outside_dir.
         PathFragment intermediatePath = canonicalSubpathFragment.getParentDirectory();
         for (String pathSegment : linkTarget.getSegments()) {
-          intermediatePath = intermediatePath.getRelative(pathSegment).normalize();
+          intermediatePath = intermediatePath.getRelative(pathSegment);
           if (intermediatePath.containsUplevelReferences()) {
             String errorMessage = String.format(
                 "A TreeArtifact may not contain relative symlinks whose target paths traverse "
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java
index e8c9ad2..26fc565 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/SkylarkImports.java
@@ -173,7 +173,7 @@
 
     @Override
     public PathFragment asPathFragment() {
-      return PathFragment.create(PathFragment.ROOT_DIR).getRelative(importLabel.toPathFragment());
+      return PathFragment.create("/").getRelative(importLabel.toPathFragment());
     }
 
     @Override
diff --git a/src/main/java/com/google/devtools/build/lib/unix/UnixFileSystem.java b/src/main/java/com/google/devtools/build/lib/unix/UnixFileSystem.java
index 033a6a6..d5a74eb 100644
--- a/src/main/java/com/google/devtools/build/lib/unix/UnixFileSystem.java
+++ b/src/main/java/com/google/devtools/build/lib/unix/UnixFileSystem.java
@@ -326,7 +326,7 @@
   @Override
   protected void createSymbolicLink(Path linkPath, PathFragment targetFragment)
       throws IOException {
-    NativePosixFiles.symlink(targetFragment.toString(), linkPath.toString());
+    NativePosixFiles.symlink(targetFragment.getSafePathString(), linkPath.toString());
   }
 
   @Override
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/BUILD b/src/main/java/com/google/devtools/build/lib/vfs/BUILD
index f7a57be..b829858 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/vfs/BUILD
@@ -10,8 +10,9 @@
     "Canonicalizer.java",
     "PathFragment.java",
     "PathFragmentSerializationProxy.java",
-    "UnixPathFragment.java",
-    "WindowsPathFragment.java",
+    "OsPathPolicy.java",
+    "UnixOsPathPolicy.java",
+    "WindowsOsPathPolicy.java",
 ]
 
 java_library(
@@ -25,6 +26,8 @@
         "//src/main/java/com/google/devtools/build/lib:skylarkinterface",
         "//src/main/java/com/google/devtools/build/lib/concurrent",
         "//src/main/java/com/google/devtools/build/lib/skyframe/serialization",
+        "//src/main/java/com/google/devtools/build/lib/windows:windows_short_path",
+        "//src/main/java/com/google/devtools/build/lib/windows/jni",
         "//third_party:guava",
         "//third_party/protobuf:protobuf_java",
     ],
@@ -47,7 +50,6 @@
         ":pathfragment",
         "//src/main/java/com/google/devtools/build/lib:base-util",
         "//src/main/java/com/google/devtools/build/lib:filetype",
-        "//src/main/java/com/google/devtools/build/lib:os_util",
         "//src/main/java/com/google/devtools/build/lib:skylarkinterface",
         "//src/main/java/com/google/devtools/build/lib/clock",
         "//src/main/java/com/google/devtools/build/lib/concurrent",
@@ -55,8 +57,6 @@
         "//src/main/java/com/google/devtools/build/lib/shell",
         "//src/main/java/com/google/devtools/build/lib/skyframe/serialization",
         "//src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec",
-        "//src/main/java/com/google/devtools/build/lib/windows:windows_short_path",
-        "//src/main/java/com/google/devtools/build/lib/windows/jni",
         "//src/main/java/com/google/devtools/common/options",
         "//third_party:guava",
         "//third_party:jsr305",
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/FileSystem.java b/src/main/java/com/google/devtools/build/lib/vfs/FileSystem.java
index aaaacd9..38da81c 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/FileSystem.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/FileSystem.java
@@ -23,7 +23,6 @@
 import com.google.common.io.CharStreams;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
 import com.google.devtools.build.lib.vfs.Dirent.Type;
-import com.google.devtools.build.lib.vfs.Path.PathFactory;
 import com.google.devtools.common.options.EnumConverter;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -84,25 +83,6 @@
     return digestFunction;
   }
 
-  private enum UnixPathFactory implements PathFactory {
-    INSTANCE {
-      @Override
-      public Path createRootPath(FileSystem filesystem) {
-        return new Path(filesystem, PathFragment.ROOT_DIR, null);
-      }
-
-      @Override
-      public Path createChildPath(Path parent, String childName) {
-        return new Path(parent.getFileSystem(), childName, parent);
-      }
-
-      @Override
-      public Path getCachedChildPathInternal(Path path, String childName) {
-        return Path.getCachedChildPathInternal(path, childName, /*cacheable=*/ true);
-      }
-    };
-  }
-
   /**
    * An exception thrown when attempting to resolve an ordinary file as a symlink.
    */
@@ -112,53 +92,23 @@
     }
   }
 
-  /** Lazy-initialized on first access, always use {@link FileSystem#getRootDirectory} */
-  private volatile Path rootPath;
-
   private final Root absoluteRoot = new Root.AbsoluteRoot(this);
 
-  /** Returns filesystem-specific path factory. */
-  protected PathFactory getPathFactory() {
-    return UnixPathFactory.INSTANCE;
+  /**
+   * Returns an absolute path instance, given an absolute path name, without double slashes, .., or
+   * . segments. While this method will normalize the path representation by creating a
+   * structured/parsed representation, it will not cause any IO. (e.g., it will not resolve symbolic
+   * links if it's a Unix file system.
+   */
+  public Path getPath(String path) {
+    return Path.create(path, this);
   }
 
-  /**
-   * Returns an absolute path instance, given an absolute path name, without
-   * double slashes, .., or . segments. While this method will normalize the
-   * path representation by creating a structured/parsed representation, it will
-   * not cause any IO. (e.g., it will not resolve symbolic links if it's a Unix
-   * file system.
-   */
-  public Path getPath(String pathName) {
-    return getPath(PathFragment.create(pathName));
-  }
-
-  /**
-   * Returns an absolute path instance, given an absolute path name, without
-   * double slashes, .., or . segments. While this method will normalize the
-   * path representation by creating a structured/parsed representation, it will
-   * not cause any IO. (e.g., it will not resolve symbolic links if it's a Unix
-   * file system.
-   */
-  public Path getPath(PathFragment pathName) {
-    if (!pathName.isAbsolute()) {
-      throw new IllegalArgumentException(pathName.getPathString()  + " (not an absolute path)");
-    }
-    return getRootDirectory().getRelative(pathName);
-  }
-
-  /**
-   * Returns a path representing the root directory of the current file system.
-   */
-  public final Path getRootDirectory() {
-    if (rootPath == null) {
-      synchronized (this) {
-        if (rootPath == null) {
-          rootPath = getPathFactory().createRootPath(this);
-        }
-      }
-    }
-    return rootPath;
+  /** Returns an absolute path instance, given an absolute path fragment. */
+  public Path getPath(PathFragment pathFragment) {
+    Preconditions.checkArgument(pathFragment.isAbsolute());
+    return Path.createAlreadyNormalized(
+        pathFragment.getPathString(), pathFragment.getDriveStrLength(), this);
   }
 
   final Root getAbsoluteRoot() {
@@ -401,7 +351,7 @@
       throw new IOException(naive + " (Too many levels of symbolic links)");
     }
     if (linkTarget.isAbsolute()) {
-      dir = getRootDirectory();
+      dir = getPath(linkTarget.getDriveStr());
     }
     for (String name : linkTarget.segments()) {
       if (name.equals(".") || name.isEmpty()) {
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/FileSystemUtils.java b/src/main/java/com/google/devtools/build/lib/vfs/FileSystemUtils.java
index adeb9c8..b7fd8d2 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/FileSystemUtils.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/FileSystemUtils.java
@@ -25,7 +25,6 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.io.PrintStream;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -90,25 +89,13 @@
 
     return a;
   }
-  /**
-   * Returns a path fragment from a given from-dir to a given to-path. May be
-   * either a short relative path "foo/bar", an up'n'over relative path
-   * "../../foo/bar" or an absolute path.
-   */
-  public static PathFragment relativePath(Path fromDir, Path to) {
-    if (to.getFileSystem() != fromDir.getFileSystem()) {
-      throw new IllegalArgumentException("fromDir and to must be on the same FileSystem");
-    }
-
-    return relativePath(fromDir.asFragment(), to.asFragment());
-  }
 
   /**
    * Returns a path fragment from a given from-dir to a given to-path.
    */
   public static PathFragment relativePath(PathFragment fromDir, PathFragment to) {
     if (to.equals(fromDir)) {
-      return PathFragment.create(".");  // same dir, just return '.'
+      return PathFragment.EMPTY_FRAGMENT;
     }
     if (to.startsWith(fromDir)) {
       return to.relativeTo(fromDir);  // easy case--it's a descendant
@@ -883,30 +870,6 @@
   }
 
   /**
-   * Dumps diagnostic information about the specified filesystem to {@code out}.
-   * This is the implementation of the filesystem part of the 'blaze dump'
-   * command. It lives here, rather than in DumpCommand, because it requires
-   * privileged access to members of this package.
-   *
-   * <p>Its results are unspecified and MUST NOT be interpreted programmatically.
-   */
-  public static void dump(FileSystem fs, final PrintStream out) {
-    // Unfortunately there's no "letrec" for anonymous functions so we have to
-    // (a) name the function, (b) put it in a box and (c) use List not array
-    // because of the generic type.  *sigh*.
-    final List<Predicate<Path>> dumpFunction = new ArrayList<>();
-    dumpFunction.add(
-        child -> {
-          Path path = child;
-          out.println("  " + path + " (" + path.toDebugString() + ")");
-          path.applyToChildren(dumpFunction.get(0));
-          return false;
-        });
-
-    fs.getRootDirectory().applyToChildren(dumpFunction.get(0));
-  }
-
-  /**
    * Returns the type of the file system path belongs to.
    */
   public static String getFileSystem(Path path) {
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/JavaIoFileSystem.java b/src/main/java/com/google/devtools/build/lib/vfs/JavaIoFileSystem.java
index 5bba535..f5b0220 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/JavaIoFileSystem.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/JavaIoFileSystem.java
@@ -281,7 +281,7 @@
       throws IOException {
     java.nio.file.Path nioPath = getNioPath(linkPath);
     try {
-      Files.createSymbolicLink(nioPath, Paths.get(targetFragment.getPathString()));
+      Files.createSymbolicLink(nioPath, Paths.get(targetFragment.getSafePathString()));
     } catch (java.nio.file.FileAlreadyExistsException e) {
       throw new IOException(linkPath + ERR_FILE_EXISTS);
     } catch (java.nio.file.AccessDeniedException e) {
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/LocalPath.java b/src/main/java/com/google/devtools/build/lib/vfs/LocalPath.java
deleted file mode 100644
index a32a4e3..0000000
--- a/src/main/java/com/google/devtools/build/lib/vfs/LocalPath.java
+++ /dev/null
@@ -1,715 +0,0 @@
-// Copyright 2017 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.devtools.build.lib.util.OS;
-import com.google.devtools.build.lib.windows.WindowsShortPath;
-import com.google.devtools.build.lib.windows.jni.WindowsFileOperations;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nullable;
-
-/**
- * A local file path representing a file on the host machine. You should use this when you want to
- * access local files via the file system.
- *
- * <p>Paths are either absolute or relative.
- *
- * <p>Strings are normalized with '.' and '..' removed and resolved (if possible), any multiple
- * slashes ('/') removed, and any trailing slash also removed. The current implementation does not
- * touch the incoming path string unless the string actually needs to be normalized.
- *
- * <p>There is some limited support for Windows-style paths. Most importantly, drive identifiers in
- * front of a path (c:/abc) are supported and such paths are correctly recognized as absolute, as
- * are paths with backslash separators (C:\\foo\\bar). However, advanced Windows-style features like
- * \\\\network\\paths and \\\\?\\unc\\paths are not supported. We are currently using forward
- * slashes ('/') even on Windows, so backslashes '\' get converted to forward slashes during
- * normalization.
- *
- * <p>Mac and Windows file paths are case insensitive. Case is preserved.
- *
- * <p>This class is replaces {@link Path} as the way to access the host machine's file system.
- * Developers should use this class instead of {@link Path}.
- */
-public final class LocalPath implements Comparable<LocalPath> {
-  private static final OsPathPolicy DEFAULT_OS = createFilePathOs();
-
-  public static final LocalPath EMPTY = create("");
-
-  private final String path;
-  private final int driveStrLength; // 0 for relative paths, 1 on Unix, 3 on Windows
-  private final OsPathPolicy os;
-
-  /** Creates a local path that is specific to the host OS. */
-  public static LocalPath create(String path) {
-    return createWithOs(path, DEFAULT_OS);
-  }
-
-  @VisibleForTesting
-  static LocalPath createWithOs(String path, OsPathPolicy os) {
-    Preconditions.checkNotNull(path);
-    int normalizationLevel = os.needsToNormalize(path);
-    String normalizedPath = os.normalize(path, normalizationLevel);
-    int driveStrLength = os.getDriveStrLength(normalizedPath);
-    return new LocalPath(normalizedPath, driveStrLength, os);
-  }
-
-  /** This method expects path to already be normalized. */
-  private LocalPath(String path, int driveStrLength, OsPathPolicy os) {
-    this.path = Preconditions.checkNotNull(path);
-    this.driveStrLength = driveStrLength;
-    this.os = Preconditions.checkNotNull(os);
-  }
-
-  public String getPathString() {
-    return path;
-  }
-
-  /**
-   * If called on a {@link LocalPath} instance for a mount name (eg. '/' or 'C:/'), the empty string
-   * is returned.
-   */
-  public String getBaseName() {
-    int lastSeparator = path.lastIndexOf(os.getSeparator());
-    return lastSeparator < driveStrLength
-        ? path.substring(driveStrLength)
-        : path.substring(lastSeparator + 1);
-  }
-
-  /**
-   * Returns a {@link LocalPath} instance representing the relative path between this {@link
-   * LocalPath} and the given {@link LocalPath}.
-   *
-   * <pre>
-   *   Example:
-   *
-   *   LocalPath.create("/foo").getRelative(LocalPath.create("bar/baz"))
-   *   -> "/foo/bar/baz"
-   * </pre>
-   *
-   * <p>If the passed path is absolute it is returned untouched. This can be useful to resolve
-   * symlinks.
-   */
-  public LocalPath getRelative(LocalPath other) {
-    Preconditions.checkNotNull(other);
-    Preconditions.checkArgument(os == other.os);
-    return getRelative(other.getPathString(), other.driveStrLength);
-  }
-
-  /**
-   * Returns a {@link LocalPath} instance representing the relative path between this {@link
-   * LocalPath} and the given path.
-   *
-   * <p>See {@link #getRelative(LocalPath)} for details.
-   */
-  public LocalPath getRelative(String other) {
-    Preconditions.checkNotNull(other);
-    return getRelative(other, os.getDriveStrLength(other));
-  }
-
-  private LocalPath getRelative(String other, int otherDriveStrLength) {
-    if (path.isEmpty()) {
-      return create(other);
-    }
-    if (other.isEmpty()) {
-      return this;
-    }
-    // Note that even if other came from a LocalPath instance we still might
-    // need to normalize the result if (for instance) other is a path that
-    // starts with '..'
-    int normalizationLevel = os.needsToNormalize(other);
-    // This is an absolute path, simply return it
-    if (otherDriveStrLength > 0) {
-      String normalizedPath = os.normalize(other, normalizationLevel);
-      return new LocalPath(normalizedPath, otherDriveStrLength, os);
-    }
-    String newPath;
-    if (path.length() == driveStrLength) {
-      newPath = path + other;
-    } else {
-      newPath = path + '/' + other;
-    }
-    newPath = os.normalize(newPath, normalizationLevel);
-    return new LocalPath(newPath, driveStrLength, os);
-  }
-
-  /**
-   * Returns the parent directory of this {@link LocalPath}.
-   *
-   * <p>If this is called on an single directory for a relative path, this returns an empty relative
-   * path. If it's called on a root (like '/') or the empty string, it returns null.
-   */
-  @Nullable
-  public LocalPath getParentDirectory() {
-    int lastSeparator = path.lastIndexOf(os.getSeparator());
-
-    // For absolute paths we need to specially handle when we hit root
-    // Relative paths can't hit this path as driveStrLength == 0
-    if (driveStrLength > 0) {
-      if (lastSeparator < driveStrLength) {
-        if (path.length() > driveStrLength) {
-          String newPath = path.substring(0, driveStrLength);
-          return new LocalPath(newPath, driveStrLength, os);
-        } else {
-          return null;
-        }
-      }
-    } else {
-      if (lastSeparator == -1) {
-        if (!path.isEmpty()) {
-          return EMPTY;
-        } else {
-          return null;
-        }
-      }
-    }
-    String newPath = path.substring(0, lastSeparator);
-    return new LocalPath(newPath, driveStrLength, os);
-  }
-
-  /**
-   * Returns the {@link LocalPath} relative to the base {@link LocalPath}.
-   *
-   * <p>For example, <code>LocalPath.create("foo/bar/wiz").relativeTo(LocalPath.create("foo"))
-   * </code> returns <code>LocalPath.create("bar/wiz")</code>.
-   *
-   * <p>If the {@link LocalPath} is not a child of the passed {@link LocalPath} an {@link
-   * IllegalArgumentException} is thrown. In particular, this will happen whenever the two {@link
-   * LocalPath} instances aren't both absolute or both relative.
-   */
-  public LocalPath relativeTo(LocalPath base) {
-    Preconditions.checkNotNull(base);
-    Preconditions.checkArgument(os == base.os);
-    if (isAbsolute() != base.isAbsolute()) {
-      throw new IllegalArgumentException(
-          "Cannot relativize an absolute and a non-absolute path pair");
-    }
-    String basePath = base.path;
-    if (!os.startsWith(path, basePath)) {
-      throw new IllegalArgumentException(
-          String.format("Path '%s' is not under '%s', cannot relativize", this, base));
-    }
-    int bn = basePath.length();
-    if (bn == 0) {
-      return this;
-    }
-    if (path.length() == bn) {
-      return EMPTY;
-    }
-    final int lastSlashIndex;
-    if (basePath.charAt(bn - 1) == '/') {
-      lastSlashIndex = bn - 1;
-    } else {
-      lastSlashIndex = bn;
-    }
-    if (path.charAt(lastSlashIndex) != '/') {
-      throw new IllegalArgumentException(
-          String.format("Path '%s' is not under '%s', cannot relativize", this, base));
-    }
-    String newPath = path.substring(lastSlashIndex + 1);
-    return new LocalPath(newPath, 0 /* Always a relative path */, os);
-  }
-
-  /**
-   * Splits a path into its constituent parts. The root is not included. This is an inefficient
-   * operation and should be avoided.
-   */
-  public String[] split() {
-    String[] segments = path.split("/");
-    if (driveStrLength > 0) {
-      // String#split("/") for some reason returns a zero-length array
-      // String#split("/hello") returns a 2-length array, so this makes little sense
-      if (segments.length == 0) {
-        return segments;
-      }
-      return Arrays.copyOfRange(segments, 1, segments.length);
-    }
-    return segments;
-  }
-
-  /**
-   * Returns whether this path is an ancestor of another path.
-   *
-   * <p>A path is considered an ancestor of itself.
-   *
-   * <p>An absolute path can never be an ancestor of a relative path, and vice versa.
-   */
-  public boolean startsWith(LocalPath other) {
-    Preconditions.checkNotNull(other);
-    Preconditions.checkArgument(os == other.os);
-    if (other.path.length() > path.length()) {
-      return false;
-    }
-    if (driveStrLength != other.driveStrLength) {
-      return false;
-    }
-    if (!os.startsWith(path, other.path)) {
-      return false;
-    }
-    return path.length() == other.path.length()
-        || other.path.length() == driveStrLength
-        || path.charAt(other.path.length()) == os.getSeparator();
-  }
-
-  public boolean isAbsolute() {
-    return driveStrLength > 0;
-  }
-
-  @Override
-  public String toString() {
-    return path;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    return os.compare(this.path, ((LocalPath) o).path) == 0;
-  }
-
-  @Override
-  public int hashCode() {
-    return os.hashPath(this.path);
-  }
-
-  @Override
-  public int compareTo(LocalPath o) {
-    return os.compare(this.path, o.path);
-  }
-
-  /**
-   * An interface class representing the differences in path style between different OSs.
-   *
-   * <p>Eg. case sensitivity, '/' mounts vs. 'C:/', etc.
-   */
-  @VisibleForTesting
-  interface OsPathPolicy {
-    int NORMALIZED = 0; // Path is normalized
-    int NEEDS_NORMALIZE = 1; // Path requires normalization
-
-    /** Returns required normalization level, passed to {@link #normalize}. */
-    int needsToNormalize(String path);
-
-    /**
-     * Normalizes the passed string according to the passed normalization level.
-     *
-     * @param normalizationLevel The normalizationLevel from {@link #needsToNormalize}
-     */
-    String normalize(String path, int normalizationLevel);
-
-    /**
-     * Returns the length of the mount, eg. 1 for unix '/', 3 for Windows 'C:/'.
-     *
-     * <p>If the path is relative, 0 is returned
-     */
-    int getDriveStrLength(String path);
-
-    /** Compares two path strings, using the given OS case sensitivity. */
-    int compare(String s1, String s2);
-
-    /** Computes the hash code for a path string. */
-    int hashPath(String s);
-
-    /**
-     * Returns whether the passed string starts with the given prefix, given the OS case
-     * sensitivity.
-     *
-     * <p>This is a pure string operation and doesn't need to worry about matching path segments.
-     */
-    boolean startsWith(String path, String prefix);
-
-    char getSeparator();
-
-    boolean isCaseSensitive();
-  }
-
-  @VisibleForTesting
-  static class UnixOsPathPolicy implements OsPathPolicy {
-
-    @Override
-    public int needsToNormalize(String path) {
-      int n = path.length();
-      int dotCount = 0;
-      char prevChar = 0;
-      for (int i = 0; i < n; i++) {
-        char c = path.charAt(i);
-        if (c == '/') {
-          if (prevChar == '/') {
-            return NEEDS_NORMALIZE;
-          }
-          if (dotCount == 1 || dotCount == 2) {
-            return NEEDS_NORMALIZE;
-          }
-        }
-        dotCount = c == '.' ? dotCount + 1 : 0;
-        prevChar = c;
-      }
-      if (prevChar == '/' || dotCount == 1 || dotCount == 2) {
-        return NEEDS_NORMALIZE;
-      }
-      return NORMALIZED;
-    }
-
-    @Override
-    public String normalize(String path, int normalizationLevel) {
-      if (normalizationLevel == NORMALIZED) {
-        return path;
-      }
-      if (path.isEmpty()) {
-        return path;
-      }
-      boolean isAbsolute = path.charAt(0) == '/';
-      String[] segments = path.split("/+");
-      int segmentCount = removeRelativePaths(segments, isAbsolute ? 1 : 0);
-      StringBuilder sb = new StringBuilder(path.length());
-      if (isAbsolute) {
-        sb.append('/');
-      }
-      for (int i = 0; i < segmentCount; ++i) {
-        sb.append(segments[i]);
-        sb.append('/');
-      }
-      if (segmentCount > 0) {
-        sb.deleteCharAt(sb.length() - 1);
-      }
-      return sb.toString();
-    }
-
-    @Override
-    public int getDriveStrLength(String path) {
-      if (path.length() == 0) {
-        return 0;
-      }
-      return (path.charAt(0) == '/') ? 1 : 0;
-    }
-
-    @Override
-    public int compare(String s1, String s2) {
-      return s1.compareTo(s2);
-    }
-
-    @Override
-    public int hashPath(String s) {
-      return s.hashCode();
-    }
-
-    @Override
-    public boolean startsWith(String path, String prefix) {
-      return path.startsWith(prefix);
-    }
-
-    @Override
-    public char getSeparator() {
-      return '/';
-    }
-
-    @Override
-    public boolean isCaseSensitive() {
-      return true;
-    }
-  }
-
-  /** Mac is a unix file system that is case insensitive. */
-  @VisibleForTesting
-  static class MacOsPathPolicy extends UnixOsPathPolicy {
-    @Override
-    public int compare(String s1, String s2) {
-      return s1.compareToIgnoreCase(s2);
-    }
-
-    @Override
-    public int hashPath(String s) {
-      return s.toLowerCase().hashCode();
-    }
-
-    @Override
-    public boolean isCaseSensitive() {
-      return false;
-    }
-  }
-
-  @VisibleForTesting
-  static class WindowsOsPathPolicy implements OsPathPolicy {
-
-    private static final int NEEDS_SHORT_PATH_NORMALIZATION = NEEDS_NORMALIZE + 1;
-
-    // msys root, used to resolve paths from msys starting with "/"
-    private static final AtomicReference<String> UNIX_ROOT = new AtomicReference<>(null);
-    private final ShortPathResolver shortPathResolver;
-
-    interface ShortPathResolver {
-      String resolveShortPath(String path);
-    }
-
-    static class DefaultShortPathResolver implements ShortPathResolver {
-      @Override
-      public String resolveShortPath(String path) {
-        try {
-          return WindowsFileOperations.getLongPath(path);
-        } catch (IOException e) {
-          return path;
-        }
-      }
-    }
-
-    WindowsOsPathPolicy() {
-      this(new DefaultShortPathResolver());
-    }
-
-    WindowsOsPathPolicy(ShortPathResolver shortPathResolver) {
-      this.shortPathResolver = shortPathResolver;
-    }
-
-    @Override
-    public int needsToNormalize(String path) {
-      int n = path.length();
-      int normalizationLevel = 0;
-      // Check for unix path
-      if (n > 0 && path.charAt(0) == '/') {
-        normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
-      }
-      int dotCount = 0;
-      char prevChar = 0;
-      int segmentBeginIndex = 0; // The start index of the current path index
-      boolean segmentHasShortPathChar = false; // Triggers more expensive short path regex test
-      for (int i = 0; i < n; i++) {
-        char c = path.charAt(i);
-        if (c == '/' || c == '\\') {
-          if (c == '\\') {
-            normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
-          }
-          // No need to check for '\' here because that already causes normalization
-          if (prevChar == '/') {
-            normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
-          }
-          if (dotCount == 1 || dotCount == 2) {
-            normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
-          }
-          if (segmentHasShortPathChar) {
-            if (WindowsShortPath.isShortPath(path.substring(segmentBeginIndex, i))) {
-              normalizationLevel = Math.max(normalizationLevel, NEEDS_SHORT_PATH_NORMALIZATION);
-            }
-          }
-          segmentBeginIndex = i + 1;
-          segmentHasShortPathChar = false;
-        } else if (c == '~') {
-          // This path segment might be a Windows short path segment
-          segmentHasShortPathChar = true;
-        }
-        dotCount = c == '.' ? dotCount + 1 : 0;
-        prevChar = c;
-      }
-      if (prevChar == '/' || dotCount == 1 || dotCount == 2) {
-        normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
-      }
-      return normalizationLevel;
-    }
-
-    @Override
-    public String normalize(String path, int normalizationLevel) {
-      if (normalizationLevel == NORMALIZED) {
-        return path;
-      }
-      if (normalizationLevel == NEEDS_SHORT_PATH_NORMALIZATION) {
-        String resolvedPath = shortPathResolver.resolveShortPath(path);
-        if (resolvedPath != null) {
-          path = resolvedPath;
-        }
-      }
-      String[] segments = path.split("[\\\\/]+");
-      int driveStrLength = getDriveStrLength(path);
-      boolean isAbsolute = driveStrLength > 0;
-      int segmentSkipCount = isAbsolute ? 1 : 0;
-
-      StringBuilder sb = new StringBuilder(path.length());
-      if (isAbsolute) {
-        char driveLetter = path.charAt(0);
-        sb.append(Character.toUpperCase(driveLetter));
-        sb.append(":/");
-      }
-      // unix path support
-      if (!path.isEmpty() && path.charAt(0) == '/') {
-        if (path.length() == 2 || (path.length() > 2 && path.charAt(2) == '/')) {
-          sb.append(Character.toUpperCase(path.charAt(1)));
-          sb.append(":/");
-          segmentSkipCount = 2;
-        } else {
-          String unixRoot = getUnixRoot();
-          sb.append(unixRoot);
-        }
-      }
-      int segmentCount = removeRelativePaths(segments, segmentSkipCount);
-      for (int i = 0; i < segmentCount; ++i) {
-        sb.append(segments[i]);
-        sb.append('/');
-      }
-      if (segmentCount > 0) {
-        sb.deleteCharAt(sb.length() - 1);
-      }
-      return sb.toString();
-    }
-
-    @Override
-    public int getDriveStrLength(String path) {
-      int n = path.length();
-      if (n < 3) {
-        return 0;
-      }
-      if (isDriveLetter(path.charAt(0))
-          && path.charAt(1) == ':'
-          && (path.charAt(2) == '/' || path.charAt(2) == '\\')) {
-        return 3;
-      }
-      return 0;
-    }
-
-    private static boolean isDriveLetter(char c) {
-      return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'));
-    }
-
-    @Override
-    public int compare(String s1, String s2) {
-      // Windows is case-insensitive
-      return s1.compareToIgnoreCase(s2);
-    }
-
-    @Override
-    public int hashPath(String s) {
-      // Windows is case-insensitive
-      return s.toLowerCase().hashCode();
-    }
-
-    @Override
-    public boolean startsWith(String path, String prefix) {
-      int pathn = path.length();
-      int prefixn = prefix.length();
-      if (pathn < prefixn) {
-        return false;
-      }
-      for (int i = 0; i < prefixn; ++i) {
-        if (Character.toLowerCase(path.charAt(i)) != Character.toLowerCase(prefix.charAt(i))) {
-          return false;
-        }
-      }
-      return true;
-    }
-
-    @Override
-    public char getSeparator() {
-      return '/';
-    }
-
-    @Override
-    public boolean isCaseSensitive() {
-      return false;
-    }
-
-    private String getUnixRoot() {
-      String value = UNIX_ROOT.get();
-      if (value == null) {
-        String jvmFlag = "bazel.windows_unix_root";
-        value = determineUnixRoot(jvmFlag);
-        if (value == null) {
-          throw new IllegalStateException(
-              String.format(
-                  "\"%1$s\" JVM flag is not set. Use the --host_jvm_args flag or export the "
-                      + "BAZEL_SH environment variable. For example "
-                      + "\"--host_jvm_args=-D%1$s=c:/tools/msys64\" or "
-                      + "\"set BAZEL_SH=c:/tools/msys64/usr/bin/bash.exe\".",
-                  jvmFlag));
-        }
-        if (getDriveStrLength(value) != 3) {
-          throw new IllegalStateException(
-              String.format("\"%s\" must be an absolute path, got: \"%s\"", jvmFlag, value));
-        }
-        value = value.replace('\\', '/');
-        if (value.length() > 3 && value.endsWith("/")) {
-          value = value.substring(0, value.length() - 1);
-        }
-        UNIX_ROOT.set(value);
-      }
-      return value;
-    }
-
-    private String determineUnixRoot(String jvmArgName) {
-      // Get the path from a JVM flag, if specified.
-      String path = System.getProperty(jvmArgName);
-      if (path == null) {
-        return null;
-      }
-      path = path.trim();
-      if (path.isEmpty()) {
-        return null;
-      }
-      return path;
-    }
-  }
-
-  private static OsPathPolicy createFilePathOs() {
-    switch (OS.getCurrent()) {
-      case LINUX:
-      case FREEBSD:
-      case UNKNOWN:
-        return new UnixOsPathPolicy();
-      case DARWIN:
-        return new MacOsPathPolicy();
-      case WINDOWS:
-        return new WindowsOsPathPolicy();
-      default:
-        throw new AssertionError("Not covering all OSs");
-    }
-  }
-
-  /**
-   * Normalizes any '.' and '..' in-place in the segment array by shifting other segments to the
-   * front. Returns the remaining number of items.
-   */
-  private static int removeRelativePaths(String[] segments, int starti) {
-    int segmentCount = 0;
-    int shift = starti;
-    for (int i = starti; i < segments.length; ++i) {
-      String segment = segments[i];
-      switch (segment) {
-        case ".":
-          // Just discard it
-          ++shift;
-          break;
-        case "..":
-          if (segmentCount > 0 && !segments[segmentCount - 1].equals("..")) {
-            // Remove the last segment, if there is one and it is not "..". This
-            // means that the resulting path can still contain ".."
-            // segments at the beginning.
-            segmentCount--;
-            shift += 2;
-            break;
-          }
-          // Fall through
-        default:
-          ++segmentCount;
-          if (shift > 0) {
-            segments[i - shift] = segments[i];
-          }
-          break;
-      }
-    }
-    return segmentCount;
-  }
-}
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/OsPathPolicy.java b/src/main/java/com/google/devtools/build/lib/vfs/OsPathPolicy.java
new file mode 100644
index 0000000..6b0380f
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/vfs/OsPathPolicy.java
@@ -0,0 +1,144 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.vfs;
+
+import com.google.devtools.build.lib.util.OS;
+
+/**
+ * An interface class representing the differences in path style between different OSs.
+ *
+ * <p>Eg. case sensitivity, '/' mounts vs. 'C:/', etc.
+ */
+public interface OsPathPolicy {
+  int NORMALIZED = 0; // Path is normalized
+  int NEEDS_NORMALIZE = 1; // Path requires normalization
+
+  /** Returns required normalization level, passed to {@link #normalize}. */
+  int needsToNormalize(String path);
+
+  /**
+   * Returns the required normalization level if an already normalized string is concatenated with
+   * another normalized path fragment.
+   *
+   * <p>This method may be faster than {@link #needsToNormalize(String)}.
+   */
+  int needsToNormalizeSuffix(String normalizedSuffix);
+
+  /**
+   * Normalizes the passed string according to the passed normalization level.
+   *
+   * @param normalizationLevel The normalizationLevel from {@link #needsToNormalize}
+   */
+  String normalize(String path, int normalizationLevel);
+
+  /**
+   * Returns the length of the mount, eg. 1 for unix '/', 3 for Windows 'C:/'.
+   *
+   * <p>If the path is relative, 0 is returned
+   */
+  int getDriveStrLength(String path);
+
+  /** Compares two path strings, using the given OS case sensitivity. */
+  int compare(String s1, String s2);
+
+  /** Compares two characters, using the given OS case sensitivity. */
+  int compare(char c1, char c2);
+
+  /** Tests two path strings for equality, using the given OS case sensitivity. */
+  boolean equals(String s1, String s2);
+
+  /** Computes the hash code for a path string. */
+  int hash(String s);
+
+  /**
+   * Returns whether the passed string starts with the given prefix, given the OS case sensitivity.
+   *
+   * <p>This is a pure string operation and doesn't need to worry about matching path segments.
+   */
+  boolean startsWith(String path, String prefix);
+
+  /**
+   * Returns whether the passed string ends with the given prefix, given the OS case sensitivity.
+   *
+   * <p>This is a pure string operation and doesn't need to worry about matching path segments.
+   */
+  boolean endsWith(String path, String suffix);
+
+  /** Returns the separator used for normalized paths. */
+  char getSeparator();
+
+  /** Returns whether the unnormalized character c is a separator. */
+  boolean isSeparator(char c);
+
+  boolean isCaseSensitive();
+
+  static OsPathPolicy getFilePathOs() {
+    switch (OS.getCurrent()) {
+      case LINUX:
+      case FREEBSD:
+      case UNKNOWN:
+        return UnixOsPathPolicy.INSTANCE;
+      case DARWIN:
+        // NOTE: We *should* return a path policy that is case insensitive,
+        // but we currently don't handle this
+        return UnixOsPathPolicy.INSTANCE;
+      case WINDOWS:
+        return WindowsOsPathPolicy.INSTANCE;
+      default:
+        throw new AssertionError("Not covering all OSs");
+    }
+  }
+
+  /** Utilities for implementations of {@link OsPathPolicy}. */
+  class Utils {
+    /**
+     * Normalizes any '.' and '..' in-place in the segment array by shifting other segments to the
+     * front. Returns the remaining number of items.
+     */
+    static int removeRelativePaths(String[] segments, int starti, boolean isAbsolute) {
+      int segmentCount = 0;
+      int shift = starti;
+      int n = segments.length;
+      for (int i = starti; i < n; ++i) {
+        String segment = segments[i];
+        switch (segment) {
+          case ".":
+            ++shift;
+            break;
+          case "..":
+            if (segmentCount > 0 && !segments[segmentCount - 1].equals("..")) {
+              // Remove the last segment, if there is one and it is not "..". This
+              // means that the resulting path can still contain ".."
+              // segments at the beginning.
+              segmentCount--;
+              shift += 2;
+              break;
+            } else if (isAbsolute) {
+              // If this is absolute, then just pop it the ".." off and remain at root
+              ++shift;
+              break;
+            }
+            // Fall through
+          default:
+            ++segmentCount;
+            if (shift > 0) {
+              segments[i - shift] = segments[i];
+            }
+            break;
+        }
+      }
+      return segmentCount;
+    }
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/Path.java b/src/main/java/com/google/devtools/build/lib/vfs/Path.java
index 9549d25..075c47b 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/Path.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/Path.java
@@ -14,14 +14,14 @@
 package com.google.devtools.build.lib.vfs;
 
 import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
 import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodec;
+import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec;
 import com.google.devtools.build.lib.skyframe.serialization.SerializationException;
+import com.google.devtools.build.lib.skyframe.serialization.strings.StringCodecs;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkPrintable;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkPrinter;
 import com.google.devtools.build.lib.util.FileType;
-import com.google.devtools.build.lib.util.StringCanonicalizer;
 import com.google.devtools.build.lib.vfs.FileSystem.HashFunction;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
@@ -33,28 +33,29 @@
 import java.io.ObjectOutputStream;
 import java.io.OutputStream;
 import java.io.Serializable;
-import java.lang.ref.Reference;
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.WeakReference;
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.IdentityHashMap;
-import java.util.Objects;
+import javax.annotation.Nullable;
 
 /**
- * Instances of this class represent pathnames, forming a tree structure to implement sharing of
- * common prefixes (parent directory names). A node in these trees is something like foo, bar, ..,
- * ., or /. If the instance is not a root path, it will have a parent path. A path can also have
- * children, which are indexed by name in a map.
+ * A local file path representing a file on the host machine. You should use this when you want to
+ * access local files via the file system.
+ *
+ * <p>Paths are always absolute.
+ *
+ * <p>Strings are normalized with '.' and '..' removed and resolved (if possible), any multiple
+ * slashes ('/') removed, and any trailing slash also removed. Windows drive letters are uppercased.
+ * The current implementation does not touch the incoming path string unless the string actually
+ * needs to be normalized.
  *
  * <p>There is some limited support for Windows-style paths. Most importantly, drive identifiers in
- * front of a path (c:/abc) are supported. However, Windows-style backslash separators
- * (C:\\foo\\bar) and drive-relative paths ("C:foo") are explicitly not supported, same with
- * advanced features like \\\\network\\paths and \\\\?\\unc\\paths.
+ * front of a path (c:/abc) are supported and such paths are correctly recognized as absolute, as
+ * are paths with backslash separators (C:\\foo\\bar). However, advanced Windows-style features like
+ * \\\\network\\paths and \\\\?\\unc\\paths are not supported. We are currently using forward
+ * slashes ('/') even on Windows, so backslashes '\' get converted to forward slashes during
+ * normalization.
  *
- * <p>{@link FileSystem} implementations maintain pointers into this graph.
+ * <p>Mac and Windows file paths are case insensitive. Case is preserved.
  */
 @ThreadSafe
 public class Path
@@ -62,34 +63,6 @@
   public static final InjectingObjectCodec<Path, FileSystemProvider> CODEC =
       new PathCodecWithInjectedFileSystem();
 
-  /** Filesystem-specific factory for {@link Path} objects. */
-  public static interface PathFactory {
-    /**
-     * Creates the root of all paths used by a filesystem.
-     *
-     * <p>All other paths are instantiated via {@link Path#createChildPath(String)} which calls
-     * {@link #createChildPath(Path, String)}.
-     *
-     * <p>Beware: this is called during the FileSystem constructor which may occur before subclasses
-     * are completely initialized.
-     */
-    Path createRootPath(FileSystem filesystem);
-
-    /**
-     * Create a child path of the given parent.
-     *
-     * <p>All {@link Path} objects are instantiated via this method, with the sole exception of the
-     * filesystem root, which is created by {@link #createRootPath(FileSystem)}.
-     */
-    Path createChildPath(Path parent, String childName);
-
-    /**
-     * Makes the proper invocation of {@link FileSystem#getCachedChildPathInternal}, doing
-     * filesystem-specific logic if necessary.
-     */
-    Path getCachedChildPathInternal(Path path, String childName);
-  }
-
   private static FileSystem fileSystemForSerialization;
 
   /**
@@ -106,398 +79,279 @@
     return fileSystemForSerialization;
   }
 
-  // These are basically final, but can't be marked as such in order to support serialization.
+  private static final OsPathPolicy OS = OsPathPolicy.getFilePathOs();
+  private static final char SEPARATOR = OS.getSeparator();
+
+  private String path;
+  private int driveStrLength; // 1 on Unix, 3 on Windows
   private FileSystem fileSystem;
-  private String name;
-  private Path parent;
-  private int depth;
-  private int hashCode;
 
-  private static final ReferenceQueue<Path> REFERENCE_QUEUE = new ReferenceQueue<>();
-
-  private static class PathWeakReferenceForCleanup extends WeakReference<Path> {
-    final Path parent;
-    final String baseName;
-
-    PathWeakReferenceForCleanup(Path referent, ReferenceQueue<Path> referenceQueue) {
-      super(referent, referenceQueue);
-      parent = referent.getParentDirectory();
-      baseName = referent.getBaseName();
-    }
+  /** Creates a local path that is specific to the host OS. */
+  static Path create(String path, FileSystem fileSystem) {
+    Preconditions.checkNotNull(path);
+    int normalizationLevel = OS.needsToNormalize(path);
+    String normalizedPath = OS.normalize(path, normalizationLevel);
+    return createAlreadyNormalized(normalizedPath, fileSystem);
   }
 
-  private static final Thread PATH_CHILD_CACHE_CLEANUP_THREAD = new Thread("Path cache cleanup") {
-    @Override
-    public void run() {
-      while (true) {
-        try {
-          PathWeakReferenceForCleanup ref = (PathWeakReferenceForCleanup) REFERENCE_QUEUE.remove();
-          Path parent = ref.parent;
-          synchronized (parent) {
-            // It's possible that since this reference was enqueued for deletion, the Path was
-            // recreated with a new entry in the map. We definitely shouldn't delete that entry, so
-            // check to make sure they're the same.
-            Reference<Path> currentRef = ref.parent.children.get(ref.baseName);
-            if (currentRef == ref) {
-              ref.parent.children.remove(ref.baseName);
-            }
-          }
-        } catch (InterruptedException e) {
-          // Ignored.
-        }
-      }
-    }
-  };
-
-  static {
-    PATH_CHILD_CACHE_CLEANUP_THREAD.setDaemon(true);
-    PATH_CHILD_CACHE_CLEANUP_THREAD.start();
+  static Path createAlreadyNormalized(String path, FileSystem fileSystem) {
+    int driveStrLength = OS.getDriveStrLength(path);
+    return createAlreadyNormalized(path, driveStrLength, fileSystem);
   }
 
-  /**
-   * A mapping from a child file name to the {@link Path} representing it.
-   *
-   * <p>File names must be a single path segment.  The strings must be
-   * canonical.  We use IdentityHashMap instead of HashMap for reasons of space
-   * efficiency: instances are smaller by a single word.  Also, since all path
-   * segments are interned, the universe of Paths holds a minimal number of
-   * references to strings.  (It's doubtful that there's any time gain from use
-   * of an IdentityHashMap, since the time saved by avoiding string equality
-   * tests during hash lookups is probably equal to the time spent eagerly
-   * interning strings, unless the collision rate is high.)
-   *
-   * <p>The Paths are stored as weak references to ensure that a live
-   * Path for a directory does not hold a strong reference to all of its
-   * descendants, which would prevent collection of paths we never intend to
-   * use again.  Stale references in the map must be treated as absent.
-   *
-   * <p>A Path may be recycled once there is no Path that refers to it or
-   * to one of its descendants.  This means that any data stored in the
-   * Path instance by one of its subclasses must be recoverable: it's ok to
-   * store data in Paths as an optimization, but there must be another
-   * source for that data in case the Path is recycled.
-   *
-   * <p>We intentionally avoid using the existing library classes for reasons of
-   * space efficiency: while ConcurrentHashMap would reduce our locking
-   * overhead, and ReferenceMap would simplify the code a little, both of those
-   * classes have much higher per-instance overheads than IdentityHashMap.
-   *
-   * <p>The Path object must be synchronized while children is being
-   * accessed.
-   */
-  private volatile IdentityHashMap<String, Reference<Path>> children;
+  static Path createAlreadyNormalized(String path, int driveStrLength, FileSystem fileSystem) {
+    return new Path(path, driveStrLength, fileSystem);
+  }
 
-  /**
-   * Create a path instance.
-   *
-   * <p>Should only be called by {@link PathFactory#createChildPath(Path, String)}.
-   *
-   * @param name the name of this path; it must be canonicalized with {@link
-   *     StringCanonicalizer#intern}
-   * @param parent this path's parent
-   */
-  protected Path(FileSystem fileSystem, String name, Path parent) {
+  /** This method expects path to already be normalized. */
+  private Path(String path, int driveStrLength, FileSystem fileSystem) {
+    Preconditions.checkArgument(driveStrLength > 0, "Paths must be absolute: '%s'", path);
+    this.path = Preconditions.checkNotNull(path);
+    this.driveStrLength = driveStrLength;
     this.fileSystem = fileSystem;
-    this.name = name;
-    this.parent = parent;
-    this.depth = parent == null ? 0 : parent.depth + 1;
-
-    // No need to include the drive letter in the hash code, because it's derived from the parent
-    // and/or the name.
-    if (fileSystem == null || fileSystem.isFilePathCaseSensitive()) {
-      this.hashCode = Objects.hash(parent, name);
-    } else {
-      this.hashCode = Objects.hash(parent, name.toLowerCase());
-    }
   }
 
-  /**
-   * Create the root path.
-   *
-   * <p>Should only be called by {@link PathFactory#createRootPath(FileSystem)}.
-   */
-  protected Path(FileSystem fileSystem) {
-    this(fileSystem, StringCanonicalizer.intern("/"), null);
-  }
-
-  private void writeObject(ObjectOutputStream out) throws IOException {
-    Preconditions.checkState(
-        fileSystem == fileSystemForSerialization, "%s %s", fileSystem, fileSystemForSerialization);
-    out.writeUTF(getPathString());
-  }
-
-  private void readObject(ObjectInputStream in) throws IOException {
-    fileSystem = fileSystemForSerialization;
-    String p = in.readUTF();
-    PathFragment pf = PathFragment.create(p);
-    PathFragment parentDir = pf.getParentDirectory();
-    if (parentDir == null) {
-      this.name = "/";
-      this.parent = null;
-      this.depth = 0;
-    } else {
-      this.name = pf.getBaseName();
-      this.parent = fileSystem.getPath(parentDir);
-      this.depth = this.parent.depth + 1;
-    }
-    this.hashCode = Objects.hash(parent, name);
-    reinitializeAfterDeserialization();
-  }
-
-  /**
-   * Returns the filesystem instance to which this path belongs.
-   */
-  public FileSystem getFileSystem() {
-    return fileSystem;
-  }
-
-  public boolean isRootDirectory() {
-    return parent == null;
-  }
-
-  protected Path createChildPath(String childName) {
-    return fileSystem.getPathFactory().createChildPath(this, childName);
-  }
-
-  /**
-   * Reinitializes this object after deserialization.
-   *
-   * <p>Derived classes should use this hook to initialize additional state.
-   */
-  protected void reinitializeAfterDeserialization() {}
-
-  /**
-   * Returns true if {@code ancestorPath} may be an ancestor of {@code path}.
-   *
-   * <p>The return value may be a false positive, but it cannot be a false negative. This means that
-   * a true return value doesn't mean the ancestor candidate is really an ancestor, however a false
-   * return value means it's guaranteed that {@code ancestorCandidate} is not an ancestor of this
-   * path.
-   *
-   * <p>Subclasses may override this method with filesystem-specific logic, e.g. a Windows
-   * filesystem may return false if the ancestor path is on a different drive than this one, because
-   * it is then guaranteed that the ancestor candidate cannot be an ancestor of this path.
-   *
-   * @param ancestorCandidate the path that may or may not be an ancestor of this one
-   */
-  protected boolean isMaybeRelativeTo(Path ancestorCandidate) {
-    return true;
-  }
-
-  /**
-   * Returns true if this directory is top-level, i.e. it is its own parent.
-   *
-   * <p>When canonicalizing paths the ".." segment of a top-level directory always resolves to the
-   * directory itself.
-   *
-   * <p>On Unix, a top-level directory would be just the filesystem root ("/), on Windows it would
-   * be the filesystem root and the volume roots.
-   */
-  protected boolean isTopLevelDirectory() {
-    return isRootDirectory();
-  }
-
-  /**
-   * Returns the child path named name, or creates such a path (and caches it)
-   * if it doesn't already exist.
-   */
-  private Path getCachedChildPath(String childName) {
-    return fileSystem.getPathFactory().getCachedChildPathInternal(this, childName);
-  }
-
-  /**
-   * Internal method only intended to be called by {@link PathFactory#getCachedChildPathInternal}.
-   */
-  public static Path getCachedChildPathInternal(Path parent, String childName, boolean cacheable) {
-    // We get a canonical instance since 'children' is an IdentityHashMap.
-    childName = StringCanonicalizer.intern(childName);
-    if (!cacheable) {
-      // Non-cacheable children won't show up in `children` so applyToChildren won't run for these.
-      return parent.createChildPath(childName);
-    }
-
-    synchronized (parent) {
-      if (parent.children == null) {
-        // 66% of Paths have size == 1, 80% <= 2
-        parent.children = new IdentityHashMap<>(1);
-      }
-      Reference<Path> childRef = parent.children.get(childName);
-      Path child;
-      if (childRef == null || (child = childRef.get()) == null) {
-        child = parent.createChildPath(childName);
-        parent.children.put(childName, new PathWeakReferenceForCleanup(child, REFERENCE_QUEUE));
-      }
-      return child;
-    }
-  }
-
-  /**
-   * Applies the specified function to each {@link Path} that is an existing direct
-   * descendant of this one.  The Predicate is evaluated only for its
-   * side-effects.
-   *
-   * <p>This function exists to hide the "children" field, whose complex
-   * synchronization and identity requirements are too unsafe to be exposed to
-   * subclasses.  For example, the "children" field must be synchronized for
-   * the duration of any iteration over it; it may be null; and references
-   * within it may be stale, and must be ignored.
-   */
-  protected synchronized void applyToChildren(Predicate<Path> function) {
-    if (children != null) {
-      for (Reference<Path> childRef : children.values()) {
-        Path child = childRef.get();
-        if (child != null) {
-          function.apply(child);
-        }
-      }
-    }
-  }
-
-  /**
-   * Returns whether this path is recursively "under" {@code prefix} - that is,
-   * whether {@code path} is a prefix of this path.
-   *
-   * <p>This method returns {@code true} when called with this path itself. This
-   * method acts independently of the existence of files or folders.
-   *
-   * @param prefix a path which may or may not be a prefix of this path
-   */
-  public boolean startsWith(Path prefix) {
-    Path n = this;
-    for (int i = 0, len = depth - prefix.depth; i < len; i++) {
-      n = n.getParentDirectory();
-    }
-    return prefix.equals(n);
-  }
-
-  /**
-   * Computes a string representation of this path, and writes it to the given string builder. Only
-   * called locally with a new instance.
-   */
-  protected void buildPathString(StringBuilder result) {
-    if (isRootDirectory()) {
-      result.append(PathFragment.ROOT_DIR);
-    } else {
-      parent.buildPathString(result);
-      if (!parent.isRootDirectory()) {
-        result.append(PathFragment.SEPARATOR_CHAR);
-      }
-      result.append(name);
-    }
-  }
-
-  /**
-   * Returns the path encoded as an {@link URI}.
-   *
-   * <p>This concrete implementation returns URIs with "file" as the scheme.
-   * For Example:
-   *  - On Unix the path "/tmp/foo bar.txt" will be encoded as
-   *    "file:///tmp/foo%20bar.txt".
-   *  - On Windows the path "C:\Temp\Foo Bar.txt" will be encoded as
-   *    "file:///C:/Temp/Foo%20Bar.txt"
-   *
-   * <p>Implementors extending this class for special filesystems will likely need to override
-   * this method.
-   *
-   * @throws URISyntaxException if the URI cannot be constructed.
-   */
-  public URI toURI() {
-    String ps = getPathString();
-    if (!ps.startsWith("/")) {
-      // On Windows URI's need to start with a '/'. i.e. C:\Foo\Bar would be file:///C:/Foo/Bar
-      ps = "/" + ps;
-    }
-    try {
-      return new URI("file",
-          // Needs to be "" instead of null, so that toString() will append "//" after the scheme.
-          // We need this for backwards compatibility reasons as some consumers of the BEP are
-          // broken.
-          "",
-          ps, null, null);
-    } catch (URISyntaxException e) {
-      throw new IllegalStateException(e);
-    }
-  }
-
-  /**
-   * Returns the path as a string.
-   */
   public String getPathString() {
-    // Profile driven optimization:
-    // Preallocate a size determined by the depth, so that
-    // we do not have to expand the capacity of the StringBuilder
-    StringBuilder builder = new StringBuilder(depth * 20);
-    buildPathString(builder);
-    return builder.toString();
-  }
-
-  @Override
-  public void repr(SkylarkPrinter printer) {
-    printer.append(getPathString());
+    return path;
   }
 
   @Override
   public String filePathForFileTypeMatcher() {
-    return name;
+    return path;
   }
 
   /**
-   * Returns the path as a string.
+   * Returns the name of the leaf file or directory.
+   *
+   * <p>If called on a {@link Path} instance for a mount name (eg. '/' or 'C:/'), the empty string
+   * is returned.
    */
+  public String getBaseName() {
+    int lastSeparator = path.lastIndexOf(SEPARATOR);
+    return lastSeparator < driveStrLength
+        ? path.substring(driveStrLength)
+        : path.substring(lastSeparator + 1);
+  }
+
+  /** Synonymous with {@link Path#getRelative(String)}. */
+  public Path getChild(String child) {
+    FileSystemUtils.checkBaseName(child);
+    return getRelative(child);
+  }
+
+  /**
+   * Returns a {@link Path} instance representing the relative path between this {@link Path} and
+   * the given path.
+   */
+  public Path getRelative(PathFragment other) {
+    Preconditions.checkNotNull(other);
+    String otherStr = other.getPathString();
+    // Fast-path: The path fragment is already normal, use cheaper normalization check
+    return getRelative(otherStr, other.getDriveStrLength(), OS.needsToNormalizeSuffix(otherStr));
+  }
+
+  /**
+   * Returns a {@link Path} instance representing the relative path between this {@link Path} and
+   * the given path.
+   */
+  public Path getRelative(String other) {
+    Preconditions.checkNotNull(other);
+    return getRelative(other, OS.getDriveStrLength(other), OS.needsToNormalize(other));
+  }
+
+  private Path getRelative(String other, int otherDriveStrLength, int normalizationLevel) {
+    if (other.isEmpty()) {
+      return this;
+    }
+    // This is an absolute path, simply return it
+    if (otherDriveStrLength > 0) {
+      String normalizedPath = OS.normalize(other, normalizationLevel);
+      return new Path(normalizedPath, otherDriveStrLength, fileSystem);
+    }
+    String newPath;
+    if (path.length() == driveStrLength) {
+      newPath = path + other;
+    } else {
+      newPath = path + '/' + other;
+    }
+    // Note that even if other came from a PathFragment instance we still might
+    // need to normalize the result if (for instance) other is a path that
+    // starts with '..'
+    newPath = OS.normalize(newPath, normalizationLevel);
+    return new Path(newPath, driveStrLength, fileSystem);
+  }
+
+  /**
+   * Returns the parent directory of this {@link Path}.
+   *
+   * <p>If called on a root (like '/'), it returns null.
+   */
+  @Nullable
+  public Path getParentDirectory() {
+    int lastSeparator = path.lastIndexOf(SEPARATOR);
+    if (lastSeparator < driveStrLength) {
+      if (path.length() > driveStrLength) {
+        String newPath = path.substring(0, driveStrLength);
+        return new Path(newPath, driveStrLength, fileSystem);
+      } else {
+        return null;
+      }
+    }
+    String newPath = path.substring(0, lastSeparator);
+    return new Path(newPath, driveStrLength, fileSystem);
+  }
+
+  /**
+   * Returns the drive.
+   *
+   * <p>On unix, this will return "/". On Windows it will return the drive letter, like "C:/".
+   */
+  public String getDriveStr() {
+    return path.substring(0, driveStrLength);
+  }
+
+  /**
+   * Returns the {@link Path} relative to the base {@link Path}.
+   *
+   * <p>For example, <code>Path.create("foo/bar/wiz").relativeTo(Path.create("foo"))
+   * </code> returns <code>Path.create("bar/wiz")</code>.
+   *
+   * <p>If the {@link Path} is not a child of the passed {@link Path} an {@link
+   * IllegalArgumentException} is thrown. In particular, this will happen whenever the two {@link
+   * Path} instances aren't both absolute or both relative.
+   */
+  public PathFragment relativeTo(Path base) {
+    Preconditions.checkNotNull(base);
+    checkSameFileSystem(base);
+    String basePath = base.path;
+    if (!OS.startsWith(path, basePath)) {
+      throw new IllegalArgumentException(
+          String.format("Path '%s' is not under '%s', cannot relativize", this, base));
+    }
+    int bn = basePath.length();
+    if (bn == 0) {
+      return PathFragment.createAlreadyNormalized(path, driveStrLength);
+    }
+    if (path.length() == bn) {
+      return PathFragment.EMPTY_FRAGMENT;
+    }
+    final int lastSlashIndex;
+    if (basePath.charAt(bn - 1) == '/') {
+      lastSlashIndex = bn - 1;
+    } else {
+      lastSlashIndex = bn;
+    }
+    if (path.charAt(lastSlashIndex) != '/') {
+      throw new IllegalArgumentException(
+          String.format("Path '%s' is not under '%s', cannot relativize", this, base));
+    }
+    String newPath = path.substring(lastSlashIndex + 1);
+    return PathFragment.createAlreadyNormalized(newPath, 0);
+  }
+
+  /**
+   * Returns whether this path is an ancestor of another path.
+   *
+   * <p>A path is considered an ancestor of itself.
+   */
+  public boolean startsWith(Path other) {
+    if (fileSystem != other.fileSystem) {
+      return false;
+    }
+    return startsWith(other.path, other.driveStrLength);
+  }
+
+  /**
+   * Returns whether this path is an ancestor of another path.
+   *
+   * <p>A path is considered an ancestor of itself.
+   *
+   * <p>An absolute path can never be an ancestor of a relative path fragment.
+   */
+  public boolean startsWith(PathFragment other) {
+    if (!other.isAbsolute()) {
+      return false;
+    }
+    String otherPath = other.getPathString();
+    return startsWith(otherPath, OS.getDriveStrLength(otherPath));
+  }
+
+  private boolean startsWith(String otherPath, int otherDriveStrLength) {
+    Preconditions.checkNotNull(otherPath);
+    if (otherPath.length() > path.length()) {
+      return false;
+    }
+    if (driveStrLength != otherDriveStrLength) {
+      return false;
+    }
+    if (!OS.startsWith(path, otherPath)) {
+      return false;
+    }
+    return path.length() == otherPath.length() // Handle equal paths
+        || otherPath.length() == driveStrLength // Handle (eg.) 'C:/foo' starts with 'C:/'
+        // Handle 'true' ancestors, eg. "foo/bar" starts with "foo", but does not start with "fo"
+        || path.charAt(otherPath.length()) == SEPARATOR;
+  }
+
+  public FileSystem getFileSystem() {
+    return fileSystem;
+  }
+
+  public PathFragment asFragment() {
+    return PathFragment.createAlreadyNormalized(path, driveStrLength);
+  }
+
   @Override
   public String toString() {
-    return getPathString();
+    return path;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    Path other = (Path) o;
+    if (fileSystem != other.fileSystem) {
+      return false;
+    }
+    return OS.equals(this.path, other.path);
   }
 
   @Override
   public int hashCode() {
-    return hashCode;
+    // Do not include file system for efficiency.
+    // In practice we never construct paths from different file systems.
+    return OS.hash(this.path);
   }
 
   @Override
-  public boolean equals(Object other) {
-    if (this == other) {
-      return true;
+  public int compareTo(Path o) {
+    // If they are on different file systems, the file system decides the ordering.
+    FileSystem otherFs = o.getFileSystem();
+    if (!fileSystem.equals(otherFs)) {
+      int thisFileSystemHash = System.identityHashCode(fileSystem);
+      int otherFileSystemHash = System.identityHashCode(otherFs);
+      if (thisFileSystemHash < otherFileSystemHash) {
+        return -1;
+      } else if (thisFileSystemHash > otherFileSystemHash) {
+        return 1;
+      }
     }
-    if (!(other instanceof Path)) {
-      return false;
-    }
-
-    Path otherPath = (Path) other;
-    if (hashCode != otherPath.hashCode) {
-      return false;
-    }
-
-    if (!fileSystem.equals(otherPath.fileSystem)) {
-      return false;
-    }
-
-    if (fileSystem.isFilePathCaseSensitive()) {
-      return name.equals(otherPath.name)
-          && Objects.equals(parent, otherPath.parent);
-    } else {
-      return name.toLowerCase().equals(otherPath.name.toLowerCase())
-          && Objects.equals(parent, otherPath.parent);
-    }
+    return OS.compare(this.path, o.path);
   }
 
-  /**
-   * Returns a string of debugging information associated with this path.
-   * The results are unspecified and MUST NOT be interpreted programmatically.
-   */
-  protected String toDebugString() {
-    return "";
+  @Override
+  public void repr(SkylarkPrinter printer) {
+    printer.append(path);
   }
 
-  /**
-   * Returns a path representing the parent directory of this path,
-   * or null iff this Path represents the root of the filesystem.
-   *
-   * <p>Note: This method normalises ".."  and "." path segments by string
-   * processing, not by directory lookups.
-   */
-  public Path getParentDirectory() {
-    return parent;
+  @Override
+  public void str(SkylarkPrinter printer) {
+    repr(printer);
   }
 
   /** Returns true iff this path denotes an existing file of any kind. Follows symbolic links. */
@@ -662,157 +516,6 @@
   }
 
   /**
-   * Returns the last segment of this path, or "/" for the root directory.
-   */
-  public String getBaseName() {
-    return name;
-  }
-
-  /**
-   * Interprets the name of a path segment relative to the current path and
-   * returns the result.
-   *
-   * <p>This is a purely syntactic operation, i.e. it does no I/O, it does not
-   * validate the existence of any path, nor resolve symbolic links. If 'prefix'
-   * is not canonical, then a 'name' of '..' will be interpreted incorrectly.
-   *
-   * @precondition segment contains no slashes.
-   */
-  private Path getCanonicalPath(String segment) {
-    if (segment.equals(".") || segment.isEmpty()) {
-      return this; // that's a noop
-    } else if (segment.equals("..")) {
-      // top-level directory's parent is root, when canonicalising:
-      return isTopLevelDirectory() ? this : parent;
-    } else {
-      return getCachedChildPath(segment);
-    }
-  }
-
-  /**
-   * Returns the path formed by appending the single non-special segment
-   * "baseName" to this path.
-   *
-   * <p>You should almost always use {@link #getRelative} instead, which has
-   * the same performance characteristics if the given name is a valid base
-   * name, and which also works for '.', '..', and strings containing '/'.
-   *
-   * @throws IllegalArgumentException if {@code baseName} is not a valid base
-   *     name according to {@link FileSystemUtils#checkBaseName}
-   */
-  public Path getChild(String baseName) {
-    FileSystemUtils.checkBaseName(baseName);
-    return getCachedChildPath(baseName);
-  }
-
-  protected Path getRootForRelativePathComputation(PathFragment suffix) {
-    return suffix.isAbsolute() ? fileSystem.getRootDirectory() : this;
-  }
-
-  /**
-   * Returns the path formed by appending the relative or absolute path fragment
-   * {@code suffix} to this path.
-   *
-   * <p>If suffix is absolute, the current path will be ignored; otherwise, they
-   * will be combined. Up-level references ("..") cause the preceding path
-   * segment to be elided; this interpretation is only correct if the base path
-   * is canonical.
-   */
-  public Path getRelative(PathFragment suffix) {
-    Path result = getRootForRelativePathComputation(suffix);
-    for (String segment : suffix.segments()) {
-      result = result.getCanonicalPath(segment);
-    }
-    return result;
-  }
-
-  /**
-   * Returns the path formed by appending the relative or absolute string
-   * {@code path} to this path.
-   *
-   * <p>If the given path string is absolute, the current path will be ignored;
-   * otherwise, they will be combined. Up-level references ("..") cause the
-   * preceding path segment to be elided.
-   *
-   * <p>This is a purely syntactic operation, i.e. it does no I/O, it does not
-   * validate the existence of any path, nor resolve symbolic links.
-   */
-  public Path getRelative(String path) {
-    // Fast path for valid base names.
-    if ((path.length() == 0) || (path.equals("."))) {
-      return this;
-    } else if (path.equals("..")) {
-      return isTopLevelDirectory() ? this : parent;
-    } else if (PathFragment.containsSeparator(path)) {
-      return getRelative(PathFragment.create(path));
-    } else {
-      return getCachedChildPath(path);
-    }
-  }
-
-  protected final String[] getSegments() {
-    String[] resultSegments = new String[depth];
-    Path currentPath = this;
-    for (int pos = depth - 1; pos >= 0; pos--) {
-      resultSegments[pos] = currentPath.getBaseName();
-      currentPath = currentPath.getParentDirectory();
-    }
-    return resultSegments;
-  }
-
-  /** Returns an absolute PathFragment representing this path. */
-  public PathFragment asFragment() {
-    return PathFragment.createAlreadyInterned('\0', true, getSegments());
-  }
-
-  /**
-   * Returns a relative path fragment to this path, relative to {@code
-   * ancestorDirectory}. {@code ancestorDirectory} must be on the same
-   * filesystem as this path. (Currently, both this path and "ancestorDirectory"
-   * must be absolute, though this restriction could be loosened.)
-   * <p>
-   * <code>x.relativeTo(z) == y</code> implies
-   * <code>z.getRelative(y.getPathString()) == x</code>.
-   * <p>
-   * For example, <code>"/foo/bar/wiz".relativeTo("/foo")</code> returns
-   * <code>"bar/wiz"</code>.
-   *
-   * @throws IllegalArgumentException if this path is not beneath {@code
-   *         ancestorDirectory} or if they are not part of the same filesystem
-   */
-  public PathFragment relativeTo(Path ancestorPath) {
-    checkSameFilesystem(ancestorPath);
-
-    if (isMaybeRelativeTo(ancestorPath)) {
-      // Fast path: when otherPath is the ancestor of this path
-      int resultSegmentCount = depth - ancestorPath.depth;
-      if (resultSegmentCount >= 0) {
-        String[] resultSegments = new String[resultSegmentCount];
-        Path currentPath = this;
-        for (int pos = resultSegmentCount - 1; pos >= 0; pos--) {
-          resultSegments[pos] = currentPath.getBaseName();
-          currentPath = currentPath.getParentDirectory();
-        }
-        if (ancestorPath.equals(currentPath)) {
-          return PathFragment.createAlreadyInterned('\0', false, resultSegments);
-        }
-      }
-    }
-
-    throw new IllegalArgumentException("Path " + this + " is not beneath " + ancestorPath);
-  }
-
-  /**
-   * Checks that "this" and "that" are paths on the same filesystem.
-   */
-  protected void checkSameFilesystem(Path that) {
-    if (this.fileSystem != that.fileSystem) {
-      throw new IllegalArgumentException("Files are on different filesystems: "
-          + this + ", " + that);
-    }
-  }
-
-  /**
    * Returns an output stream to the file denoted by the current path, creating it and truncating it
    * if necessary. The stream is opened for writing.
    *
@@ -868,7 +571,7 @@
    * @throws IOException if the creation of the symbolic link was unsuccessful for any reason
    */
   public void createSymbolicLink(Path target) throws IOException {
-    checkSameFilesystem(target);
+    checkSameFileSystem(target);
     fileSystem.createSymbolicLink(this, target.asFragment());
   }
 
@@ -943,7 +646,7 @@
    * @throws IOException if the rename failed for any reason
    */
   public void renameTo(Path target) throws IOException {
-    checkSameFilesystem(target);
+    checkSameFileSystem(target);
     fileSystem.renameTo(this, target);
   }
 
@@ -1183,69 +886,28 @@
     fileSystem.prefetchPackageAsync(this, maxDirs);
   }
 
-  /**
-   * Compare Paths of the same file system using their PathFragments.
-   *
-   * <p>Paths from different filesystems will be compared using the identity
-   * hash code of their respective filesystems.
-   */
-  @Override
-  public int compareTo(Path o) {
-    // Fast-path.
-    if (equals(o)) {
-      return 0;
+  private void checkSameFileSystem(Path that) {
+    if (this.fileSystem != that.fileSystem) {
+      throw new IllegalArgumentException(
+          "Files are on different filesystems: " + this + ", " + that);
     }
+  }
 
-    // If they are on different file systems, the file system decides the ordering.
-    FileSystem otherFs = o.getFileSystem();
-    if (!fileSystem.equals(otherFs)) {
-      int thisFileSystemHash = System.identityHashCode(fileSystem);
-      int otherFileSystemHash = System.identityHashCode(otherFs);
-      if (thisFileSystemHash < otherFileSystemHash) {
-        return -1;
-      } else if (thisFileSystemHash > otherFileSystemHash) {
-        return 1;
-      } else {
-        // TODO(bazel-team): Add a name to every file system to be used here.
-        return 0;
-      }
-    }
+  private void writeObject(ObjectOutputStream out) throws IOException {
+    Preconditions.checkState(
+        fileSystem == fileSystemForSerialization, "%s %s", fileSystem, fileSystemForSerialization);
+    out.writeUTF(path);
+  }
 
-    // Equal file system, but different paths, because of the canonicalization.
-    // We expect to often compare Paths that are very similar, for example for files in the same
-    // directory. This can be done efficiently by going up segment by segment until we get the
-    // identical path (canonicalization again), and then just compare the immediate child segments.
-    // Overall this is much faster than creating PathFragment instances, and comparing those, which
-    // requires us to always go up to the top-level directory and copy all segments into a new
-    // string array.
-    // This was previously showing up as a hotspot in a profile of globbing a large directory.
-    Path a = this;
-    Path b = o;
-    int maxDepth = Math.min(a.depth, b.depth);
-    while (a.depth > maxDepth) {
-      a = a.getParentDirectory();
-    }
-    while (b.depth > maxDepth) {
-      b = b.getParentDirectory();
-    }
-    // One is the child of the other.
-    if (a.equals(b)) {
-      // If a is the same as this, this.depth must be less than o.depth.
-      return equals(a) ? -1 : 1;
-    }
-    Path previousa;
-    Path previousb;
-    do {
-      previousa = a;
-      previousb = b;
-      a = a.getParentDirectory();
-      b = b.getParentDirectory();
-    } while (!a.equals(b)); // This has to happen eventually.
-    return previousa.name.compareTo(previousb.name);
+  private void readObject(ObjectInputStream in) throws IOException {
+    path = in.readUTF();
+    fileSystem = fileSystemForSerialization;
+    driveStrLength = OS.getDriveStrLength(path);
   }
 
   private static class PathCodecWithInjectedFileSystem
       implements InjectingObjectCodec<Path, FileSystemProvider> {
+    private final ObjectCodec<String> stringCodec = StringCodecs.asciiOptimized();
 
     @Override
     public Class<Path> getEncodedClass() {
@@ -1256,14 +918,14 @@
     public void serialize(FileSystemProvider fsProvider, Path path, CodedOutputStream codedOut)
         throws IOException, SerializationException {
       Preconditions.checkArgument(path.getFileSystem() == fsProvider.getFileSystem());
-      PathFragment.CODEC.serialize(path.asFragment(), codedOut);
+      stringCodec.serialize(path.getPathString(), codedOut);
     }
 
     @Override
     public Path deserialize(FileSystemProvider fsProvider, CodedInputStream codedIn)
         throws IOException, SerializationException {
-      PathFragment pathFragment = PathFragment.CODEC.deserialize(codedIn);
-      return fsProvider.getFileSystem().getPath(pathFragment);
+      return Path.createAlreadyNormalized(
+          stringCodec.deserialize(codedIn), fsProvider.getFileSystem());
     }
   }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/PathCodec.java b/src/main/java/com/google/devtools/build/lib/vfs/PathCodec.java
index ee0ef36..c7644ed 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/PathCodec.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/PathCodec.java
@@ -17,6 +17,7 @@
 import com.google.common.base.Preconditions;
 import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec;
 import com.google.devtools.build.lib.skyframe.serialization.SerializationException;
+import com.google.devtools.build.lib.skyframe.serialization.strings.StringCodecs;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import java.io.IOException;
@@ -24,6 +25,7 @@
 /** Custom serialization for {@link Path}s. */
 public class PathCodec implements ObjectCodec<Path> {
 
+  private final ObjectCodec<String> stringCodec = StringCodecs.asciiOptimized();
   private final FileSystem fileSystem;
 
   /** Create an instance for serializing and deserializing {@link Path}s on {@code fileSystem}. */
@@ -41,15 +43,15 @@
       throws IOException, SerializationException {
     Preconditions.checkState(
         path.getFileSystem() == fileSystem,
-        "Path's FileSystem (%s) did not match the configured FileSystem (%s)",
+        "Path's FileSystem (%s) did not match the configured FileSystem (%s) for path (%s)",
         path.getFileSystem(),
-        fileSystem);
-    PathFragment.CODEC.serialize(path.asFragment(), codedOut);
+        fileSystem,
+        path);
+    stringCodec.serialize(path.getPathString(), codedOut);
   }
 
   @Override
   public Path deserialize(CodedInputStream codedIn) throws IOException, SerializationException {
-    PathFragment pathFragment = PathFragment.CODEC.deserialize(codedIn);
-    return fileSystem.getPath(pathFragment);
+    return fileSystem.getPath(stringCodec.deserialize(codedIn));
   }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/PathFragment.java b/src/main/java/com/google/devtools/build/lib/vfs/PathFragment.java
index 572042a..88ae732 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/PathFragment.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/PathFragment.java
@@ -1,4 +1,4 @@
-// Copyright 2014 The Bazel Authors. All rights reserved.
+// Copyright 2017 The Bazel Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,288 +16,517 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.devtools.build.lib.analysis.actions.CommandLineItem;
-import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
-import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
 import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec;
 import com.google.devtools.build.lib.skyframe.serialization.SerializationException;
 import com.google.devtools.build.lib.skyframe.serialization.strings.StringCodecs;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkPrintable;
 import com.google.devtools.build.lib.skylarkinterface.SkylarkPrinter;
 import com.google.devtools.build.lib.util.FileType;
-import com.google.devtools.build.lib.util.OS;
-import com.google.devtools.build.lib.util.StringCanonicalizer;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import java.io.File;
 import java.io.IOException;
-import java.io.InvalidObjectException;
-import java.io.ObjectInputStream;
 import java.io.Serializable;
-import java.util.Arrays;
-import java.util.List;
 import java.util.Set;
+import javax.annotation.Nullable;
 
 /**
- * This class represents an immutable filesystem path, which may be absolute or relative. The path
- * is maintained as a simple ordered list of path segment strings.
+ * A path segment representing a path fragment using the host machine's path style. That is; If you
+ * are running on a Unix machine, the path style will be unix, on Windows it is the windows path
+ * style.
  *
- * <p>This class is independent from other VFS classes, especially anything requiring native code.
- * It is safe to use in places that need simple segmented string path functionality.
+ * <p>Path fragments are either absolute or relative.
+ *
+ * <p>Strings are normalized with '.' and '..' removed and resolved (if possible), any multiple
+ * slashes ('/') removed, and any trailing slash also removed. Windows drive letters are uppercased.
+ * The current implementation does not touch the incoming path string unless the string actually
+ * needs to be normalized.
  *
  * <p>There is some limited support for Windows-style paths. Most importantly, drive identifiers in
  * front of a path (c:/abc) are supported and such paths are correctly recognized as absolute, as
  * are paths with backslash separators (C:\\foo\\bar). However, advanced Windows-style features like
- * \\\\network\\paths and \\\\?\\unc\\paths are not supported.
+ * \\\\network\\paths and \\\\?\\unc\\paths are not supported. We are currently using forward
+ * slashes ('/') even on Windows.
+ *
+ * <p>Mac and Windows path fragments are case insensitive.
  */
-@Immutable
-@javax.annotation.concurrent.Immutable
-@ThreadSafe
-public abstract class PathFragment
+public final class PathFragment
     implements Comparable<PathFragment>,
         Serializable,
-        SkylarkPrintable,
         FileType.HasFileType,
+        SkylarkPrintable,
         CommandLineItem {
-  private static final Helper HELPER =
-      OS.getCurrent() == OS.WINDOWS ? WindowsPathFragment.HELPER : UnixPathFragment.HELPER;
+  private static final OsPathPolicy OS = OsPathPolicy.getFilePathOs();
 
-  public static final char SEPARATOR_CHAR = HELPER.getPrimarySeparatorChar();
-
+  public static final PathFragment EMPTY_FRAGMENT = create("");
+  public static final char SEPARATOR_CHAR = OS.getSeparator();
   public static final int INVALID_SEGMENT = -1;
 
-  public static final String ROOT_DIR = "/";
-
-  /** An empty path fragment. */
-  public static final PathFragment EMPTY_FRAGMENT = create("");
-
-  /** The path fragment representing the root directory. */
-  public static final PathFragment ROOT_FRAGMENT = create(ROOT_DIR);
+  private final String path;
+  private final int driveStrLength; // 0 for relative paths, 1 on Unix, 3 on Windows
 
   public static final ObjectCodec<PathFragment> CODEC = new PathFragmentCodec();
 
-  /**
-   * A helper object for manipulating the various internal {@link PathFragment} implementations.
-   *
-   * <p>There will be exactly one {@link Helper} instance used to manipulate all the {@link
-   * PathFragment} instances (see {@link PathFragment#HELPER}). All of the various {@link Helper}
-   * and {@link PathFragment} implementations may assume this property.
-   */
-  protected abstract static class Helper {
-    /**
-     * Returns whether the two given arrays of segments have the same length and should be
-     * considered have logically equal contents.
-     */
-    protected final boolean segmentsEqual(String[] segments1, String[] segments2) {
-      return segments1.length == segments2.length
-          && segmentsEqual(segments1.length, segments1, 0, segments2);
-    }
-
-    /**
-     * Returns whether the {@code length} segments in {@code segments1}, starting at {@code offset1}
-     * should be considered to be logically equal to the first {@code length} segments in {@code
-     * segments2}.
-     */
-    abstract boolean segmentsEqual(int length, String[] segments1, int offset1, String[] segments2);
-
-    /** Returns the comparison result of two {@link PathFragment} instances. */
-    protected abstract int compare(PathFragment pathFragment1, PathFragment pathFragment2);
-
-    /** Returns a fresh {@link PathFragment} instance from the given path string. */
-    abstract PathFragment create(String path);
-    /**
-     * Returns a fresh {@link PathFragment} instance from the given information, taking ownership of
-     * {@code segments} and assuming the {@link String}s within have already been interned.
-     */
-    abstract PathFragment createAlreadyInterned(
-        char driveLetter, boolean isAbsolute, String[] segments);
-
-    /** Returns whether {@code c} is a path separator. */
-    abstract boolean isSeparator(char c);
-    /** Returns the primary path separator. */
-    abstract char getPrimarySeparatorChar();
-    /** Return whether the given {@code path} contains a path separator. */
-    abstract boolean containsSeparatorChar(String path);
-
-    /**
-     * Splits the given {@code toSegment} into path segments, starting at the given {@code offset}.
-     */
-    protected final String[] segment(String toSegment, int offset) {
-      int length = toSegment.length();
-
-      // We make two passes through the array of characters: count & alloc,
-      // because simply using ArrayList was a bottleneck showing up during profiling.
-      int seg = 0;
-      int start = offset;
-      for (int i = offset; i < length; i++) {
-        if (isSeparator(toSegment.charAt(i))) {
-          if (i > start) { // to skip repeated separators
-            seg++;
-          }
-          start = i + 1;
-        }
-      }
-      if (start < length) {
-        seg++;
-      }
-      String[] result = new String[seg];
-      seg = 0;
-      start = offset;
-      for (int i = offset; i < length; i++) {
-        if (isSeparator(toSegment.charAt(i))) {
-          if (i > start) { // to skip repeated separators
-            result[seg] = StringCanonicalizer.intern(toSegment.substring(start, i));
-            seg++;
-          }
-          start = i + 1;
-        }
-      }
-      if (start < length) {
-        result[seg] = StringCanonicalizer.intern(toSegment.substring(start, length));
-      }
-      return result;
-    }
-  }
-
-  /** Lower-level API. Create a PathFragment, interning segments. */
-  public static PathFragment create(char driveLetter, boolean isAbsolute, String[] segments) {
-    String[] internedSegments = new String[segments.length];
-    for (int i = 0; i < segments.length; i++) {
-      internedSegments[i] = StringCanonicalizer.intern(segments[i]);
-    }
-    return createAlreadyInterned(driveLetter, isAbsolute, internedSegments);
-  }
-
-  /** Same as {@link #create(char, boolean, String[])}, except for {@link List}s of segments. */
-  public static PathFragment create(char driveLetter, boolean isAbsolute, List<String> segments) {
-    String[] internedSegments = new String[segments.size()];
-    for (int i = 0; i < segments.size(); i++) {
-      internedSegments[i] = StringCanonicalizer.intern(segments.get(i));
-    }
-    return createAlreadyInterned(driveLetter, isAbsolute, internedSegments);
-  }
-
-  /**
-   * Construct a PathFragment from a java.io.File, which is an absolute or
-   * relative UNIX path.  Does not support Windows-style Files.
-   */
-  public static PathFragment create(File path) {
-    return HELPER.create(path.getPath());
-  }
-
-  /**
-   * Construct a PathFragment from a string, which is an absolute or relative UNIX or Windows path.
-   */
+  /** Creates a new normalized path fragment. */
   public static PathFragment create(String path) {
-    return HELPER.create(path);
+    int normalizationLevel = OS.needsToNormalize(path);
+    String normalizedPath =
+        normalizationLevel != OsPathPolicy.NORMALIZED
+            ? OS.normalize(path, normalizationLevel)
+            : path;
+    int driveStrLength = OS.getDriveStrLength(normalizedPath);
+    return new PathFragment(normalizedPath, driveStrLength);
   }
 
   /**
-   * Constructs a PathFragment, taking ownership of {@code segments} and assuming the {@link
-   * String}s within have already been interned.
+   * Creates a new path fragment, where the caller promises that the path is normalized.
    *
-   * <p>Package-private because it does not perform a defensive copy of the segments array. Used
-   * here in PathFragment, and by Path.asFragment() and Path.relativeTo().
+   * <p>WARNING! Make sure the path fragment is in fact already normalized. The rest of the code
+   * assumes this is the case.
    */
-  static PathFragment createAlreadyInterned(
-      char driveLetter, boolean isAbsolute, String[] segments) {
-    return HELPER.createAlreadyInterned(driveLetter, isAbsolute, segments);
-  }
-
-  /** Returns whether the current {@code path} contains a path separator. */
-  static boolean containsSeparator(String path) {
-    return HELPER.containsSeparatorChar(path);
+  public static PathFragment createAlreadyNormalized(String normalizedPath) {
+    int driveStrLength = OS.getDriveStrLength(normalizedPath);
+    return createAlreadyNormalized(normalizedPath, driveStrLength);
   }
 
   /**
-   * Construct a PathFragment from a sequence of other PathFragments. The new fragment will be
-   * absolute iff the first fragment was absolute.
+   * Creates a new path fragment, where the caller promises that the path is normalized.
+   *
+   * <p>Should only be used internally.
    */
-  // TODO(bazel-team): Most usages of this method are wasteful from a garbage perspective. Refactor
-  // to something better.
-  public static PathFragment create(PathFragment first, PathFragment second, PathFragment... more) {
-    String[] segments = new String[sumLengths(first, second, more)];
-    int offset = 0;
-    offset += addSegmentsTo(segments, offset, first);
-    offset += addSegmentsTo(segments, offset, second);
-    for (PathFragment fragment : more) {
-      offset += addSegmentsTo(segments, offset, fragment);
-    }
-    boolean isAbsolute = first.isAbsolute();
-    char driveLetter = first.getDriveLetter();
-    return HELPER.createAlreadyInterned(driveLetter, isAbsolute, segments);
+  static PathFragment createAlreadyNormalized(String normalizedPath, int driveStrLength) {
+    return new PathFragment(normalizedPath, driveStrLength);
   }
 
-  // Medium sized builds can easily hold millions of live PathFragments, so the per-instance size of
-  // PathFragment is a concern.
-  //
-  // We have two oop-sized fields (segments, path), and one 4-byte-sized one (hashCode).
-  //
-  // If Blaze is run on a jvm with -XX:+UseCompressedOops, each PathFragment instance is 24 bytes
-  // and so adding any additional field will increase the per-instance size to at least 32 bytes.
-  //
-  // If Blaze is run on a jvm with -XX:-UseCompressedOops, each PathFragment instance is 32 bytes
-  // and so adding any additional field will increase the per-instance size to at least 40 bytes.
-  //
-  // Therefore, do not add any additional fields unless you have considered the memory implications.
-
-  // The individual path components.
-  // Does *not* include the Windows drive letter.
-  protected final String[] segments;
-
-  // hashCode and path are lazily initialized but semantically immutable.
-  private int hashCode;
-  private String path;
-
-  protected PathFragment(String[] segments) {
-    this.segments = segments;
+  /** This method expects path to already be normalized. */
+  private PathFragment(String path, int driveStrLength) {
+    this.path = Preconditions.checkNotNull(path);
+    this.driveStrLength = driveStrLength;
   }
 
-  private static int addSegmentsTo(String[] segments, int offset, PathFragment fragment) {
-    int count = fragment.segmentCount();
-    System.arraycopy(fragment.segments, 0, segments, offset, count);
-    return count;
-  }
-
-  private static int sumLengths(PathFragment first, PathFragment second, PathFragment[] more) {
-    int total = first.segmentCount() + second.segmentCount();
-    for (PathFragment fragment : more) {
-      total += fragment.segmentCount();
-    }
-    return total;
-  }
-
-  protected Object writeReplace() {
-    return new PathFragmentSerializationProxy(toString());
-  }
-
-  protected void readObject(ObjectInputStream stream) throws InvalidObjectException {
-    throw new InvalidObjectException("Serialization is allowed only by proxy");
-  }
-
-  /**
-   * Returns the path string using '/' as the name-separator character.  Returns "" if the path
-   * is both relative and empty.
-   */
   public String getPathString() {
-    // Double-checked locking works, even without volatile, because path is a String, according to:
-    // http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
-    if (path == null) {
-      synchronized (this) {
-        if (path == null) {
-          path = StringCanonicalizer.intern(joinSegments(HELPER.getPrimarySeparatorChar()));
-        }
-      }
-    }
     return path;
   }
 
+  public boolean isEmpty() {
+    return path.isEmpty();
+  }
+
+  int getDriveStrLength() {
+    return driveStrLength;
+  }
+
   /**
-   * Returns "." if the path fragment is both relative and empty, or {@link
-   * #getPathString} otherwise.
+   * If called on a {@link PathFragment} instance for a mount name (eg. '/' or 'C:/'), the empty
+   * string is returned.
+   *
+   * <p>This operation allocates a new string.
    */
-  // TODO(bazel-team): Change getPathString to do this - this behavior makes more sense.
+  public String getBaseName() {
+    int lastSeparator = path.lastIndexOf(SEPARATOR_CHAR);
+    return lastSeparator < driveStrLength
+        ? path.substring(driveStrLength)
+        : path.substring(lastSeparator + 1);
+  }
+
+  /**
+   * Returns a {@link PathFragment} instance representing the relative path between this {@link
+   * PathFragment} and the given {@link PathFragment}.
+   *
+   * <p>If the passed path is absolute it is returned untouched. This can be useful to resolve
+   * symlinks.
+   */
+  public PathFragment getRelative(PathFragment other) {
+    Preconditions.checkNotNull(other);
+    // Fast-path: The path fragment is already normal, use cheaper normalization check
+    String otherStr = other.path;
+    return getRelative(otherStr, other.getDriveStrLength(), OS.needsToNormalizeSuffix(otherStr));
+  }
+
+  /**
+   * Returns a {@link PathFragment} instance representing the relative path between this {@link
+   * PathFragment} and the given path.
+   *
+   * <p>See {@link #getRelative(PathFragment)} for details.
+   */
+  public PathFragment getRelative(String other) {
+    Preconditions.checkNotNull(other);
+    return getRelative(other, OS.getDriveStrLength(other), OS.needsToNormalize(other));
+  }
+
+  private PathFragment getRelative(String other, int otherDriveStrLength, int normalizationLevel) {
+    if (path.isEmpty()) {
+      return create(other);
+    }
+    if (other.isEmpty()) {
+      return this;
+    }
+    // This is an absolute path, simply return it
+    if (otherDriveStrLength > 0) {
+      String normalizedPath =
+          normalizationLevel != OsPathPolicy.NORMALIZED
+              ? OS.normalize(other, normalizationLevel)
+              : other;
+      return new PathFragment(normalizedPath, otherDriveStrLength);
+    }
+    String newPath;
+    if (path.length() == driveStrLength) {
+      newPath = path + other;
+    } else {
+      newPath = path + '/' + other;
+    }
+    newPath =
+        normalizationLevel != OsPathPolicy.NORMALIZED
+            ? OS.normalize(newPath, normalizationLevel)
+            : newPath;
+    return new PathFragment(newPath, driveStrLength);
+  }
+
+  public PathFragment getChild(String baseName) {
+    checkBaseName(baseName);
+    String newPath;
+    if (path.length() == driveStrLength) {
+      newPath = path + baseName;
+    } else {
+      newPath = path + '/' + baseName;
+    }
+    return new PathFragment(newPath, driveStrLength);
+  }
+
+  /**
+   * Returns the parent directory of this {@link PathFragment}.
+   *
+   * <p>If this is called on an single directory for a relative path, this returns an empty relative
+   * path. If it's called on a root (like '/') or the empty string, it returns null.
+   */
+  @Nullable
+  public PathFragment getParentDirectory() {
+    int lastSeparator = path.lastIndexOf(SEPARATOR_CHAR);
+
+    // For absolute paths we need to specially handle when we hit root
+    // Relative paths can't hit this path as driveStrLength == 0
+    if (driveStrLength > 0) {
+      if (lastSeparator < driveStrLength) {
+        if (path.length() > driveStrLength) {
+          String newPath = path.substring(0, driveStrLength);
+          return new PathFragment(newPath, driveStrLength);
+        } else {
+          return null;
+        }
+      }
+    } else {
+      if (lastSeparator == -1) {
+        if (!path.isEmpty()) {
+          return EMPTY_FRAGMENT;
+        } else {
+          return null;
+        }
+      }
+    }
+    String newPath = path.substring(0, lastSeparator);
+    return new PathFragment(newPath, driveStrLength);
+  }
+
+  /**
+   * Returns the {@link PathFragment} relative to the base {@link PathFragment}.
+   *
+   * <p>For example, <code>FilePath.create("foo/bar/wiz").relativeTo(FilePath.create("foo"))</code>
+   * returns <code>"bar/wiz"</code>.
+   *
+   * <p>If the {@link PathFragment} is not a child of the passed {@link PathFragment} an {@link
+   * IllegalArgumentException} is thrown. In particular, this will happen whenever the two {@link
+   * PathFragment} instances aren't both absolute or both relative.
+   */
+  public PathFragment relativeTo(PathFragment base) {
+    Preconditions.checkNotNull(base);
+    if (isAbsolute() != base.isAbsolute()) {
+      throw new IllegalArgumentException(
+          "Cannot relativize an absolute and a non-absolute path pair");
+    }
+    String basePath = base.path;
+    if (!OS.startsWith(path, basePath)) {
+      throw new IllegalArgumentException(
+          String.format("Path '%s' is not under '%s', cannot relativize", this, base));
+    }
+    int bn = basePath.length();
+    if (bn == 0) {
+      return this;
+    }
+    if (path.length() == bn) {
+      return EMPTY_FRAGMENT;
+    }
+    final int lastSlashIndex;
+    if (basePath.charAt(bn - 1) == '/') {
+      lastSlashIndex = bn - 1;
+    } else {
+      lastSlashIndex = bn;
+    }
+    if (path.charAt(lastSlashIndex) != '/') {
+      throw new IllegalArgumentException(
+          String.format("Path '%s' is not under '%s', cannot relativize", this, base));
+    }
+    String newPath = path.substring(lastSlashIndex + 1);
+    return new PathFragment(newPath, 0 /* Always a relative path */);
+  }
+
+  public PathFragment relativeTo(String base) {
+    return relativeTo(PathFragment.create(base));
+  }
+
+  /**
+   * Returns whether this path is an ancestor of another path.
+   *
+   * <p>If this == other, true is returned.
+   *
+   * <p>An absolute path can never be an ancestor of a relative path, and vice versa.
+   */
+  public boolean startsWith(PathFragment other) {
+    Preconditions.checkNotNull(other);
+    if (other.path.length() > path.length()) {
+      return false;
+    }
+    if (driveStrLength != other.driveStrLength) {
+      return false;
+    }
+    if (!OS.startsWith(path, other.path)) {
+      return false;
+    }
+    return path.length() == other.path.length()
+        || other.path.length() == driveStrLength
+        || path.charAt(other.path.length()) == SEPARATOR_CHAR;
+  }
+
+  /**
+   * Returns true iff {@code suffix}, considered as a list of path segments, is relative and a
+   * suffix of {@code this}, or both are absolute and equal.
+   *
+   * <p>This is a reflexive, transitive, anti-symmetric relation (i.e. a partial order)
+   */
+  public boolean endsWith(PathFragment other) {
+    Preconditions.checkNotNull(other);
+    if (other.path.length() > path.length()) {
+      return false;
+    }
+    if (other.isAbsolute()) {
+      return this.equals(other);
+    }
+    if (!OS.endsWith(path, other.path)) {
+      return false;
+    }
+    return path.length() == other.path.length()
+        || other.path.length() == 0
+        || path.charAt(path.length() - other.path.length() - 1) == SEPARATOR_CHAR;
+  }
+
+  public boolean isAbsolute() {
+    return driveStrLength > 0;
+  }
+
+  public static boolean isAbsolute(String path) {
+    return OS.getDriveStrLength(path) > 0;
+  }
+
+  @Override
+  public String toString() {
+    return path;
+  }
+
+  @Override
+  public void repr(SkylarkPrinter printer) {
+    printer.append(path);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    return OS.equals(this.path, ((PathFragment) o).path);
+  }
+
+  @Override
+  public int hashCode() {
+    return OS.hash(this.path);
+  }
+
+  @Override
+  public int compareTo(PathFragment o) {
+    return OS.compare(this.path, o.path);
+  }
+
+  ////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Returns the number of segments in this path.
+   *
+   * <p>This operation is O(N) on the length of the string.
+   */
+  public int segmentCount() {
+    int n = path.length();
+    int segmentCount = 0;
+    int i;
+    for (i = driveStrLength; i < n; ++i) {
+      if (path.charAt(i) == SEPARATOR_CHAR) {
+        ++segmentCount;
+      }
+    }
+    // Add last segment if one exists.
+    if (i > driveStrLength) {
+      ++segmentCount;
+    }
+    return segmentCount;
+  }
+
+  /**
+   * Returns the specified segment of this path; index must be positive and less than numSegments().
+   *
+   * <p>This operation is O(N) on the length of the string.
+   */
+  public String getSegment(int index) {
+    int n = path.length();
+    int segmentCount = 0;
+    int i;
+    for (i = driveStrLength; i < n && segmentCount < index; ++i) {
+      if (path.charAt(i) == SEPARATOR_CHAR) {
+        ++segmentCount;
+      }
+    }
+    int starti = i;
+    for (; i < n; ++i) {
+      if (path.charAt(i) == SEPARATOR_CHAR) {
+        break;
+      }
+    }
+    // Add last segment if one exists.
+    if (i > driveStrLength) {
+      ++segmentCount;
+    }
+    int endi = i;
+    if (index < 0 || index >= segmentCount) {
+      throw new IllegalArgumentException("Illegal segment index: " + index);
+    }
+    return path.substring(starti, endi);
+  }
+
+  /**
+   * Returns a new path fragment that is a sub fragment of this one. The sub fragment begins at the
+   * specified <code>beginIndex</code> segment and ends at the segment at index <code>endIndex - 1
+   * </code>. Thus the number of segments in the new PathFragment is <code>endIndex - beginIndex
+   * </code>.
+   *
+   * <p>This operation is O(N) on the length of the string.
+   *
+   * @param beginIndex the beginning index, inclusive.
+   * @param endIndex the ending index, exclusive.
+   * @return the specified sub fragment, never null.
+   * @exception IndexOutOfBoundsException if the <code>beginIndex</code> is negative, or <code>
+   *     endIndex</code> is larger than the length of this <code>String</code> object, or <code>
+   *     beginIndex</code> is larger than <code>endIndex</code>.
+   */
+  public PathFragment subFragment(int beginIndex, int endIndex) {
+    if (beginIndex < 0 || beginIndex > endIndex) {
+      throw new IndexOutOfBoundsException(
+          String.format("path: %s, beginIndex: %d endIndex: %d", toString(), beginIndex, endIndex));
+    }
+    return subFragmentImpl(beginIndex, endIndex);
+  }
+
+  public PathFragment subFragment(int beginIndex) {
+    if (beginIndex < 0) {
+      throw new IndexOutOfBoundsException(
+          String.format("path: %s, beginIndex: %d", toString(), beginIndex));
+    }
+    return subFragmentImpl(beginIndex, -1);
+  }
+
+  private PathFragment subFragmentImpl(int beginIndex, int endIndex) {
+    int n = path.length();
+    int segmentIndex = 0;
+    int i;
+    for (i = driveStrLength; i < n && segmentIndex < beginIndex; ++i) {
+      if (path.charAt(i) == SEPARATOR_CHAR) {
+        ++segmentIndex;
+      }
+    }
+    int starti = i;
+    if (segmentIndex < endIndex) {
+      for (; i < n; ++i) {
+        if (path.charAt(i) == SEPARATOR_CHAR) {
+          ++segmentIndex;
+          if (segmentIndex == endIndex) {
+            break;
+          }
+        }
+      }
+    } else if (endIndex == -1) {
+      i = path.length();
+    }
+    int endi = i;
+    // Add last segment if one exists for verification
+    if (i == n && i > driveStrLength) {
+      ++segmentIndex;
+    }
+    if (beginIndex > segmentIndex || endIndex > segmentIndex) {
+      throw new IndexOutOfBoundsException(
+          String.format("path: %s, beginIndex: %d endIndex: %d", toString(), beginIndex, endIndex));
+    }
+    // If beginIndex is 0 we include the drive. Very odd semantics.
+    int driveStrLength = 0;
+    if (beginIndex == 0) {
+      starti = 0;
+      driveStrLength = this.driveStrLength;
+      endi = Math.max(endi, driveStrLength);
+    }
+    return new PathFragment(path.substring(starti, endi), driveStrLength);
+  }
+
+  /**
+   * Returns the segments of this path fragment. This array should not be
+   * modified.
+   */
+  String[] segments() {
+    int segmentCount = segmentCount();
+    String[] segments = new String[segmentCount];
+    int segmentIndex = 0;
+    int nexti = driveStrLength;
+    int n = path.length();
+    for (int i = driveStrLength; i < n; ++i) {
+      if (path.charAt(i) == SEPARATOR_CHAR) {
+        segments[segmentIndex++] = path.substring(nexti, i);
+        nexti = i + 1;
+      }
+    }
+    // Add last segment if one exists.
+    if (nexti < n) {
+      segments[segmentIndex] = path.substring(nexti);
+    }
+    return segments;
+  }
+
+  /**
+   * Returns a list of the segments.
+   *
+   * <p>This operation is O(N) on the length of the string.
+   */
+  public ImmutableList<String> getSegments() {
+    return ImmutableList.copyOf(segments());
+  }
+
+  public int getFirstSegment(Set<String> values) {
+    String[] segments = segments();
+    for (int i = 0; i < segments.length; ++i) {
+      if (values.contains(segments[i])) {
+        return i;
+      }
+    }
+    return INVALID_SEGMENT;
+  }
+
+  /** Returns the path string, or '.' if the path is empty. */
   public String getSafePathString() {
-    return (!isAbsolute() && (segmentCount() == 0)) ? "." : getPathString();
+    return !path.isEmpty() ? path : ".";
   }
 
   /**
@@ -310,399 +539,52 @@
    */
   public String getCallablePathString() {
     if (isAbsolute()) {
-      return getPathString();
-    } else if (segmentCount() == 0) {
+      return path;
+    } else if (path.isEmpty()) {
       return ".";
-    } else if (segmentCount() == 1) {
-      return "." + HELPER.getPrimarySeparatorChar() + getPathString();
+    } else if (path.indexOf(SEPARATOR_CHAR) == -1) {
+      return "." + SEPARATOR_CHAR + path;
     } else {
-      return getPathString();
+      return path;
     }
   }
 
   /**
-  * Throws {@link IllegalArgumentException} if {@code paths} contains any paths that
-  * are equal to {@code startingWithPath} or that are not beneath {@code startingWithPath}.
-  */
-  public static void checkAllPathsAreUnder(Iterable<PathFragment> paths,
-      PathFragment startingWithPath) {
-    for (PathFragment path : paths) {
-      Preconditions.checkArgument(
-          !path.equals(startingWithPath) && path.startsWith(startingWithPath),
-              "%s is not beneath %s", path, startingWithPath);
-    }
-  }
-
-  private String joinSegments(char separatorChar) {
-    if (segments.length == 0 && isAbsolute()) {
-      return windowsVolume() + ROOT_DIR;
-    }
-
-    // Profile driven optimization:
-    // Preallocate a size determined by the number of segments, so that
-    // we do not have to expand the capacity of the StringBuilder.
-    // Heuristically, this estimate is right for about 99% of the time.
-    int estimateSize =
-        ((getDriveLetter() != '\0') ? 2 : 0)
-            + ((segments.length == 0) ? 0 : (segments.length + 1) * 20);
-    StringBuilder result = new StringBuilder(estimateSize);
-    if (isAbsolute()) {
-      // Only print the Windows volume label if the PathFragment is absolute. Do not print relative
-      // Windows paths like "C:foo/bar", it would break all kinds of things, e.g. glob().
-      result.append(windowsVolume());
-    }
-    boolean initialSegment = true;
-    for (String segment : segments) {
-      if (!initialSegment || isAbsolute()) {
-        result.append(separatorChar);
-      }
-      initialSegment = false;
-      result.append(segment);
-    }
-    return result.toString();
-  }
-
-  /**
-   * Return true iff none of the segments are either "." or "..".
-   */
-  public boolean isNormalized() {
-    for (String segment : segments) {
-      if (segment.equals(".") || segment.equals("..")) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  public static boolean isNormalized(String path) {
-    return PathFragment.create(path).isNormalized();
-  }
-
-  /**
-   * Normalizes the path fragment: removes "." and ".." segments if possible
-   * (if there are too many ".." segments, the resulting PathFragment will still
-   * start with "..").
-   */
-  public PathFragment normalize() {
-    String[] scratchSegments = new String[segments.length];
-    int segmentCount = 0;
-
-    for (String segment : segments) {
-      switch (segment) {
-        case ".":
-          // Just discard it
-          break;
-        case "..":
-          if (segmentCount > 0 && !scratchSegments[segmentCount - 1].equals("..")) {
-            // Remove the last segment, if there is one and it is not "..". This
-            // means that the resulting PathFragment can still contain ".."
-            // segments at the beginning.
-            segmentCount--;
-          } else {
-            scratchSegments[segmentCount++] = segment;
-          }
-          break;
-        default:
-          scratchSegments[segmentCount++] = segment;
-      }
-    }
-
-    if (segmentCount == segments.length) {
-      // Optimization, no new PathFragment needs to be created.
-      return this;
-    }
-
-    return HELPER.createAlreadyInterned(
-        getDriveLetter(), isAbsolute(), subarray(scratchSegments, 0, segmentCount));
-  }
-
-  /**
-   * Returns the path formed by appending the relative or absolute path fragment
-   * {@code otherFragment} to this path.
-   *
-   * <p>If {@code otherFragment} is absolute, the current path will be ignored;
-   * otherwise, they will be concatenated. This is a purely syntactic operation,
-   * with no path normalization or I/O performed.
-   */
-  public PathFragment getRelative(PathFragment otherFragment) {
-    if (otherFragment == EMPTY_FRAGMENT) {
-      return this;
-    }
-
-    if (otherFragment.isAbsolute()) {
-      char driveLetter = getDriveLetter();
-      return driveLetter == '\0' || otherFragment.getDriveLetter() != '\0'
-          ? otherFragment
-          : createAlreadyInterned(driveLetter, true, otherFragment.segments);
-    } else {
-      return create(this, otherFragment);
-    }
-  }
-
-  /**
-   * Returns the path formed by appending the relative or absolute string
-   * {@code path} to this path.
-   *
-   * <p>If the given path string is absolute, the current path will be ignored;
-   * otherwise, they will be concatenated. This is a purely syntactic operation,
-   * with no path normalization or I/O performed.
-   */
-  public PathFragment getRelative(String path) {
-    return getRelative(create(path));
-  }
-
-  /**
-   * Returns the path formed by appending the single non-special segment "baseName" to this path.
-   *
-   * <p>You should almost always use {@link #getRelative} instead, which has the same performance
-   * characteristics if the given name is a valid base name, and which also works for '.', '..', and
-   * strings containing '/'.
-   *
-   * @throws IllegalArgumentException if {@code baseName} is not a valid base name according to
-   *     {@link #checkBaseName}
-   */
-  public PathFragment getChild(String baseName) {
-    checkBaseName(baseName);
-    baseName = StringCanonicalizer.intern(baseName);
-    String[] newSegments = Arrays.copyOf(segments, segments.length + 1);
-    newSegments[newSegments.length - 1] = baseName;
-    return createAlreadyInterned(getDriveLetter(), isAbsolute(), newSegments);
-  }
-
-  /**
-   * Returns the last segment of this path, or "" for the empty fragment.
-   */
-  public String getBaseName() {
-    return (segments.length == 0) ? "" : segments[segments.length - 1];
-  }
-
-  /**
    * Returns the file extension of this path, excluding the period, or "" if there is no extension.
    */
   public String getFileExtension() {
-    String baseName = getBaseName();
-
-    int lastIndex = baseName.lastIndexOf('.');
-    if (lastIndex != -1) {
-      return baseName.substring(lastIndex + 1);
+    int n = path.length();
+    for (int i = n - 1; i > driveStrLength; --i) {
+      char c = path.charAt(i);
+      if (c == '.') {
+        return path.substring(i + 1, n);
+      } else if (c == SEPARATOR_CHAR) {
+        break;
+      }
     }
-
     return "";
   }
 
   /**
-   * Returns a relative path fragment to this path, relative to
-   * {@code ancestorDirectory}.
-   * <p>
-   * <code>x.relativeTo(z) == y</code> implies
-   * <code>z.getRelative(y) == x</code>.
-   * <p>
-   * For example, <code>"foo/bar/wiz".relativeTo("foo")</code>
-   * returns <code>"bar/wiz"</code>.
-   */
-  public PathFragment relativeTo(PathFragment ancestorDirectory) {
-    String[] ancestorSegments = ancestorDirectory.segments();
-    int ancestorLength = ancestorSegments.length;
-
-    if (isAbsolute() != ancestorDirectory.isAbsolute() || segments.length < ancestorLength) {
-      throw new IllegalArgumentException("PathFragment " + this
-          + " is not beneath " + ancestorDirectory);
-    }
-
-    if (!HELPER.segmentsEqual(ancestorLength, segments, 0, ancestorSegments)) {
-      throw new IllegalArgumentException(
-          "PathFragment " + this + " is not beneath " + ancestorDirectory);
-    }
-
-    int length = segments.length - ancestorLength;
-    String[] resultSegments = subarray(segments, ancestorLength, length);
-    return createAlreadyInterned('\0', false, resultSegments);
-  }
-
-  /**
-   * Returns a relative path fragment to this path, relative to {@code path}.
-   */
-  public PathFragment relativeTo(String path) {
-    return relativeTo(create(path));
-  }
-
-  /**
-   * Returns a new PathFragment formed by appending {@code newName} to the
-   * parent directory. Null is returned iff this method is called on a
-   * PathFragment with zero segments.  If {@code newName} designates an absolute path,
-   * the value of {@code this} will be ignored and a PathFragment corresponding to
-   * {@code newName} will be returned.  This behavior is consistent with the behavior of
-   * {@link #getRelative(String)}.
+   * Returns a new PathFragment formed by appending {@code newName} to the parent directory. Null is
+   * returned iff this method is called on a PathFragment with zero segments. If {@code newName}
+   * designates an absolute path, the value of {@code this} will be ignored and a PathFragment
+   * corresponding to {@code newName} will be returned. This behavior is consistent with the
+   * behavior of {@link #getRelative(String)}.
    */
   public PathFragment replaceName(String newName) {
-    return segments.length == 0 ? null : getParentDirectory().getRelative(newName);
+    PathFragment parent = getParentDirectory();
+    return parent != null ? parent.getRelative(newName) : null;
   }
 
   /**
-   * Returns a path representing the parent directory of this path,
-   * or null iff this Path represents the root of the filesystem.
+   * Returns the drive for an absolute path fragment.
    *
-   * <p>Note: This method DOES NOT normalize ".."  and "." path segments.
+   * <p>On unix, this will return "/". On Windows it will return the drive letter, like "C:/".
    */
-  public PathFragment getParentDirectory() {
-    return segments.length == 0 ? null : subFragment(0, segments.length - 1);
-  }
-
-  /**
-   * Returns true iff {@code prefix}, considered as a list of path segments, is
-   * a prefix of {@code this}, and that they are both relative or both
-   * absolute.
-   *
-   * <p>This is a reflexive, transitive, anti-symmetric relation (i.e. a partial
-   * order)
-   */
-  public boolean startsWith(PathFragment prefix) {
-    if (isAbsolute() != prefix.isAbsolute()
-        || this.segments.length < prefix.segments.length
-        || (isAbsolute() && getDriveLetter() != prefix.getDriveLetter())) {
-      return false;
-    }
-    return HELPER.segmentsEqual(prefix.segments.length, segments, 0, prefix.segments);
-  }
-
-  /**
-   * Returns true iff {@code suffix}, considered as a list of path segments, is
-   * relative and a suffix of {@code this}, or both are absolute and equal.
-   *
-   * <p>This is a reflexive, transitive, anti-symmetric relation (i.e. a partial
-   * order)
-   */
-  public boolean endsWith(PathFragment suffix) {
-    if ((suffix.isAbsolute() && !suffix.equals(this))
-        || this.segments.length < suffix.segments.length) {
-      return false;
-    }
-    int offset = this.segments.length - suffix.segments.length;
-    return HELPER.segmentsEqual(suffix.segments.length, segments, offset, suffix.segments);
-  }
-
-  private static String[] subarray(String[] array, int start, int length) {
-    String[] subarray = new String[length];
-    System.arraycopy(array, start, subarray, 0, length);
-    return subarray;
-  }
-
-  /**
-   * Returns a new path fragment that is a sub fragment of this one.
-   * The sub fragment begins at the specified <code>beginIndex</code> segment
-   * and ends at the segment at index <code>endIndex - 1</code>. Thus the number
-   * of segments in the new PathFragment is <code>endIndex - beginIndex</code>.
-   *
-   * @param      beginIndex   the beginning index, inclusive.
-   * @param      endIndex     the ending index, exclusive.
-   * @return     the specified sub fragment, never null.
-   * @exception  IndexOutOfBoundsException  if the
-   *             <code>beginIndex</code> is negative, or
-   *             <code>endIndex</code> is larger than the length of
-   *             this <code>String</code> object, or
-   *             <code>beginIndex</code> is larger than
-   *             <code>endIndex</code>.
-   */
-  public PathFragment subFragment(int beginIndex, int endIndex) {
-    int count = segments.length;
-    if ((beginIndex < 0) || (beginIndex > endIndex) || (endIndex > count)) {
-      throw new IndexOutOfBoundsException(String.format("path: %s, beginIndex: %d endIndex: %d",
-          toString(), beginIndex, endIndex));
-    }
-    boolean isAbsolute = (beginIndex == 0) && isAbsolute();
-    return ((beginIndex == 0) && (endIndex == count))
-        ? this
-        : createAlreadyInterned(
-            getDriveLetter(), isAbsolute, subarray(segments, beginIndex, endIndex - beginIndex));
-  }
-
-  /**
-   * Returns a new path fragment that is a sub fragment of this one. The sub fragment begins at the
-   * specified <code>beginIndex</code> segment and contains the rest of the original path fragment.
-   *
-   * @param beginIndex the beginning index, inclusive.
-   * @return the specified sub fragment, never null.
-   * @exception IndexOutOfBoundsException if the <code>beginIndex</code> is negative, or <code>
-   *     endIndex</code> is larger than the length of this <code>String</code> object, or <code>
-   *     beginIndex</code> is larger than <code>endIndex</code>.
-   */
-  public PathFragment subFragment(int beginIndex) {
-    return subFragment(beginIndex, segments.length);
-  }
-
-  /**
-   * Returns true iff the path represented by this object is absolute.
-   *
-   * <p>True both for UNIX-style absolute paths ("/foo") and Windows-style ("C:/foo"). False for a
-   * Windows-style volume label ("C:") which is actually a relative path.
-   */
-  public abstract boolean isAbsolute();
-
-  public static boolean isAbsolute(String path) {
-    return PathFragment.create(path).isAbsolute();
-  }
-
-  /**
-   * Returns the segments of this path fragment. This array should not be
-   * modified.
-   */
-  String[] segments() {
-    return segments;
-  }
-
-  public ImmutableList<String> getSegments() {
-    return ImmutableList.copyOf(segments);
-  }
-
-  public abstract String windowsVolume();
-
-  /** Return the drive letter or '\0' if not applicable. */
-  // TODO(bazel-team): This doesn't need to pollute the PathFragment interface (ditto for
-  // windowsVolume).
-  public abstract char getDriveLetter();
-
-  public boolean isEmpty() {
-    return segments.length == 0;
-  }
-
-  /**
-   * Returns the number of segments in this path.
-   */
-  public int segmentCount() {
-    return segments.length;
-  }
-
-  /**
-   * Returns the specified segment of this path; index must be positive and
-   * less than numSegments().
-   */
-  public String getSegment(int index) {
-    return segments[index];
-  }
-
-  /**
-   * Returns the index of the first segment which equals one of the input values
-   * or {@link PathFragment#INVALID_SEGMENT} if none of the segments match.
-   */
-  public int getFirstSegment(Set<String> values) {
-    for (int i = 0; i < segments.length; i++) {
-      if (values.contains(segments[i])) {
-        return i;
-      }
-    }
-    return INVALID_SEGMENT;
-  }
-
-  /**
-   * Returns true iff this path contains uplevel references "..".
-   */
-  public boolean containsUplevelReferences() {
-    for (String segment : segments) {
-      if (segment.equals("..")) {
-        return true;
-      }
-    }
-    return false;
+  public String getDriveStr() {
+    Preconditions.checkArgument(isAbsolute());
+    return path.substring(0, driveStrLength);
   }
 
   /**
@@ -711,60 +593,129 @@
    */
   public PathFragment toRelative() {
     Preconditions.checkArgument(isAbsolute());
-    return HELPER.createAlreadyInterned(getDriveLetter(), false, segments);
+    return new PathFragment(path.substring(driveStrLength), 0);
   }
 
-  @Override
-  public final int hashCode() {
-    // We use the hash code caching strategy employed by java.lang.String. There are three subtle
-    // things going on here:
-    //
-    // (1) We use a value of 0 to indicate that the hash code hasn't been computed and cached yet.
-    // Yes, this means that if the hash code is really 0 then we will "recompute" it each time. But
-    // this isn't a problem in practice since a hash code of 0 is rare.
-    //
-    // (2) Since we have no synchronization, multiple threads can race here thinking they are the
-    // first one to compute and cache the hash code.
-    //
-    // (3) Moreover, since 'hashCode' is non-volatile, the cached hash code value written from one
-    // thread may not be visible by another. Note that we don't need to worry about multiple
-    // inefficient reads of 'hashCode' on the same thread since it's non-volatile.
-    //
-    // All three of these issues are benign from a correctness perspective; in the end we have no
-    // overhead from synchronization, at the cost of potentially computing the hash code more than
-    // once.
-    if (hashCode == 0) {
-      hashCode = computeHashCode();
-    }
-    return hashCode;
-  }
-
-  protected abstract int computeHashCode();
-
-  @Override
-  public abstract boolean equals(Object other);
-
   /**
-   * Compares two PathFragments using the lexicographical order.
+   * Returns true if this path contains uplevel references "..".
+   *
+   * <p>Since path fragments are normalized, this implies that the uplevel reference is at the start
+   * of the path fragment.
    */
-  @Override
-  public int compareTo(PathFragment p2) {
-    return HELPER.compare(this, p2);
+  public boolean containsUplevelReferences() {
+    // Path is normalized, so any ".." would have to be at the very start
+    return path.startsWith("..");
   }
 
-  @Override
-  public String toString() {
-    return getPathString();
+  /**
+   * Returns true if the passed path contains uplevel references ".." or single-dot references "."
+   *
+   * <p>This is useful to check a string for normalization before constructing a PathFragment, since
+   * these are always normalized and will throw uplevel references away.
+   */
+  public static boolean isNormalized(String path) {
+    return isNormalizedImpl(path, true /* lookForSameLevelReferences */);
   }
 
-  @Override
-  public void repr(SkylarkPrinter printer) {
-    printer.append(getPathString());
+  /**
+   * Returns true if the passed path contains uplevel references "..".
+   *
+   * <p>This is useful to check a string for '..' segments before constructing a PathFragment, since
+   * these are always normalized and will throw uplevel references away.
+   */
+  public static boolean containsUplevelReferences(String path) {
+    return !isNormalizedImpl(path, false /* lookForSameLevelReferences */);
+  }
+
+  private enum NormalizedImplState {
+    Base, /* No particular state, eg. an 'a' or 'L' character */
+    Separator, /* We just saw a separator */
+    Dot, /* We just saw a dot after a separator */
+    DotDot, /* We just saw two dots after a separator */
+  }
+
+  private static boolean isNormalizedImpl(String path, boolean lookForSameLevelReferences) {
+    // Starting state is equivalent to having just seen a separator
+    NormalizedImplState state = NormalizedImplState.Separator;
+    int n = path.length();
+    for (int i = 0; i < n; ++i) {
+      char c = path.charAt(i);
+      boolean isSeparator = OS.isSeparator(c);
+      switch (state) {
+        case Base:
+          if (isSeparator) {
+            state = NormalizedImplState.Separator;
+          } else {
+            state = NormalizedImplState.Base;
+          }
+          break;
+        case Separator:
+          if (isSeparator) {
+            state = NormalizedImplState.Separator;
+          } else if (c == '.') {
+            state = NormalizedImplState.Dot;
+          } else {
+            state = NormalizedImplState.Base;
+          }
+          break;
+        case Dot:
+          if (isSeparator) {
+            if (lookForSameLevelReferences) {
+              // "." segment found
+              return false;
+            }
+            state = NormalizedImplState.Separator;
+          } else if (c == '.') {
+            state = NormalizedImplState.DotDot;
+          } else {
+            state = NormalizedImplState.Base;
+          }
+          break;
+        case DotDot:
+          if (isSeparator) {
+            // ".." segment found
+            return false;
+          } else {
+            state = NormalizedImplState.Base;
+          }
+          break;
+        default:
+          throw new IllegalStateException("Unhandled state: " + state);
+      }
+    }
+    // The character just after the string is equivalent to a separator
+    switch (state) {
+      case Dot:
+        if (lookForSameLevelReferences) {
+          // "." segment found
+          return false;
+        }
+        break;
+      case DotDot:
+        return false;
+      default:
+    }
+    return true;
+  }
+
+  /**
+   * Throws {@link IllegalArgumentException} if {@code paths} contains any paths that are equal to
+   * {@code startingWithPath} or that are not beneath {@code startingWithPath}.
+   */
+  public static void checkAllPathsAreUnder(
+      Iterable<PathFragment> paths, PathFragment startingWithPath) {
+    for (PathFragment path : paths) {
+      Preconditions.checkArgument(
+          !path.equals(startingWithPath) && path.startsWith(startingWithPath),
+          "%s is not beneath %s",
+          path,
+          startingWithPath);
+    }
   }
 
   @Override
   public String filePathForFileTypeMatcher() {
-    return getBaseName();
+    return path;
   }
 
   @Override
@@ -783,25 +734,13 @@
     @Override
     public void serialize(PathFragment pathFragment, CodedOutputStream codedOut)
         throws IOException, SerializationException {
-      codedOut.writeInt32NoTag(pathFragment.getDriveLetter());
-      codedOut.writeBoolNoTag(pathFragment.isAbsolute());
-      codedOut.writeInt32NoTag(pathFragment.segmentCount());
-      for (int i = 0; i < pathFragment.segmentCount(); i++) {
-        stringCodec.serialize(pathFragment.getSegment(i), codedOut);
-      }
+      stringCodec.serialize(pathFragment.getPathString(), codedOut);
     }
 
     @Override
     public PathFragment deserialize(CodedInputStream codedIn)
         throws IOException, SerializationException {
-      char driveLetter = (char) codedIn.readInt32();
-      boolean isAbsolute = codedIn.readBool();
-      int segmentCount = codedIn.readInt32();
-      String[] segments = new String[segmentCount];
-      for (int i = 0; i < segmentCount; i++) {
-        segments[i] = stringCodec.deserialize(codedIn);
-      }
-      return PathFragment.create(driveLetter, isAbsolute, segments);
+      return PathFragment.createAlreadyNormalized(stringCodec.deserialize(codedIn));
     }
   }
 
@@ -816,4 +755,8 @@
       throw new IllegalArgumentException("baseName must not contain a slash: '" + baseName + "'");
     }
   }
+
+  private Object writeReplace() {
+    return new PathFragmentSerializationProxy(path);
+  }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/PathFragmentSerializationProxy.java b/src/main/java/com/google/devtools/build/lib/vfs/PathFragmentSerializationProxy.java
index 39aefd1..4ba66be 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/PathFragmentSerializationProxy.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/PathFragmentSerializationProxy.java
@@ -17,7 +17,6 @@
 import java.io.IOException;
 import java.io.ObjectOutput;
 
-
 /**
  * A helper proxy for serializing immutable {@link PathFragment} objects.
  */
@@ -44,7 +43,7 @@
   }
 
   private Object readResolve() {
-    return PathFragment.create(pathFragmentString);
+    return PathFragment.createAlreadyNormalized(pathFragmentString);
   }
 }
 
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/PathTrie.java b/src/main/java/com/google/devtools/build/lib/vfs/PathTrie.java
deleted file mode 100644
index fd783c5..0000000
--- a/src/main/java/com/google/devtools/build/lib/vfs/PathTrie.java
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2014 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import com.google.common.base.Preconditions;
-import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadCompatible;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A trie that operates on path segments.
- *
- * @param <T> the type of the values.
- */
-@ThreadCompatible
-public class PathTrie<T> {
-  @SuppressWarnings("unchecked")
-  private static class Node<T> {
-    private Node() {
-      children = new HashMap<>();
-    }
-
-    private T value;
-    private Map<String, Node<T>> children;
-  }
-
-  private final Node<T> root;
-
-  public PathTrie() {
-    root = new Node<T>();
-  }
-
-  /**
-   * Puts a value in the trie.
-   *
-   * @param key must be an absolute path.
-   */
-  public void put(PathFragment key, T value) {
-    Preconditions.checkArgument(key.isAbsolute(), "PathTrie only accepts absolute paths as keys.");
-    Node<T> current = root;
-    for (String segment : key.getSegments()) {
-      current.children.putIfAbsent(segment, new Node<T>());
-      current = current.children.get(segment);
-    }
-    current.value = value;
-  }
-
-  /**
-   * Gets a value from the trie. If there is an entry with the same key, that will be returned,
-   * otherwise, the value corresponding to the key that matches the longest prefix of the input.
-   */
-  public T get(PathFragment key) {
-    Node<T> current = root;
-    T lastValue = current.value;
-
-    for (String segment : key.getSegments()) {
-      if (current.children.containsKey(segment)) {
-        current = current.children.get(segment);
-        // Track the values of increasing matching prefixes.
-        if (current.value != null) {
-          lastValue = current.value;
-        }
-      } else {
-        // We've reached the longest prefix, no further to go.
-        break;
-      }
-    }
-
-    return lastValue;
-  }
-}
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 9182f10..09ab313 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
@@ -30,9 +30,8 @@
  * <p>Two {@link RootedPath}s are considered equal iff they have equal roots and equal relative
  * paths.
  *
- * <p>TODO(bazel-team): refactor Artifact to use this instead of Root. TODO(bazel-team): use an
- * opaque root representation so as to not expose the absolute path to clients via #asPath or
- * #getRoot.
+ * <p>TODO(bazel-team): use an opaque root representation so as to not expose the absolute path to
+ * clients via #asPath or #getRoot.
  */
 public class RootedPath implements Serializable {
 
@@ -48,7 +47,7 @@
         rootRelativePath,
         root);
     this.root = root;
-    this.rootRelativePath = rootRelativePath.normalize();
+    this.rootRelativePath = rootRelativePath;
     this.path = root.getRelative(this.rootRelativePath);
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/UnionFileSystem.java b/src/main/java/com/google/devtools/build/lib/vfs/UnionFileSystem.java
index d924e19..a929f14 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/UnionFileSystem.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/UnionFileSystem.java
@@ -15,12 +15,14 @@
 package com.google.devtools.build.lib.vfs;
 
 import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
 import com.google.devtools.build.lib.concurrent.ThreadSafety;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
 import java.util.Map;
 import javax.annotation.Nullable;
 
@@ -42,12 +44,21 @@
  * are not currently supported.
  */
 @ThreadSafety.ThreadSafe
-public class UnionFileSystem extends FileSystem {
+public final class UnionFileSystem extends FileSystem {
 
-  // Prefix trie index, allowing children to easily inherit prefix mappings
-  // of their parents.
-  // This does not currently handle unicode filenames.
-  private final PathTrie<FileSystem> pathDelegate;
+  private static class FileSystemAndPrefix {
+    final PathFragment prefix;
+    final FileSystem fileSystem;
+
+    public FileSystemAndPrefix(PathFragment prefix, FileSystem fileSystem) {
+      this.prefix = prefix;
+      this.fileSystem = fileSystem;
+    }
+  }
+
+  // List of file systems and their mappings, sorted by prefix length descending.
+  private final List<FileSystemAndPrefix> fileSystems;
+  private final FileSystem rootFileSystem;
 
   // True if the file path is case-sensitive on all the FileSystem
   // or False if they are all case-insensitive, otherwise error.
@@ -65,11 +76,12 @@
     Preconditions.checkNotNull(rootFileSystem);
     Preconditions.checkArgument(rootFileSystem != this, "Circular root filesystem.");
     Preconditions.checkArgument(
-        !prefixMapping.containsKey(PathFragment.EMPTY_FRAGMENT),
+        prefixMapping.keySet().stream().noneMatch(p -> p.getPathString().equals("/")),
         "Attempted to specify an explicit root prefix mapping; "
             + "please use the rootFileSystem argument instead.");
 
-    this.pathDelegate = new PathTrie<>();
+    this.fileSystems = new ArrayList<>();
+    this.rootFileSystem = rootFileSystem;
     this.isCaseSensitive = rootFileSystem.isFilePathCaseSensitive();
 
     for (Map.Entry<PathFragment, FileSystem> prefix : prefixMapping.entrySet()) {
@@ -80,9 +92,13 @@
       PathFragment prefixPath = prefix.getKey();
 
       // Extra slash prevents within-directory mappings, which Path can't handle.
-      pathDelegate.put(prefixPath, delegate);
+      fileSystems.add(new FileSystemAndPrefix(prefixPath, delegate));
     }
-    pathDelegate.put(PathFragment.ROOT_FRAGMENT, rootFileSystem);
+    // Order by length descending. This ensures that more specific mapping takes precedence
+    // when we try to find the file system of a given path.
+    Comparator<FileSystemAndPrefix> comparator =
+        Comparator.comparing(f -> f.prefix.getPathString().length());
+    fileSystems.sort(comparator.reversed());
   }
 
   /**
@@ -92,19 +108,24 @@
    * @param path the {@link Path} to map to a filesystem
    * @throws IllegalArgumentException if no delegate exists for the path
    */
-  protected FileSystem getDelegate(Path path) {
+  FileSystem getDelegate(Path path) {
     Preconditions.checkNotNull(path);
-    FileSystem immediateDelegate = pathDelegate.get(path.asFragment());
-
-    // Should never actually happen if the root delegate is present.
-    Preconditions.checkNotNull(immediateDelegate, "No delegate filesystem exists for %s", path);
-    return immediateDelegate;
+    FileSystem delegate = null;
+    // Linearly iterate over each mapped file system and find the one that handles this path.
+    // For small number of mappings, this will be more efficient than using a trie
+    for (FileSystemAndPrefix fileSystemAndPrefix : this.fileSystems) {
+      if (path.startsWith(fileSystemAndPrefix.prefix)) {
+        delegate = fileSystemAndPrefix.fileSystem;
+        break;
+      }
+    }
+    return delegate != null ? delegate : rootFileSystem;
   }
 
   // Associates the path with the root of the given delegate filesystem.
   // Necessary to avoid null pointer problems inside of the delegates.
-  protected Path adjustPath(Path path, FileSystem delegate) {
-    return delegate.getPath(path.asFragment());
+  Path adjustPath(Path path, FileSystem delegate) {
+    return delegate.getPath(path.getPathString());
   }
 
   /**
@@ -344,12 +365,7 @@
     path = internalResolveSymlink(path);
     FileSystem delegate = getDelegate(path);
     Path resolvedPath = adjustPath(path, delegate);
-    Collection<Path> entries = resolvedPath.getDirectoryEntries();
-    Collection<String> result = Lists.newArrayListWithCapacity(entries.size());
-    for (Path entry : entries) {
-      result.add(entry.getBaseName());
-    }
-    return result;
+    return delegate.getDirectoryEntries(resolvedPath);
   }
 
   // No need for the more complex logic of getDirectoryEntries; it calls it implicitly.
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/UnixOsPathPolicy.java b/src/main/java/com/google/devtools/build/lib/vfs/UnixOsPathPolicy.java
new file mode 100644
index 0000000..8576643
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/vfs/UnixOsPathPolicy.java
@@ -0,0 +1,138 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.vfs;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Splitter;
+import com.google.common.collect.Iterables;
+
+@VisibleForTesting
+class UnixOsPathPolicy implements OsPathPolicy {
+
+  static final UnixOsPathPolicy INSTANCE = new UnixOsPathPolicy();
+  private static final Splitter PATH_SPLITTER = Splitter.onPattern("/+").omitEmptyStrings();
+
+  @Override
+  public int needsToNormalize(String path) {
+    int n = path.length();
+    int dotCount = 0;
+    char prevChar = 0;
+    for (int i = 0; i < n; i++) {
+      char c = path.charAt(i);
+      if (c == '\\') {
+        return NEEDS_NORMALIZE;
+      }
+      if (c == '/') {
+        if (prevChar == '/') {
+          return NEEDS_NORMALIZE;
+        }
+        if (dotCount == 1 || dotCount == 2) {
+          return NEEDS_NORMALIZE;
+        }
+      }
+      dotCount = c == '.' ? dotCount + 1 : 0;
+      prevChar = c;
+    }
+    if (prevChar == '/' || dotCount == 1 || dotCount == 2) {
+      return NEEDS_NORMALIZE;
+    }
+    return NORMALIZED;
+  }
+
+  @Override
+  public int needsToNormalizeSuffix(String normalizedSuffix) {
+    // We know that the string is normalized
+    // In this case only suffixes starting with ".." may cause
+    // normalization once concatenated with other strings
+    return normalizedSuffix.startsWith("..") ? NEEDS_NORMALIZE : NORMALIZED;
+  }
+
+  @Override
+  public String normalize(String path, int normalizationLevel) {
+    if (normalizationLevel == NORMALIZED) {
+      return path;
+    }
+    if (path.isEmpty()) {
+      return path;
+    }
+    boolean isAbsolute = path.charAt(0) == '/';
+    StringBuilder sb = new StringBuilder(path.length());
+    if (isAbsolute) {
+      sb.append('/');
+    }
+    String[] segments = Iterables.toArray(PATH_SPLITTER.splitToList(path), String.class);
+    int segmentCount = Utils.removeRelativePaths(segments, 0, isAbsolute);
+    for (int i = 0; i < segmentCount; ++i) {
+      sb.append(segments[i]);
+      sb.append('/');
+    }
+    if (segmentCount > 0) {
+      sb.deleteCharAt(sb.length() - 1);
+    }
+    return sb.toString();
+  }
+
+  @Override
+  public int getDriveStrLength(String path) {
+    if (path.length() == 0) {
+      return 0;
+    }
+    return (path.charAt(0) == '/') ? 1 : 0;
+  }
+
+  @Override
+  public int compare(String s1, String s2) {
+    return s1.compareTo(s2);
+  }
+
+  @Override
+  public int compare(char c1, char c2) {
+    return Character.compare(c1, c2);
+  }
+
+  @Override
+  public boolean equals(String s1, String s2) {
+    return s1.equals(s2);
+  }
+
+  @Override
+  public int hash(String s) {
+    return s.hashCode();
+  }
+
+  @Override
+  public boolean startsWith(String path, String prefix) {
+    return path.startsWith(prefix);
+  }
+
+  @Override
+  public boolean endsWith(String path, String suffix) {
+    return path.endsWith(suffix);
+  }
+
+  @Override
+  public char getSeparator() {
+    return '/';
+  }
+
+  @Override
+  public boolean isSeparator(char c) {
+    return c == '/';
+  }
+
+  @Override
+  public boolean isCaseSensitive() {
+    return true;
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/UnixPathFragment.java b/src/main/java/com/google/devtools/build/lib/vfs/UnixPathFragment.java
deleted file mode 100644
index b581d43..0000000
--- a/src/main/java/com/google/devtools/build/lib/vfs/UnixPathFragment.java
+++ /dev/null
@@ -1,220 +0,0 @@
-// Copyright 2017 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import com.google.common.base.Preconditions;
-import java.io.InvalidObjectException;
-import java.io.ObjectInputStream;
-
-/**
- * Abstract base class for {@link PathFragment} instances that will be allocated when Blaze is run
- * on a non-Windows platform.
- */
-abstract class UnixPathFragment extends PathFragment {
-  static final Helper HELPER = new Helper();
-  /**
-    * We have two concrete subclasses with zero per-instance additional memory overhead. Do not add
-    * any fields. See the comment on memory use in PathFragment for details on the current
-    * per-instance memory usage.
-    */
-
-  protected UnixPathFragment(String[] segments) {
-    super(segments);
-  }
-
-  @Override
-  protected int computeHashCode() {
-    int h = 0;
-    for (String segment : segments) {
-      int segmentHash = segment.hashCode();
-      h = h * 31 + segmentHash;
-    }
-    return h;
-  }
-
-  @Override
-  public String windowsVolume() {
-    return "";
-  }
-
-  @Override
-  public char getDriveLetter() {
-    return '\0';
-  }
-
-  private static class Helper extends PathFragment.Helper {
-    private static final char SEPARATOR_CHAR = '/';
-
-    @Override
-    PathFragment create(String path) {
-      boolean isAbsolute = path.length() > 0 && isSeparator(path.charAt(0));
-      return isAbsolute
-          ? new AbsoluteUnixPathFragment(segment(path, 1))
-          : new RelativeUnixPathFragment(segment(path, 0));
-    }
-
-    @Override
-    PathFragment createAlreadyInterned(char driveLetter, boolean isAbsolute, String[] segments) {
-      Preconditions.checkState(driveLetter == '\0', driveLetter);
-      return isAbsolute
-          ? new AbsoluteUnixPathFragment(segments)
-          : new RelativeUnixPathFragment(segments);
-    }
-
-    @Override
-    char getPrimarySeparatorChar() {
-      return SEPARATOR_CHAR;
-    }
-
-    @Override
-    boolean isSeparator(char c) {
-      return c == SEPARATOR_CHAR;
-    }
-
-    @Override
-    boolean containsSeparatorChar(String path) {
-      return path.indexOf(SEPARATOR_CHAR) != -1;
-    }
-
-    @Override
-    boolean segmentsEqual(int length, String[] segments1, int offset1, String[] segments2) {
-      if ((segments1.length - offset1) < length || segments2.length < length) {
-        return false;
-      }
-      for (int i = 0; i < length; ++i) {
-        String seg1 = segments1[i + offset1];
-        String seg2 = segments2[i];
-        if ((seg1 == null) != (seg2 == null)) {
-          return false;
-        }
-        if (seg1 == null) {
-          continue;
-        }
-        if (!seg1.equals(seg2)) {
-          return false;
-        }
-      }
-      return true;
-    }
-
-    @Override
-    protected int compare(PathFragment pathFragment1, PathFragment pathFragment2) {
-      if (pathFragment1.isAbsolute() != pathFragment2.isAbsolute()) {
-        return pathFragment1.isAbsolute() ? -1 : 1;
-      }
-      String[] segments1 = pathFragment1.segments();
-      String[] segments2 = pathFragment2.segments();
-      int len1 = segments1.length;
-      int len2 = segments2.length;
-      int n = Math.min(len1, len2);
-      for (int i = 0; i < n; i++) {
-        String seg1 = segments1[i];
-        String seg2 = segments2[i];
-        int cmp = seg1.compareTo(seg2);
-        if (cmp != 0) {
-          return cmp;
-        }
-      }
-      return len1 - len2;
-    }
-  }
-
-  private static final class AbsoluteUnixPathFragment extends UnixPathFragment {
-    private AbsoluteUnixPathFragment(String[] segments) {
-      super(segments);
-    }
-
-    @Override
-    public boolean isAbsolute() {
-      return true;
-    }
-
-    @Override
-    protected int computeHashCode() {
-      int h = Boolean.TRUE.hashCode();
-      h = h * 31 + super.computeHashCode();
-      return h;
-    }
-
-    @Override
-    public boolean equals(Object other) {
-      if (!(other instanceof AbsoluteUnixPathFragment)) {
-        return false;
-      }
-      if (this == other) {
-        return true;
-      }
-      AbsoluteUnixPathFragment otherAbsoluteUnixPathFragment = (AbsoluteUnixPathFragment) other;
-      return HELPER.segmentsEqual(this.segments, otherAbsoluteUnixPathFragment.segments);
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected Object writeReplace() {
-      return super.writeReplace();
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected void readObject(ObjectInputStream stream) throws InvalidObjectException {
-      super.readObject(stream);
-    }
-  }
-
-  private static final class RelativeUnixPathFragment extends UnixPathFragment {
-    private RelativeUnixPathFragment(String[] segments) {
-      super(segments);
-    }
-
-    @Override
-    public boolean isAbsolute() {
-      return false;
-    }
-
-    @Override
-    protected int computeHashCode() {
-      int h = Boolean.FALSE.hashCode();
-      h = h * 31 + super.computeHashCode();
-      return h;
-    }
-
-    @Override
-    public boolean equals(Object other) {
-      if (!(other instanceof RelativeUnixPathFragment)) {
-        return false;
-      }
-      if (this == other) {
-        return true;
-      }
-      RelativeUnixPathFragment otherRelativeUnixPathFragment = (RelativeUnixPathFragment) other;
-      return HELPER.segmentsEqual(this.segments, otherRelativeUnixPathFragment.segments);
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected Object writeReplace() {
-      return super.writeReplace();
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected void readObject(ObjectInputStream stream) throws InvalidObjectException {
-      super.readObject(stream);
-    }
-  }
-}
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/WindowsOsPathPolicy.java b/src/main/java/com/google/devtools/build/lib/vfs/WindowsOsPathPolicy.java
new file mode 100644
index 0000000..f420683
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/vfs/WindowsOsPathPolicy.java
@@ -0,0 +1,240 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.vfs;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Splitter;
+import com.google.common.collect.Iterables;
+import com.google.devtools.build.lib.windows.WindowsShortPath;
+import com.google.devtools.build.lib.windows.jni.WindowsFileOperations;
+import java.io.IOException;
+
+@VisibleForTesting
+class WindowsOsPathPolicy implements OsPathPolicy {
+
+  static final WindowsOsPathPolicy INSTANCE = new WindowsOsPathPolicy();
+
+  static final int NEEDS_SHORT_PATH_NORMALIZATION = NEEDS_NORMALIZE + 1;
+
+  private static final Splitter WINDOWS_PATH_SPLITTER =
+      Splitter.onPattern("[\\\\/]+").omitEmptyStrings();
+
+  private final ShortPathResolver shortPathResolver;
+
+  interface ShortPathResolver {
+    String resolveShortPath(String path);
+  }
+
+  static class DefaultShortPathResolver implements ShortPathResolver {
+    @Override
+    public String resolveShortPath(String path) {
+      try {
+        return WindowsFileOperations.getLongPath(path);
+      } catch (IOException e) {
+        return path;
+      }
+    }
+  }
+
+  WindowsOsPathPolicy() {
+    this(new DefaultShortPathResolver());
+  }
+
+  WindowsOsPathPolicy(ShortPathResolver shortPathResolver) {
+    this.shortPathResolver = shortPathResolver;
+  }
+
+  @Override
+  public int needsToNormalize(String path) {
+    int n = path.length();
+    int normalizationLevel = NORMALIZED;
+    int dotCount = 0;
+    char prevChar = 0;
+    int segmentBeginIndex = 0; // The start index of the current path index
+    boolean segmentHasShortPathChar = false; // Triggers more expensive short path regex test
+    for (int i = 0; i < n; i++) {
+      char c = path.charAt(i);
+      if (isSeparator(c)) {
+        if (c == '\\') {
+          normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
+        }
+        // No need to check for '\\' here because that already causes normalization
+        if (prevChar == '/') {
+          normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
+        }
+        if (dotCount == 1 || dotCount == 2) {
+          normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
+        }
+        if (segmentHasShortPathChar) {
+          if (WindowsShortPath.isShortPath(path.substring(segmentBeginIndex, i))) {
+            normalizationLevel = Math.max(normalizationLevel, NEEDS_SHORT_PATH_NORMALIZATION);
+          }
+        }
+        segmentBeginIndex = i + 1;
+        segmentHasShortPathChar = false;
+      } else if (c == '~') {
+        // This path segment might be a Windows short path segment
+        segmentHasShortPathChar = true;
+      }
+      dotCount = c == '.' ? dotCount + 1 : 0;
+      prevChar = c;
+    }
+    if (segmentHasShortPathChar) {
+      if (WindowsShortPath.isShortPath(path.substring(segmentBeginIndex))) {
+        normalizationLevel = Math.max(normalizationLevel, NEEDS_SHORT_PATH_NORMALIZATION);
+      }
+    }
+    if ((n > 1 && isSeparator(prevChar)) || dotCount == 1 || dotCount == 2) {
+      normalizationLevel = Math.max(normalizationLevel, NEEDS_NORMALIZE);
+    }
+    return normalizationLevel;
+  }
+
+  @Override
+  public int needsToNormalizeSuffix(String normalizedSuffix) {
+    // On Windows, all bets are off because of short paths, so we have to check the entire string
+    return needsToNormalize(normalizedSuffix);
+  }
+
+  @Override
+  public String normalize(String path, int normalizationLevel) {
+    if (normalizationLevel == NORMALIZED) {
+      return path;
+    }
+    if (normalizationLevel == NEEDS_SHORT_PATH_NORMALIZATION) {
+      String resolvedPath = shortPathResolver.resolveShortPath(path);
+      if (resolvedPath != null) {
+        path = resolvedPath;
+      }
+    }
+    String[] segments = Iterables.toArray(WINDOWS_PATH_SPLITTER.splitToList(path), String.class);
+    int driveStrLength = getDriveStrLength(path);
+    boolean isAbsolute = driveStrLength > 0;
+    int segmentSkipCount = isAbsolute && driveStrLength > 1 ? 1 : 0;
+
+    StringBuilder sb = new StringBuilder(path.length());
+    if (isAbsolute) {
+      char c = path.charAt(0);
+      if (isSeparator(c)) {
+        sb.append('/');
+      } else {
+        sb.append(Character.toUpperCase(c));
+        sb.append(":/");
+      }
+    }
+    int segmentCount = Utils.removeRelativePaths(segments, segmentSkipCount, isAbsolute);
+    for (int i = 0; i < segmentCount; ++i) {
+      sb.append(segments[i]);
+      sb.append('/');
+    }
+    if (segmentCount > 0) {
+      sb.deleteCharAt(sb.length() - 1);
+    }
+    return sb.toString();
+  }
+
+  @Override
+  public int getDriveStrLength(String path) {
+    int n = path.length();
+    if (n == 0) {
+      return 0;
+    }
+    char c0 = path.charAt(0);
+    if (isSeparator(c0)) {
+      return 1;
+    }
+    if (n < 3) {
+      return 0;
+    }
+    char c1 = path.charAt(1);
+    char c2 = path.charAt(2);
+    if (isDriveLetter(c0) && c1 == ':' && isSeparator(c2)) {
+      return 3;
+    }
+    return 0;
+  }
+
+  private static boolean isDriveLetter(char c) {
+    return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'));
+  }
+
+  @Override
+  public int compare(String s1, String s2) {
+    // Windows is case-insensitive
+    return s1.compareToIgnoreCase(s2);
+  }
+
+  @Override
+  public int compare(char c1, char c2) {
+    return Character.compare(Character.toLowerCase(c1), Character.toLowerCase(c2));
+  }
+
+  @Override
+  public boolean equals(String s1, String s2) {
+    return s1.equalsIgnoreCase(s2);
+  }
+
+  @Override
+  public int hash(String s) {
+    // Windows is case-insensitive
+    return s.toLowerCase().hashCode();
+  }
+
+  @Override
+  public boolean startsWith(String path, String prefix) {
+    int pathn = path.length();
+    int prefixn = prefix.length();
+    if (pathn < prefixn) {
+      return false;
+    }
+    for (int i = 0; i < prefixn; ++i) {
+      if (Character.toLowerCase(path.charAt(i)) != Character.toLowerCase(prefix.charAt(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @Override
+  public boolean endsWith(String path, String suffix) {
+    int pathn = path.length();
+    int suffixLength = suffix.length();
+    if (pathn < suffixLength) {
+      return false;
+    }
+    int offset = pathn - suffixLength;
+    for (int i = 0; i < suffixLength; ++i) {
+      if (Character.toLowerCase(path.charAt(i + offset))
+          != Character.toLowerCase(suffix.charAt(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @Override
+  public char getSeparator() {
+    return '/';
+  }
+
+  @Override
+  public boolean isSeparator(char c) {
+    return c == '/' || c == '\\';
+  }
+
+  @Override
+  public boolean isCaseSensitive() {
+    return false;
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/WindowsPathFragment.java b/src/main/java/com/google/devtools/build/lib/vfs/WindowsPathFragment.java
deleted file mode 100644
index ac3be0f..0000000
--- a/src/main/java/com/google/devtools/build/lib/vfs/WindowsPathFragment.java
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright 2017 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import java.io.InvalidObjectException;
-import java.io.ObjectInputStream;
-
-/**
- * Abstract base class for {@link PathFragment} instances that will be allocated when Blaze is run
- * on a Windows platform.
- */
-abstract class WindowsPathFragment extends PathFragment {
-  static final Helper HELPER = new Helper();
-
-  // The drive letter of an absolute path, eg. 'C' for 'C:/foo'.
-  // We deliberately ignore "C:foo" style paths and treat them like a literal "C:foo" path segment.
-  protected final char driveLetter;
-
-  protected WindowsPathFragment(char driveLetter, String[] segments) {
-    super(segments);
-    this.driveLetter = driveLetter;
-  }
-
-  @Override
-  public String windowsVolume() {
-    return (driveLetter != '\0') ? driveLetter + ":" : "";
-  }
-
-  @Override
-  public char getDriveLetter() {
-    return driveLetter;
-  }
-
-  @Override
-  protected int computeHashCode() {
-    int h = 0;
-    for (String segment : segments) {
-      int segmentHash = segment.toLowerCase().hashCode();
-      h = h * 31 + segmentHash;
-    }
-    return h;
-  }
-
-  private static class Helper extends PathFragment.Helper {
-    private static final char SEPARATOR_CHAR = '/';
-    // TODO(laszlocsomor): Lots of internal PathFragment operations, e.g. getPathString, use the
-    // primary separator char and do not use this.
-    private static final char EXTRA_SEPARATOR_CHAR = '\\';
-
-    private static boolean isDriveLetter(char c) {
-      return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
-    }
-
-    @Override
-    PathFragment create(String path) {
-      char driveLetter =
-          path.length() >= 3
-                  && path.charAt(1) == ':'
-                  && isSeparator(path.charAt(2))
-                  && isDriveLetter(path.charAt(0))
-              ? Character.toUpperCase(path.charAt(0))
-              : '\0';
-      if (driveLetter != '\0') {
-        path = path.substring(2);
-      }
-      boolean isAbsolute = path.length() > 0 && isSeparator(path.charAt(0));
-      return isAbsolute
-          ? new AbsoluteWindowsPathFragment(driveLetter, segment(path, 1))
-          : new RelativeWindowsPathFragment(driveLetter, segment(path, 0));
-    }
-
-    @Override
-    PathFragment createAlreadyInterned(char driveLetter, boolean isAbsolute, String[] segments) {
-      return isAbsolute
-          ? new AbsoluteWindowsPathFragment(driveLetter, segments)
-          : new RelativeWindowsPathFragment(driveLetter, segments);
-    }
-
-    @Override
-    char getPrimarySeparatorChar() {
-      return SEPARATOR_CHAR;
-    }
-
-    @Override
-    boolean isSeparator(char c) {
-      return c == SEPARATOR_CHAR || c == EXTRA_SEPARATOR_CHAR;
-    }
-
-    @Override
-    boolean containsSeparatorChar(String path) {
-      // TODO(laszlocsomor): This is inefficient.
-      return path.indexOf(SEPARATOR_CHAR) != -1 || path.indexOf(EXTRA_SEPARATOR_CHAR) != -1;
-    }
-
-    @Override
-    boolean segmentsEqual(int length, String[] segments1, int offset1, String[] segments2) {
-      if ((segments1.length - offset1) < length || segments2.length < length) {
-        return false;
-      }
-      for (int i = 0; i < length; ++i) {
-        String seg1 = segments1[i + offset1];
-        String seg2 = segments2[i];
-        if ((seg1 == null) != (seg2 == null)) {
-          return false;
-        }
-        if (seg1 == null) {
-          continue;
-        }
-        // TODO(laszlocsomor): The calls to String#toLowerCase are inefficient and potentially
-        // repeated too. Also, why not use String#equalsIgnoreCase.
-        seg1 = seg1.toLowerCase();
-        seg2 = seg2.toLowerCase();
-        if (!seg1.equals(seg2)) {
-          return false;
-        }
-      }
-      return true;
-    }
-
-    @Override
-    protected int compare(PathFragment pathFragment1, PathFragment pathFragment2) {
-      if (pathFragment1.isAbsolute() != pathFragment2.isAbsolute()) {
-        return pathFragment1.isAbsolute() ? -1 : 1;
-      }
-      int cmp = Character.compare(pathFragment1.getDriveLetter(), pathFragment2.getDriveLetter());
-      if (cmp != 0) {
-        return cmp;
-      }
-      String[] segments1 = pathFragment1.segments();
-      String[] segments2 = pathFragment2.segments();
-      int len1 = segments1.length;
-      int len2 = segments2.length;
-      int n = Math.min(len1, len2);
-      for (int i = 0; i < n; i++) {
-        String seg1 = segments1[i].toLowerCase();
-        String seg2 = segments2[i].toLowerCase();
-        cmp = seg1.compareTo(seg2);
-        if (cmp != 0) {
-          return cmp;
-        }
-      }
-      return len1 - len2;
-    }
-  }
-
-  private static final class AbsoluteWindowsPathFragment extends WindowsPathFragment {
-    private AbsoluteWindowsPathFragment(char driveLetter, String[] segments) {
-      super(driveLetter, segments);
-    }
-
-    @Override
-    public boolean isAbsolute() {
-      return true;
-    }
-
-    @Override
-    protected int computeHashCode() {
-      int h = Boolean.TRUE.hashCode();
-      h = h * 31 + super.computeHashCode();
-      h = h * 31 + Character.valueOf(getDriveLetter()).hashCode();
-      return h;
-    }
-
-    @Override
-    public boolean equals(Object other) {
-      if (!(other instanceof AbsoluteWindowsPathFragment)) {
-        return false;
-      }
-      if (this == other) {
-        return true;
-      }
-      AbsoluteWindowsPathFragment otherAbsoluteWindowsPathFragment =
-          (AbsoluteWindowsPathFragment) other;
-      return this.driveLetter == otherAbsoluteWindowsPathFragment.driveLetter
-          && HELPER.segmentsEqual(this.segments, otherAbsoluteWindowsPathFragment.segments);
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected Object writeReplace() {
-      return super.writeReplace();
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected void readObject(ObjectInputStream stream) throws InvalidObjectException {
-      super.readObject(stream);
-    }
-  }
-
-  private static final class RelativeWindowsPathFragment extends WindowsPathFragment {
-    private RelativeWindowsPathFragment(char driveLetter, String[] segments) {
-      super(driveLetter, segments);
-    }
-
-    @Override
-    public boolean isAbsolute() {
-      return false;
-    }
-
-    @Override
-    protected int computeHashCode() {
-      int h = Boolean.FALSE.hashCode();
-      h = h * 31 + super.computeHashCode();
-      if (!isEmpty()) {
-        h = h * 31 + Character.valueOf(getDriveLetter()).hashCode();
-      }
-      return h;
-    }
-
-    @Override
-    public boolean equals(Object other) {
-      if (!(other instanceof RelativeWindowsPathFragment)) {
-        return false;
-      }
-      if (this == other) {
-        return true;
-      }
-      RelativeWindowsPathFragment otherRelativeWindowsPathFragment =
-          (RelativeWindowsPathFragment) other;
-      return isEmpty() && otherRelativeWindowsPathFragment.isEmpty()
-          ? true
-          : this.driveLetter == otherRelativeWindowsPathFragment.driveLetter
-              && HELPER.segmentsEqual(this.segments, otherRelativeWindowsPathFragment.segments);
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected Object writeReplace() {
-      return super.writeReplace();
-    }
-
-    // Java serialization looks for the presence of this method in the concrete class. It is not
-    // inherited from the parent class.
-    @Override
-    protected void readObject(ObjectInputStream stream) throws InvalidObjectException {
-      super.readObject(stream);
-    }
-  }
-}
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystem.java b/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystem.java
index 8fd2118..c2a52a5 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystem.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystem.java
@@ -350,7 +350,8 @@
 
     Stack<String> stack = new Stack<>();
     for (Path p = path; !isRootDirectory(p); p = p.getParentDirectory()) {
-      stack.push(p.getBaseName());
+      String name = baseNameOrWindowsDrive(p);
+      stack.push(name);
     }
 
     InMemoryContentInfo inode = rootInode;
@@ -381,6 +382,13 @@
         for (int ii = segments.size() - 1; ii >= 0; --ii) {
           stack.push(segments.get(ii)); // Note this may include ".." segments.
         }
+        // Push Windows drive if there is one
+        if (linkTarget.isAbsolute()) {
+          String driveStr = linkTarget.getDriveStr();
+          if (driveStr.length() > 1) {
+            stack.push(driveStr);
+          }
+        }
       } else {
         inode = child;
       }
@@ -412,7 +420,7 @@
   private synchronized InMemoryContentInfo getNoFollowStatOrOutOfScopeParent(Path path)
       throws IOException  {
     InMemoryDirectoryInfo dirInfo = getDirectory(path.getParentDirectory());
-    return directoryLookup(dirInfo, path.getBaseName(), /*create=*/ false, path);
+    return directoryLookup(dirInfo, baseNameOrWindowsDrive(path), /*create=*/ false, path);
   }
 
   /**
@@ -606,7 +614,7 @@
     InMemoryDirectoryInfo parent;
     synchronized (this) {
       parent = getDirectory(path.getParentDirectory());
-      InMemoryContentInfo child = parent.getChild(path.getBaseName());
+      InMemoryContentInfo child = parent.getChild(baseNameOrWindowsDrive(path));
       if (child != null) { // already exists
         if (child.isDirectory()) {
           return false;
@@ -618,7 +626,7 @@
       InMemoryDirectoryInfo newDir = new InMemoryDirectoryInfo(clock);
       newDir.addChild(".", newDir);
       newDir.addChild("..", parent);
-      insert(parent, path.getBaseName(), newDir, path);
+      insert(parent, baseNameOrWindowsDrive(path), newDir, path);
 
       return true;
     }
@@ -649,10 +657,11 @@
 
     synchronized (this) {
       InMemoryDirectoryInfo parent = getDirectory(path.getParentDirectory());
-      if (parent.getChild(path.getBaseName()) != null) {
+      if (parent.getChild(baseNameOrWindowsDrive(path)) != null) {
         throw Error.EEXIST.exception(path);
       }
-      insert(parent, path.getBaseName(), new InMemoryLinkInfo(clock, targetFragment), path);
+      insert(
+          parent, baseNameOrWindowsDrive(path), new InMemoryLinkInfo(clock, targetFragment), path);
     }
   }
 
@@ -703,11 +712,11 @@
 
     synchronized (this) {
       InMemoryDirectoryInfo parent = getDirectory(path.getParentDirectory());
-      InMemoryContentInfo child = parent.getChild(path.getBaseName());
+      InMemoryContentInfo child = parent.getChild(baseNameOrWindowsDrive(path));
       if (child.isDirectory() && child.getSize() > 2) {
         throw Error.ENOTEMPTY.exception(path);
       }
-      unlink(parent, path.getBaseName(), path);
+      unlink(parent, baseNameOrWindowsDrive(path), path);
       return true;
     }
   }
@@ -780,13 +789,13 @@
       InMemoryDirectoryInfo sourceParent = getDirectory(sourcePath.getParentDirectory());
       InMemoryDirectoryInfo targetParent = getDirectory(targetPath.getParentDirectory());
 
-      InMemoryContentInfo sourceInode = sourceParent.getChild(sourcePath.getBaseName());
+      InMemoryContentInfo sourceInode = sourceParent.getChild(baseNameOrWindowsDrive(sourcePath));
       if (sourceInode == null) {
         throw Error.ENOENT.exception(sourcePath);
       }
-      InMemoryContentInfo targetInode = targetParent.getChild(targetPath.getBaseName());
+      InMemoryContentInfo targetInode = targetParent.getChild(baseNameOrWindowsDrive(targetPath));
 
-      unlink(sourceParent, sourcePath.getBaseName(), sourcePath);
+      unlink(sourceParent, baseNameOrWindowsDrive(sourcePath), sourcePath);
       try {
         // TODO(bazel-team): (2009) test with symbolic links.
 
@@ -802,15 +811,19 @@
           } else if (sourceInode.isDirectory()) {
             throw new IOException(sourcePath + " -> " + targetPath + " (" + Error.ENOTDIR + ")");
           }
-          unlink(targetParent, targetPath.getBaseName(), targetPath);
+          unlink(targetParent, baseNameOrWindowsDrive(targetPath), targetPath);
         }
         sourceInode.movedTo(targetPath);
-        insert(targetParent, targetPath.getBaseName(), sourceInode, targetPath);
+        insert(targetParent, baseNameOrWindowsDrive(targetPath), sourceInode, targetPath);
         return;
 
       } catch (IOException e) {
         sourceInode.movedTo(sourcePath);
-        insert(sourceParent, sourcePath.getBaseName(), sourceInode, sourcePath); // restore source
+        insert(
+            sourceParent,
+            baseNameOrWindowsDrive(sourcePath),
+            sourceInode,
+            sourcePath); // restore source
         throw e;
       }
     }
@@ -828,18 +841,33 @@
     synchronized (this) {
       InMemoryDirectoryInfo linkParent = getDirectory(linkPath.getParentDirectory());
       // Same check used when creating a symbolic link
-      if (linkParent.getChild(linkPath.getBaseName()) != null) {
+      if (linkParent.getChild(baseNameOrWindowsDrive(linkPath)) != null) {
         throw Error.EEXIST.exception(linkPath);
       }
       insert(
           linkParent,
-          linkPath.getBaseName(),
-          getDirectory(originalPath.getParentDirectory()).getChild(originalPath.getBaseName()),
+          baseNameOrWindowsDrive(linkPath),
+          getDirectory(originalPath.getParentDirectory())
+              .getChild(baseNameOrWindowsDrive(originalPath)),
           linkPath);
     }
   }
 
-  private boolean isRootDirectory(Path path) {
-    return path.isRootDirectory();
+  /**
+   * On Unix the root directory is "/". On Windows there isn't one, so we reach null from
+   * getParentDirectory.
+   */
+  private boolean isRootDirectory(@Nullable Path path) {
+    return path == null || path.getPathString().equals("/");
+  }
+
+  /**
+   * Returns either the base name of the path, or the drive (if referring to a Windows drive).
+   *
+   * <p>This allows the file system to treat windows drives much like directories.
+   */
+  private static String baseNameOrWindowsDrive(Path path) {
+    String name = path.getBaseName();
+    return !name.isEmpty() ? name : path.getDriveStr();
   }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryLinkInfo.java b/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryLinkInfo.java
index 107f319..dabbbce 100644
--- a/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryLinkInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryLinkInfo.java
@@ -31,7 +31,7 @@
   InMemoryLinkInfo(Clock clock, PathFragment linkContent) {
     super(clock);
     this.linkContent = linkContent;
-    this.normalizedLinkContent = linkContent.normalize();
+    this.normalizedLinkContent = linkContent;
   }
 
   @Override
@@ -56,7 +56,7 @@
 
   @Override
   public long getSize() {
-    return linkContent.toString().length();
+    return linkContent.getSafePathString().length();
   }
 
   /**
diff --git a/src/main/java/com/google/devtools/build/lib/windows/WindowsFileSystem.java b/src/main/java/com/google/devtools/build/lib/windows/WindowsFileSystem.java
index af97e27..961465e 100644
--- a/src/main/java/com/google/devtools/build/lib/windows/WindowsFileSystem.java
+++ b/src/main/java/com/google/devtools/build/lib/windows/WindowsFileSystem.java
@@ -14,15 +14,10 @@
 package com.google.devtools.build.lib.windows;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Function;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.ThreadSafe;
 import com.google.devtools.build.lib.vfs.FileStatus;
-import com.google.devtools.build.lib.vfs.FileSystem;
 import com.google.devtools.build.lib.vfs.JavaIoFileSystem;
 import com.google.devtools.build.lib.vfs.Path;
-import com.google.devtools.build.lib.vfs.Path.PathFactory;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import com.google.devtools.build.lib.windows.jni.WindowsFileOperations;
 import java.io.File;
@@ -31,246 +26,11 @@
 import java.nio.file.Files;
 import java.nio.file.LinkOption;
 import java.nio.file.attribute.DosFileAttributes;
-import java.util.Arrays;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import javax.annotation.Nullable;
 
 /** File system implementation for Windows. */
 @ThreadSafe
 public class WindowsFileSystem extends JavaIoFileSystem {
 
-  // Properties of 8dot3 (DOS-style) short file names:
-  // - they are at most 11 characters long
-  // - they have a prefix (before "~") that is {1..6} characters long, may contain numbers, letters,
-  //   "_", even "~", and maybe even more
-  // - they have a "~" after the prefix
-  // - have {1..6} numbers after "~" (according to [1] this is only one digit, but MSDN doesn't
-  //   clarify this), the combined length up till this point is at most 8
-  // - they have an optional "." afterwards, and another {0..3} more characters
-  // - just because a path looks like a short name it isn't necessarily one; the user may create
-  //   such names and they'd resolve to themselves
-  // [1] https://en.wikipedia.org/wiki/8.3_filename#VFAT_and_Computer-generated_8.3_filenames
-  //     bullet point (3) (on 2016-12-05)
-  @VisibleForTesting
-  static final Predicate<String> SHORT_NAME_MATCHER =
-      new Predicate<String>() {
-        private final Pattern pattern = Pattern.compile("^(.{1,6})~([0-9]{1,6})(\\..{0,3}){0,1}");
-
-        @Override
-        public boolean apply(@Nullable String input) {
-          Matcher m = pattern.matcher(input);
-          return input.length() <= 12
-              && m.matches()
-              && m.groupCount() >= 2
-              && (m.group(1).length() + m.group(2).length()) < 8; // the "~" makes it at most 8
-        }
-      };
-
-  /** Resolves DOS-style, shortened path names, returning the last segment's long form. */
-  private static final Function<String, String> WINDOWS_SHORT_PATH_RESOLVER =
-      path -> {
-        try {
-          // Since Path objects are created hierarchically, we know for sure that every segment of
-          // the path, except the last one, is already canonicalized, so we can return just that.
-          // Plus the returned value is passed to Path.getChild so we must not return a full
-          // path here.
-          return PathFragment.create(WindowsFileOperations.getLongPath(path)).getBaseName();
-        } catch (IOException e) {
-          return null;
-        }
-      };
-
-  @VisibleForTesting
-  private enum WindowsPathFactory implements PathFactory {
-    INSTANCE {
-      @Override
-      public Path createRootPath(FileSystem filesystem) {
-        return new WindowsPath(filesystem, PathFragment.ROOT_DIR, null);
-      }
-
-      @Override
-      public Path createChildPath(Path parent, String childName) {
-        Preconditions.checkState(parent instanceof WindowsPath);
-        return new WindowsPath(parent.getFileSystem(), childName, (WindowsPath) parent);
-      }
-
-      @Override
-      public Path getCachedChildPathInternal(Path path, String childName) {
-        return WindowsPathFactory.getCachedChildPathInternalImpl(
-            path, childName, WINDOWS_SHORT_PATH_RESOLVER);
-      }
-    };
-
-    private static Path getCachedChildPathInternalImpl(
-        Path parent, String child, Function<String, String> resolver) {
-      if (parent != null && parent.isRootDirectory()) {
-        // This is a top-level directory. It must be a drive name ("C:" or "c").
-        if (WindowsPath.isWindowsVolumeName(child)) {
-          child = WindowsPath.getDriveLetter((WindowsPath) parent, child) + ":";
-        } else {
-          throw new IllegalArgumentException("Cannot create Unix-style paths on Windows.");
-        }
-      }
-
-      String resolvedChild = child;
-      if (parent != null && !parent.isRootDirectory() && SHORT_NAME_MATCHER.apply(child)) {
-        String pathString = parent.getPathString();
-        if (!pathString.endsWith("/")) {
-          pathString += "/";
-        }
-        pathString += child;
-        resolvedChild = resolver.apply(pathString);
-      }
-      return Path.getCachedChildPathInternal(
-          parent,
-          // If resolution succeeded, or we didn't attempt to resolve, then `resolvedChild` has the
-          // child name. If it's null, then resolution failed; use the unresolved child name in that
-          // case.
-          resolvedChild != null ? resolvedChild : child,
-          // If resolution failed, likely because the path doesn't exist, then do not cache the
-          // child. If we did, then in case the path later came into existence, we'd have a stale
-          // cache entry.
-          /* cacheable */ resolvedChild != null);
-    }
-
-    /**
-     * Creates a {@link PathFactory} with a mock shortname resolver.
-     *
-     * <p>The factory works exactly like the actual one ({@link WindowsPathFactory#INSTANCE}) except
-     * it's using the mock resolver.
-     */
-    public static PathFactory createForTesting(final Function<String, String> mockResolver) {
-      return new PathFactory() {
-        @Override
-        public Path createRootPath(FileSystem filesystem) {
-          return INSTANCE.createRootPath(filesystem);
-        }
-
-        @Override
-        public Path createChildPath(Path parent, String childName) {
-          return INSTANCE.createChildPath(parent, childName);
-        }
-
-        @Override
-        public Path getCachedChildPathInternal(Path path, String childName) {
-          return WindowsPathFactory.getCachedChildPathInternalImpl(path, childName, mockResolver);
-        }
-      };
-    }
-  }
-
-  /** A windows-specific subclass of Path. */
-  @VisibleForTesting
-  protected static final class WindowsPath extends Path {
-
-    // The drive letter is '\0' if and only if this Path is the filesystem root "/".
-    private char driveLetter;
-
-    private WindowsPath(FileSystem fileSystem) {
-      super(fileSystem);
-      this.driveLetter = '\0';
-    }
-
-    private WindowsPath(FileSystem fileSystem, String name, WindowsPath parent) {
-      super(fileSystem, name, parent);
-      this.driveLetter = getDriveLetter(parent, name);
-    }
-
-    @Override
-    protected void buildPathString(StringBuilder result) {
-      if (isRootDirectory()) {
-        result.append(PathFragment.ROOT_DIR);
-      } else {
-        if (isTopLevelDirectory()) {
-          result.append(driveLetter).append(':').append(PathFragment.SEPARATOR_CHAR);
-        } else {
-          WindowsPath parent = (WindowsPath) getParentDirectory();
-          parent.buildPathString(result);
-          if (!parent.isTopLevelDirectory()) {
-            result.append(PathFragment.SEPARATOR_CHAR);
-          }
-          result.append(getBaseName());
-        }
-      }
-    }
-
-    @Override
-    public void reinitializeAfterDeserialization() {
-      Preconditions.checkState(
-          getParentDirectory().isRootDirectory() || getParentDirectory() instanceof WindowsPath);
-      this.driveLetter =
-          (getParentDirectory() != null) ? ((WindowsPath) getParentDirectory()).driveLetter : '\0';
-    }
-
-    @Override
-    public boolean isMaybeRelativeTo(Path ancestorCandidate) {
-      Preconditions.checkState(ancestorCandidate instanceof WindowsPath);
-      return ancestorCandidate.isRootDirectory()
-          || driveLetter == ((WindowsPath) ancestorCandidate).driveLetter;
-    }
-
-    @Override
-    public boolean isTopLevelDirectory() {
-      return isRootDirectory() || getParentDirectory().isRootDirectory();
-    }
-
-    @Override
-    public PathFragment asFragment() {
-      String[] segments = getSegments();
-      if (segments.length > 0) {
-        // Strip off the first segment that contains the volume name.
-        segments = Arrays.copyOfRange(segments, 1, segments.length);
-      }
-
-      return PathFragment.create(driveLetter, true, segments);
-    }
-
-    @Override
-    protected Path getRootForRelativePathComputation(PathFragment relative) {
-      Path result = this;
-      if (relative.isAbsolute()) {
-        result = getFileSystem().getRootDirectory();
-        if (!relative.windowsVolume().isEmpty()) {
-          result = result.getRelative(relative.windowsVolume());
-        }
-      }
-      return result;
-    }
-
-    private static boolean isWindowsVolumeName(String name) {
-      return (name.length() == 1 || (name.length() == 2 && name.charAt(1) == ':'))
-          && Character.isLetter(name.charAt(0));
-    }
-
-    private static char getDriveLetter(WindowsPath parent, String name) {
-      if (parent == null) {
-        return '\0';
-      } else {
-        if (parent.isRootDirectory()) {
-          Preconditions.checkState(
-              isWindowsVolumeName(name),
-              "top-level directory on Windows must be a drive (name = '%s')",
-              name);
-          return Character.toUpperCase(name.charAt(0));
-        } else {
-          return parent.driveLetter;
-        }
-      }
-    }
-
-    @VisibleForTesting
-    @Override
-    protected synchronized void applyToChildren(Predicate<Path> function) {
-      super.applyToChildren(function);
-    }
-  }
-
-  @VisibleForTesting
-  static PathFactory getPathFactoryForTesting(Function<String, String> mockResolver) {
-    return WindowsPathFactory.createForTesting(mockResolver);
-  }
-
   public static final LinkOption[] NO_OPTIONS = new LinkOption[0];
   public static final LinkOption[] NO_FOLLOW = new LinkOption[] {LinkOption.NOFOLLOW_LINKS};
 
@@ -281,11 +41,6 @@
   }
 
   @Override
-  protected PathFactory getPathFactory() {
-    return WindowsPathFactory.INSTANCE;
-  }
-
-  @Override
   public String getFileSystemType(Path path) {
     // TODO(laszlocsomor): implement this properly, i.e. actually query this information from
     // somewhere (java.nio.Filesystem? System.getProperty? implement JNI method and use WinAPI?).
diff --git a/src/main/java/com/google/devtools/build/lib/windows/WindowsSubprocessFactory.java b/src/main/java/com/google/devtools/build/lib/windows/WindowsSubprocessFactory.java
index a698840..af591cc 100644
--- a/src/main/java/com/google/devtools/build/lib/windows/WindowsSubprocessFactory.java
+++ b/src/main/java/com/google/devtools/build/lib/windows/WindowsSubprocessFactory.java
@@ -83,9 +83,7 @@
     // If it's not absolute, then it cannot be longer than MAX_PATH, since MAX_PATH also limits the
     // length of file names.
     PathFragment argv0fragment = PathFragment.create(argv0);
-    return (argv0fragment.isAbsolute())
-        ? argv0fragment.normalize().getPathString().replace('/', '\\')
-        : argv0;
+    return (argv0fragment.isAbsolute()) ? argv0fragment.getPathString().replace('/', '\\') : argv0;
   }
 
   private String getRedirectPath(StreamAction action, File file) {
diff --git a/src/test/java/com/google/devtools/build/lib/BUILD b/src/test/java/com/google/devtools/build/lib/BUILD
index 7cbf304..538cb8f 100644
--- a/src/test/java/com/google/devtools/build/lib/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/BUILD
@@ -9,8 +9,7 @@
 CROSS_PLATFORM_WINDOWS_TESTS = [
     "util/DependencySetWindowsTest.java",
     "vfs/PathFragmentWindowsTest.java",
-    "vfs/WindowsLocalPathTest.java",
-    "windows/PathWindowsTest.java",
+    "vfs/WindowsPathTest.java",
 ]
 
 # Tests for Windows-specific functionality that run on Windows.
@@ -18,7 +17,6 @@
     ["windows/*.java"],
     exclude = [
         "windows/MockSubprocess.java",
-        "windows/PathWindowsTest.java",
     ],
 )
 
@@ -374,6 +372,7 @@
     deps = [
         ":guava_junit_truth",
         ":vfs_filesystem_test",
+        "//src/main/java/com/google/devtools/build/lib:os_util",
         "//src/main/java/com/google/devtools/build/lib/vfs",
     ],
 )
@@ -401,7 +400,7 @@
 # systems
 java_test(
     name = "windows_test",
-    srcs = CROSS_PLATFORM_WINDOWS_TESTS + ["vfs/LocalPathAbstractTest.java"],
+    srcs = CROSS_PLATFORM_WINDOWS_TESTS + ["vfs/PathAbstractTest.java"],
     jvm_flags = [
         "-Dblaze.os=Windows",
         "-Dbazel.windows_unix_root=C:/fake/msys",
diff --git a/src/test/java/com/google/devtools/build/lib/actions/ArtifactTest.java b/src/test/java/com/google/devtools/build/lib/actions/ArtifactTest.java
index 363bae9..f26d00e 100644
--- a/src/test/java/com/google/devtools/build/lib/actions/ArtifactTest.java
+++ b/src/test/java/com/google/devtools/build/lib/actions/ArtifactTest.java
@@ -27,6 +27,7 @@
 import com.google.devtools.build.lib.rules.java.JavaSemantics;
 import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodecAdapter;
 import com.google.devtools.build.lib.skyframe.serialization.testutils.ObjectCodecTester;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
 import com.google.devtools.build.lib.testutil.Scratch;
 import com.google.devtools.build.lib.vfs.Path;
 import com.google.devtools.build.lib.vfs.PathFragment;
@@ -58,7 +59,7 @@
     Path f1 = scratch.file("/exec/dir/file.ext");
     Path bogusDir = scratch.file("/exec/dir/bogus");
     try {
-      new Artifact(f1, ArtifactRoot.asDerivedRoot(execDir, bogusDir), f1.relativeTo(execDir));
+      new Artifact(ArtifactRoot.asDerivedRoot(execDir, bogusDir), f1.relativeTo(execDir));
       fail("Expected IllegalArgumentException constructing artifact with a bad root dir");
     } catch (IllegalArgumentException expected) {}
   }
@@ -93,7 +94,7 @@
   @Test
   public void testRootPrefixedExecPath_normal() throws IOException {
     Path f1 = scratch.file("/exec/root/dir/file.ext");
-    Artifact a1 = new Artifact(f1, rootDir, f1.relativeTo(execDir));
+    Artifact a1 = new Artifact(rootDir, f1.relativeTo(execDir));
     assertThat(Artifact.asRootPrefixedExecPath(a1)).isEqualTo("root:dir/file.ext");
   }
 
@@ -109,9 +110,10 @@
   public void testRootPrefixedExecPath_nullRootDir() throws IOException {
     Path f1 = scratch.file("/exec/dir/file.ext");
     try {
-      new Artifact(f1, null, f1.relativeTo(execDir));
-      fail("Expected IllegalArgumentException creating artifact with null root");
-    } catch (IllegalArgumentException expected) {}
+      new Artifact(null, f1.relativeTo(execDir));
+      fail("Expected NullPointerException creating artifact with null root");
+    } catch (NullPointerException expected) {
+    }
   }
 
   @Test
@@ -119,9 +121,9 @@
     Path f1 = scratch.file("/exec/root/dir/file1.ext");
     Path f2 = scratch.file("/exec/root/dir/dir/file2.ext");
     Path f3 = scratch.file("/exec/root/dir/dir/dir/file3.ext");
-    Artifact a1 = new Artifact(f1, rootDir, f1.relativeTo(execDir));
-    Artifact a2 = new Artifact(f2, rootDir, f2.relativeTo(execDir));
-    Artifact a3 = new Artifact(f3, rootDir, f3.relativeTo(execDir));
+    Artifact a1 = new Artifact(rootDir, f1.relativeTo(execDir));
+    Artifact a2 = new Artifact(rootDir, f2.relativeTo(execDir));
+    Artifact a3 = new Artifact(rootDir, f3.relativeTo(execDir));
     List<String> strings = new ArrayList<>();
     Artifact.addRootPrefixedExecPaths(Lists.newArrayList(a1, a2, a3), strings);
     assertThat(strings).containsExactly(
@@ -283,10 +285,9 @@
 
   @Test
   public void testToDetailString() throws Exception {
-    Path execRoot = scratch.getFileSystem().getPath("/");
+    Path execRoot = scratch.getFileSystem().getPath("/a");
     Artifact a =
         new Artifact(
-            scratch.file("/a/b/c"),
             ArtifactRoot.asDerivedRoot(execRoot, scratch.dir("/a/b")),
             PathFragment.create("b/c"));
     assertThat(a.toDetailString()).isEqualTo("[[/a]b]c");
@@ -294,17 +295,12 @@
 
   @Test
   public void testWeirdArtifact() throws Exception {
-    try {
-      Path execRoot = scratch.getFileSystem().getPath("/");
-      new Artifact(
-          scratch.file("/a/b/c"),
-          ArtifactRoot.asDerivedRoot(execRoot, scratch.dir("/a")),
-          PathFragment.create("c"));
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertThat(e).hasMessage(
-          "c: illegal execPath doesn't end with b/c at /a/b/c with root /a[derived]");
-    }
+    Path execRoot = scratch.getFileSystem().getPath("/");
+    MoreAsserts.expectThrows(
+        IllegalArgumentException.class,
+        () ->
+            new Artifact(
+                ArtifactRoot.asDerivedRoot(execRoot, scratch.dir("/a")), PathFragment.create("c")));
   }
 
   @Test
@@ -319,25 +315,23 @@
 
   @Test
   public void testSerializeToStringWithExecPath() throws Exception {
-    Path execRoot = scratch.getFileSystem().getPath("/");
-    Path path = scratch.file("/aaa/bbb/ccc");
+    Path execRoot = scratch.getFileSystem().getPath("/aaa");
     ArtifactRoot root = ArtifactRoot.asDerivedRoot(execRoot, scratch.dir("/aaa/bbb"));
     PathFragment execPath = PathFragment.create("bbb/ccc");
 
-    assertThat(new Artifact(path, root, execPath).serializeToString()).isEqualTo("bbb/ccc /3");
+    assertThat(new Artifact(root, execPath).serializeToString()).isEqualTo("bbb/ccc /3");
   }
 
   @Test
   public void testSerializeToStringWithOwner() throws Exception {
-    Path execRoot = scratch.getFileSystem().getPath("/");
+    Path execRoot = scratch.getFileSystem().getPath("/aa");
     assertThat(
             new Artifact(
-                    scratch.file("/aa/b/c"),
-                    ArtifactRoot.asDerivedRoot(execRoot, scratch.dir("/aa")),
+                    ArtifactRoot.asDerivedRoot(execRoot, scratch.dir("/aa/b")),
                     PathFragment.create("b/c"),
                     new LabelArtifactOwner(Label.parseAbsoluteUnchecked("//foo:bar")))
                 .serializeToString())
-        .isEqualTo("b/c /3 //foo:bar");
+        .isEqualTo("b/c /1 //foo:bar");
   }
 
   @Test
@@ -349,10 +343,9 @@
             new Artifact(
                 PathFragment.create("src/b"), ArtifactRoot.asSourceRoot(Root.fromPath(execDir))),
             new Artifact(
-                scratch.file("/src/c"),
                 ArtifactRoot.asDerivedRoot(
                     scratch.getFileSystem().getPath("/"), scratch.dir("/src")),
-                PathFragment.create("c"),
+                PathFragment.create("src/c"),
                 new LabelArtifactOwner(Label.parseAbsoluteUnchecked("//foo:bar"))))
         .buildAndRunTests();
   }
@@ -387,7 +380,6 @@
   public void testIsSourceArtifact() throws Exception {
     assertThat(
             new Artifact(
-                    scratch.file("/src/foo.cc"),
                     ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/"))),
                     PathFragment.create("src/foo.cc"))
                 .isSourceArtifact())
diff --git a/src/test/java/com/google/devtools/build/lib/actions/CustomCommandLineTest.java b/src/test/java/com/google/devtools/build/lib/actions/CustomCommandLineTest.java
index 085415cf..b9f341a 100644
--- a/src/test/java/com/google/devtools/build/lib/actions/CustomCommandLineTest.java
+++ b/src/test/java/com/google/devtools/build/lib/actions/CustomCommandLineTest.java
@@ -984,7 +984,6 @@
   private SpecialArtifact createTreeArtifact(String rootRelativePath) {
     PathFragment relpath = PathFragment.create(rootRelativePath);
     return new SpecialArtifact(
-        rootDir.getRoot().getRelative(relpath),
         rootDir,
         rootDir.getExecPath().getRelative(relpath),
         ArtifactOwner.NullArtifactOwner.INSTANCE,
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/actions/ParamFileWriteActionTest.java b/src/test/java/com/google/devtools/build/lib/analysis/actions/ParamFileWriteActionTest.java
index 4c9d2dd..8678d50 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/actions/ParamFileWriteActionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/actions/ParamFileWriteActionTest.java
@@ -111,7 +111,6 @@
   private SpecialArtifact createTreeArtifact(String rootRelativePath) {
     PathFragment relpath = PathFragment.create(rootRelativePath);
     return new SpecialArtifact(
-        rootDir.getRoot().getRelative(relpath),
         rootDir,
         rootDir.getExecPath().getRelative(relpath),
         ArtifactOwner.NullArtifactOwner.INSTANCE,
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactActionTest.java b/src/test/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactActionTest.java
index 345aa97..1ce4fd5 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactActionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/actions/PopulateTreeArtifactActionTest.java
@@ -346,7 +346,6 @@
   private SpecialArtifact createTreeArtifact(String rootRelativePath) {
     PathFragment relpath = PathFragment.create(rootRelativePath);
     return new SpecialArtifact(
-        root.getRoot().getRelative(relpath),
         root,
         root.getExecPath().getRelative(relpath),
         ArtifactOwner.NullArtifactOwner.INSTANCE,
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/actions/SpawnActionTemplateTest.java b/src/test/java/com/google/devtools/build/lib/analysis/actions/SpawnActionTemplateTest.java
index ad03fe7..17588a6 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/actions/SpawnActionTemplateTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/actions/SpawnActionTemplateTest.java
@@ -325,7 +325,6 @@
   private SpecialArtifact createTreeArtifact(String rootRelativePath) {
     PathFragment relpath = PathFragment.create(rootRelativePath);
     return new SpecialArtifact(
-        root.getRoot().getRelative(relpath),
         root,
         root.getExecPath().getRelative(relpath),
         ArtifactOwner.NullArtifactOwner.INSTANCE,
diff --git a/src/test/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactoryTest.java b/src/test/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactoryTest.java
index ca8bef9..5e22269 100644
--- a/src/test/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactoryTest.java
+++ b/src/test/java/com/google/devtools/build/lib/buildeventstream/transports/BuildEventTransportFactoryTest.java
@@ -133,6 +133,13 @@
     assertThat(transports).isEmpty();
   }
 
+  @Test
+  public void testPathToUriString() {
+    // See https://blogs.msdn.microsoft.com/ie/2006/12/06/file-uris-in-windows/
+    assertThat(BuildEventTransportFactory.pathToUriString("C:/Temp/Foo Bar.txt"))
+        .isEqualTo("file:///C:/Temp/Foo%20Bar.txt");
+  }
+
   private void sendEventsAndClose(BuildEvent event, Iterable<BuildEventTransport> transports)
       throws IOException{
     for (BuildEventTransport transport : transports) {
diff --git a/src/test/java/com/google/devtools/build/lib/pkgcache/PathPackageLocatorTest.java b/src/test/java/com/google/devtools/build/lib/pkgcache/PathPackageLocatorTest.java
index 1cac353..a9b224f 100644
--- a/src/test/java/com/google/devtools/build/lib/pkgcache/PathPackageLocatorTest.java
+++ b/src/test/java/com/google/devtools/build/lib/pkgcache/PathPackageLocatorTest.java
@@ -338,7 +338,7 @@
         workspace.getRelative("foo"),
         BazelSkyframeExecutorConstants.BUILD_FILES_BY_PRIORITY);
     assertThat(eventCollector.count()).isSameAs(1);
-    assertContainsEvent("The package path element './foo' will be taken relative");
+    assertContainsEvent("The package path element 'foo' will be taken relative");
   }
 
   /** Regression test for bug: "IllegalArgumentException in PathPackageLocator.create()" */
diff --git a/src/test/java/com/google/devtools/build/lib/rules/android/ResourceTestBase.java b/src/test/java/com/google/devtools/build/lib/rules/android/ResourceTestBase.java
index 1bd5bed..9ea174a 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/android/ResourceTestBase.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/android/ResourceTestBase.java
@@ -183,6 +183,6 @@
   public Artifact getResource(String pathString) {
     Path path = fileSystem.getPath("/" + RESOURCE_ROOT + "/" + pathString);
     return new Artifact(
-        path, root, root.getExecPath().getRelative(root.getRoot().relativize(path)), OWNER);
+        root, root.getExecPath().getRelative(root.getRoot().relativize(path)), OWNER);
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/CcLibraryConfiguredTargetTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/CcLibraryConfiguredTargetTest.java
index 4d7c3fc..36fcadf 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/CcLibraryConfiguredTargetTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/CcLibraryConfiguredTargetTest.java
@@ -1066,7 +1066,7 @@
     checkError(
         "root",
         "a",
-        "The include path 'd/../../somewhere' references a path outside of the execution root.",
+        "The include path '../somewhere' references a path outside of the execution root.",
         "cc_library(name='a', srcs=['a.cc'], copts=['-Id/../../somewhere'])");
   }
 
diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionTest.java
index db56bd5..f7bf8eb 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/CppLinkActionTest.java
@@ -524,10 +524,6 @@
 
   public Artifact getOutputArtifact(String relpath) {
     return new Artifact(
-        getTargetConfiguration()
-            .getBinDirectory(RepositoryName.MAIN)
-            .getRoot()
-            .getRelative(relpath),
         getTargetConfiguration().getBinDirectory(RepositoryName.MAIN),
         getTargetConfiguration().getBinFragment().getRelative(relpath));
   }
@@ -672,9 +668,7 @@
     FileSystem fs = scratch.getFileSystem();
     Path execRoot = fs.getPath(TestUtils.tmpDir());
     PathFragment execPath = PathFragment.create("out").getRelative(name);
-    Path path = execRoot.getRelative(execPath);
     return new SpecialArtifact(
-        path,
         ArtifactRoot.asDerivedRoot(execRoot, execRoot.getRelative("out")),
         execPath,
         ArtifactOwner.NullArtifactOwner.INSTANCE,
diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java
index 4a3714b..e45e32f 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java
@@ -186,7 +186,7 @@
     assertThat(ccProvider.getTargetCpu()).isEqualTo("piii");
     assertThat(ccProvider.getTargetGnuSystemName()).isEqualTo("target-system-name");
 
-    assertThat(toolchain.getToolPathFragment(Tool.AR)).isEqualTo(getToolPath("/path-to-ar"));
+    assertThat(toolchain.getToolPathFragment(Tool.AR)).isEqualTo(getToolPath("path-to-ar"));
 
     assertThat(ccProvider.getAbi()).isEqualTo("abi-version");
     assertThat(ccProvider.getAbiGlibcVersion()).isEqualTo("abi-libc-version");
@@ -199,7 +199,7 @@
     assertThat(ccProvider.supportsFission()).isTrue();
 
     assertThat(ccProvider.getBuiltInIncludeDirectories())
-        .containsExactly(getToolPath("/system-include-dir"));
+        .containsExactly(getToolPath("system-include-dir"));
     assertThat(ccProvider.getSysroot()).isNull();
 
     assertThat(CppHelper.getCompilerOptions(toolchain, ccProvider, NO_FEATURES))
@@ -238,8 +238,8 @@
                     "CC_FLAGS", "")
                 .entrySet());
 
-    assertThat(toolchain.getToolPathFragment(Tool.LD)).isEqualTo(getToolPath("/path-to-ld"));
-    assertThat(toolchain.getToolPathFragment(Tool.DWP)).isEqualTo(getToolPath("/path-to-dwp"));
+    assertThat(toolchain.getToolPathFragment(Tool.LD)).isEqualTo(getToolPath("path-to-ld"));
+    assertThat(toolchain.getToolPathFragment(Tool.DWP)).isEqualTo(getToolPath("path-to-dwp"));
   }
 
   /**
@@ -605,7 +605,7 @@
                 .entrySet());
     assertThat(ccProviderA.getBuiltInIncludeDirectories())
         .containsExactly(
-            getToolPath("/system-include-dir-A-1"), getToolPath("/system-include-dir-A-2"))
+            getToolPath("system-include-dir-A-1"), getToolPath("system-include-dir-A-2"))
         .inOrder();
     assertThat(ccProviderA.getSysroot()).isEqualTo(PathFragment.create("some"));
 
@@ -682,9 +682,7 @@
     PackageIdentifier packageIdentifier =
         PackageIdentifier.create(
             TestConstants.TOOLS_REPOSITORY,
-            PathFragment.create(
-                PathFragment.create(TestConstants.MOCK_CC_CROSSTOOL_PATH),
-                PathFragment.create(path)));
+            PathFragment.create(TestConstants.MOCK_CC_CROSSTOOL_PATH).getRelative(path));
     return packageIdentifier.getPathUnderExecRoot();
   }
 
diff --git a/src/test/java/com/google/devtools/build/lib/rules/objc/HeaderThinningTest.java b/src/test/java/com/google/devtools/build/lib/rules/objc/HeaderThinningTest.java
index cdd9d72..ee9b9fb 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/objc/HeaderThinningTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/objc/HeaderThinningTest.java
@@ -189,7 +189,6 @@
   private Artifact getTreeArtifact(String name) {
     Artifact treeArtifactBase = getSourceArtifact(name);
     return new SpecialArtifact(
-        treeArtifactBase.getPath(),
         treeArtifactBase.getRoot(),
         treeArtifactBase.getExecPath(),
         treeArtifactBase.getArtifactOwner(),
diff --git a/src/test/java/com/google/devtools/build/lib/rules/proto/ProtoCompileActionBuilderTest.java b/src/test/java/com/google/devtools/build/lib/rules/proto/ProtoCompileActionBuilderTest.java
index d21acf1..bc0ebaa 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/proto/ProtoCompileActionBuilderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/proto/ProtoCompileActionBuilderTest.java
@@ -347,7 +347,6 @@
 
   private Artifact artifact(String ownerLabel, String path) {
     return new Artifact(
-        root.getRoot().getRelative(path),
         root,
         root.getExecPath().getRelative(path),
         new LabelArtifactOwner(Label.parseAbsoluteUnchecked(ownerLabel)));
@@ -356,7 +355,6 @@
   /** Creates a dummy artifact with the given path, that actually resides in /out/<path>. */
   private Artifact derivedArtifact(String ownerLabel, String path) {
     return new Artifact(
-        derivedRoot.getRoot().getRelative(path),
         derivedRoot,
         derivedRoot.getExecPath().getRelative(path),
         new LabelArtifactOwner(Label.parseAbsoluteUnchecked(ownerLabel)));
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/ActionTemplateExpansionFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/ActionTemplateExpansionFunctionTest.java
index 7c86478..f8b6a9d 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/ActionTemplateExpansionFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/ActionTemplateExpansionFunctionTest.java
@@ -39,7 +39,6 @@
 import com.google.devtools.build.lib.events.NullEventHandler;
 import com.google.devtools.build.lib.pkgcache.PathPackageLocator;
 import com.google.devtools.build.lib.testutil.FoundationTestCase;
-import com.google.devtools.build.lib.vfs.Path;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import com.google.devtools.build.lib.vfs.Root;
 import com.google.devtools.build.skyframe.EvaluationResult;
@@ -205,9 +204,7 @@
 
   private SpecialArtifact createTreeArtifact(String path) {
     PathFragment execPath = PathFragment.create("out").getRelative(path);
-    Path fullPath = rootDirectory.getRelative(execPath);
     return new SpecialArtifact(
-        fullPath,
         ArtifactRoot.asDerivedRoot(rootDirectory, rootDirectory.getRelative("out")),
         execPath,
         ArtifactOwner.NullArtifactOwner.INSTANCE,
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/ArtifactFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/ArtifactFunctionTest.java
index 1699fc2..21b0a10 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/ArtifactFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/ArtifactFunctionTest.java
@@ -250,10 +250,8 @@
 
   private Artifact createDerivedArtifact(String path) {
     PathFragment execPath = PathFragment.create("out").getRelative(path);
-    Path fullPath = root.getRelative(execPath);
     Artifact output =
         new Artifact(
-            fullPath,
             ArtifactRoot.asDerivedRoot(root, root.getRelative("out")),
             execPath,
             ALL_OWNER);
@@ -264,9 +262,7 @@
   private Artifact createMiddlemanArtifact(String path) {
     ArtifactRoot middlemanRoot =
         ArtifactRoot.middlemanRoot(middlemanPath, middlemanPath.getRelative("out"));
-    Path fullPath = middlemanRoot.getRoot().getRelative(path);
-    return new Artifact(
-        fullPath, middlemanRoot, middlemanRoot.getExecPath().getRelative(path), ALL_OWNER);
+    return new Artifact(middlemanRoot, middlemanRoot.getExecPath().getRelative(path), ALL_OWNER);
   }
 
   private SpecialArtifact createDerivedTreeArtifactWithAction(String path) {
@@ -277,9 +273,7 @@
 
   private SpecialArtifact createDerivedTreeArtifactOnly(String path) {
     PathFragment execPath = PathFragment.create("out").getRelative(path);
-    Path fullPath = root.getRelative(execPath);
     return new SpecialArtifact(
-        fullPath,
         ArtifactRoot.asDerivedRoot(root, root.getRelative("out")),
         execPath,
         ALL_OWNER,
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/FilesystemValueCheckerTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/FilesystemValueCheckerTest.java
index f7a989a..48ccd7e 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/FilesystemValueCheckerTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/FilesystemValueCheckerTest.java
@@ -620,7 +620,6 @@
     outputDir.createDirectory();
     ArtifactRoot derivedRoot = ArtifactRoot.asDerivedRoot(fs.getPath("/"), outputDir);
     return new SpecialArtifact(
-        outputPath,
         derivedRoot,
         derivedRoot.getExecPath().getRelative(derivedRoot.getRoot().relativize(outputPath)),
         ArtifactOwner.NullArtifactOwner.INSTANCE,
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/RecursiveFilesystemTraversalFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/RecursiveFilesystemTraversalFunctionTest.java
index 872de47..25b510e 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/RecursiveFilesystemTraversalFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/RecursiveFilesystemTraversalFunctionTest.java
@@ -171,10 +171,8 @@
 
   private Artifact derivedArtifact(String path) {
     PathFragment execPath = PathFragment.create("out").getRelative(path);
-    Path fullPath = rootDirectory.getRelative(execPath);
     Artifact output =
         new Artifact(
-            fullPath,
             ArtifactRoot.asDerivedRoot(rootDirectory, rootDirectory.getRelative("out")),
             execPath);
     return output;
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/TimestampBuilderTestCase.java b/src/test/java/com/google/devtools/build/lib/skyframe/TimestampBuilderTestCase.java
index 3b39d03..e63d1ea 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/TimestampBuilderTestCase.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/TimestampBuilderTestCase.java
@@ -336,9 +336,7 @@
   Artifact createDerivedArtifact(FileSystem fs, String name) {
     Path execRoot = fs.getPath(TestUtils.tmpDir());
     PathFragment execPath = PathFragment.create("out").getRelative(name);
-    Path path = execRoot.getRelative(execPath);
     return new Artifact(
-        path,
         ArtifactRoot.asDerivedRoot(execRoot, execRoot.getRelative("out")),
         execPath,
         ACTION_LOOKUP_KEY);
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactBuildTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactBuildTest.java
index 30b6c4c..5d24b9e 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactBuildTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactBuildTest.java
@@ -1192,9 +1192,7 @@
     FileSystem fs = scratch.getFileSystem();
     Path execRoot = fs.getPath(TestUtils.tmpDir());
     PathFragment execPath = PathFragment.create("out").getRelative(name);
-    Path path = execRoot.getRelative(execPath);
     return new SpecialArtifact(
-        path,
         ArtifactRoot.asDerivedRoot(execRoot, execRoot.getRelative("out")),
         execPath,
         ACTION_LOOKUP_KEY,
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactMetadataTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactMetadataTest.java
index 96bc4be..9e3fd39 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactMetadataTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/TreeArtifactMetadataTest.java
@@ -204,7 +204,6 @@
     Path fullPath = root.getRelative(execPath);
     SpecialArtifact output =
         new SpecialArtifact(
-            fullPath,
             ArtifactRoot.asDerivedRoot(root, root.getRelative("out")),
             execPath,
             ALL_OWNER,
diff --git a/src/test/java/com/google/devtools/build/lib/unix/UnixPathEqualityTest.java b/src/test/java/com/google/devtools/build/lib/unix/UnixPathEqualityTest.java
index d77b10f..2d81e13 100644
--- a/src/test/java/com/google/devtools/build/lib/unix/UnixPathEqualityTest.java
+++ b/src/test/java/com/google/devtools/build/lib/unix/UnixPathEqualityTest.java
@@ -14,9 +14,9 @@
 package com.google.devtools.build.lib.unix;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.fail;
 
 import com.google.common.testing.EqualsTester;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
 import com.google.devtools.build.lib.vfs.FileSystem;
 import com.google.devtools.build.lib.vfs.Path;
 import org.junit.Before;
@@ -93,25 +93,8 @@
     Path a = unixFs.getPath("/a");
     Path b = otherUnixFs.getPath("/b");
 
-    try {
-      a.renameTo(b);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertThat(e).hasMessageThat().contains("different filesystems");
-    }
-
-    try {
-      a.relativeTo(b);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertThat(e).hasMessageThat().contains("different filesystems");
-    }
-
-    try {
-      a.createSymbolicLink(b);
-      fail();
-    } catch (IllegalArgumentException e) {
-      assertThat(e).hasMessageThat().contains("different filesystems");
-    }
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> a.renameTo(b));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> a.relativeTo(b));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> a.createSymbolicLink(b));
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java
index e8896bb..47ae76a 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java
@@ -14,7 +14,6 @@
 package com.google.devtools.build.lib.vfs;
 
 import static com.google.common.truth.Truth.assertThat;
-import static com.google.common.truth.Truth.assertWithMessage;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.fail;
 
@@ -789,23 +788,6 @@
     assertThat(xNonEmptyDirectoryFoo.isFile()).isTrue();
   }
 
-  @Test
-  public void testCannotRemoveRoot() {
-    Path rootDirectory = testFS.getRootDirectory();
-    try {
-      rootDirectory.delete();
-      fail();
-    } catch (IOException e) {
-      String msg = e.getMessage();
-      assertWithMessage(String.format("got %s want EBUSY or ENOTEMPTY", msg))
-          .that(
-              msg.endsWith(" (Directory not empty)")
-                  || msg.endsWith(" (Device or resource busy)")
-                  || msg.endsWith(" (Is a directory)"))
-          .isTrue(); // Happens on OS X.
-    }
-  }
-
   // Test the date functions
   @Test
   public void testCreateFileChangesTimeOfDirectory() throws Exception {
@@ -1105,22 +1087,13 @@
   // Test the Paths
   @Test
   public void testGetPathOnlyAcceptsAbsolutePath() {
-    try {
-      testFS.getPath("not-absolute");
-      fail("The expected Exception was not thrown.");
-    } catch (IllegalArgumentException ex) {
-      assertThat(ex).hasMessage("not-absolute (not an absolute path)");
-    }
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> testFS.getPath("not-absolute"));
   }
 
   @Test
   public void testGetPathOnlyAcceptsAbsolutePathFragment() {
-    try {
-      testFS.getPath(PathFragment.create("not-absolute"));
-      fail("The expected Exception was not thrown.");
-    } catch (IllegalArgumentException ex) {
-      assertThat(ex).hasMessage("not-absolute (not an absolute path)");
-    }
+    MoreAsserts.expectThrows(
+        IllegalArgumentException.class, () -> testFS.getPath(PathFragment.create("not-absolute")));
   }
 
   // Test the access permissions
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java
index 6563633..f9cc1a9 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java
@@ -175,11 +175,29 @@
   @Test
   public void testRelativePath() throws IOException {
     createTestDirectoryTree();
-    assertThat(relativePath(topDir, file1).getPathString()).isEqualTo("file-1");
-    assertThat(relativePath(topDir, topDir).getPathString()).isEqualTo(".");
-    assertThat(relativePath(topDir, dirLink).getPathString()).isEqualTo("a-dir/inner-dir/dir-link");
-    assertThat(relativePath(topDir, file4).getPathString()).isEqualTo("../file-4");
-    assertThat(relativePath(innerDir, file4).getPathString()).isEqualTo("../../../file-4");
+    assertThat(
+            relativePath(PathFragment.create("/top-dir"), PathFragment.create("/top-dir/file-1"))
+                .getPathString())
+        .isEqualTo("file-1");
+    assertThat(
+            relativePath(PathFragment.create("/top-dir"), PathFragment.create("/top-dir"))
+                .getPathString())
+        .isEqualTo("");
+    assertThat(
+            relativePath(
+                    PathFragment.create("/top-dir"),
+                    PathFragment.create("/top-dir/a-dir/inner-dir/dir-link"))
+                .getPathString())
+        .isEqualTo("a-dir/inner-dir/dir-link");
+    assertThat(
+            relativePath(PathFragment.create("/top-dir"), PathFragment.create("/file-4"))
+                .getPathString())
+        .isEqualTo("../file-4");
+    assertThat(
+            relativePath(
+                    PathFragment.create("/top-dir/a-dir/inner-dir"), PathFragment.create("/file-4"))
+                .getPathString())
+        .isEqualTo("../../../file-4");
   }
 
   @Test
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/LocalPathAbstractTest.java b/src/test/java/com/google/devtools/build/lib/vfs/LocalPathAbstractTest.java
deleted file mode 100644
index 9386952..0000000
--- a/src/test/java/com/google/devtools/build/lib/vfs/LocalPathAbstractTest.java
+++ /dev/null
@@ -1,180 +0,0 @@
-// Copyright 2017 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import static com.google.common.truth.Truth.assertThat;
-import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;
-import static java.util.stream.Collectors.toList;
-
-import com.google.common.collect.Lists;
-import com.google.common.testing.EqualsTester;
-import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy;
-import java.util.Collections;
-import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
-
-/** Tests for {@link LocalPath}. */
-public abstract class LocalPathAbstractTest {
-
-  private OsPathPolicy os;
-
-  @Before
-  public void setup() {
-    os = getFilePathOs();
-  }
-
-  @Test
-  public void testEqualsAndHashCode() {
-    new EqualsTester()
-        .addEqualityGroup(
-            create("../relative/path"), create("..").getRelative("relative").getRelative("path"))
-        .addEqualityGroup(create("something/else"))
-        .addEqualityGroup(create(""), LocalPath.EMPTY)
-        .testEquals();
-  }
-
-  @Test
-  public void testRelativeTo() {
-    assertThat(create("").relativeTo(create("")).getPathString()).isEmpty();
-    assertThat(create("foo").relativeTo(create("foo")).getPathString()).isEmpty();
-    assertThat(create("foo/bar/baz").relativeTo(create("foo")).getPathString())
-        .isEqualTo("bar/baz");
-    assertThat(create("foo/bar/baz").relativeTo(create("foo/bar")).getPathString())
-        .isEqualTo("baz");
-    assertThat(create("foo").relativeTo(create("")).getPathString()).isEqualTo("foo");
-
-    // Cannot relativize non-ancestors
-    assertThrows(IllegalArgumentException.class, () -> create("foo/bar").relativeTo(create("fo")));
-
-    // Make sure partial directory matches aren't reported
-    assertThrows(
-        IllegalArgumentException.class, () -> create("foo/bar").relativeTo(create("foo/ba")));
-  }
-
-  @Test
-  public void testGetRelative() {
-    assertThat(create("a").getRelative("b").getPathString()).isEqualTo("a/b");
-    assertThat(create("a/b").getRelative("c/d").getPathString()).isEqualTo("a/b/c/d");
-    assertThat(create("a").getRelative("").getPathString()).isEqualTo("a");
-    assertThat(create("a/b").getRelative("../c").getPathString()).isEqualTo("a/c");
-    assertThat(create("a/b").getRelative("..").getPathString()).isEqualTo("a");
-  }
-
-  @Test
-  public void testEmptyPathToEmptyPath() {
-    // compare string forms
-    assertThat(create("").getPathString()).isEmpty();
-    // compare fragment forms
-    assertThat(create("")).isEqualTo(create(""));
-  }
-
-  @Test
-  public void testSimpleNameToSimpleName() {
-    // compare string forms
-    assertThat(create("foo").getPathString()).isEqualTo("foo");
-    // compare fragment forms
-    assertThat(create("foo")).isEqualTo(create("foo"));
-  }
-
-  @Test
-  public void testSimplePathToSimplePath() {
-    // compare string forms
-    assertThat(create("foo/bar").getPathString()).isEqualTo("foo/bar");
-    // compare fragment forms
-    assertThat(create("foo/bar")).isEqualTo(create("foo/bar"));
-  }
-
-  @Test
-  public void testStripsTrailingSlash() {
-    // compare string forms
-    assertThat(create("foo/bar/").getPathString()).isEqualTo("foo/bar");
-    // compare fragment forms
-    assertThat(create("foo/bar/")).isEqualTo(create("foo/bar"));
-  }
-
-  @Test
-  public void testGetParentDirectory() {
-    LocalPath fooBarWiz = create("foo/bar/wiz");
-    LocalPath fooBar = create("foo/bar");
-    LocalPath foo = create("foo");
-    LocalPath empty = create("");
-    assertThat(fooBarWiz.getParentDirectory()).isEqualTo(fooBar);
-    assertThat(fooBar.getParentDirectory()).isEqualTo(foo);
-    assertThat(foo.getParentDirectory()).isEqualTo(empty);
-    assertThat(empty.getParentDirectory()).isNull();
-  }
-
-  @Test
-  public void testBasename() throws Exception {
-    assertThat(create("foo/bar").getBaseName()).isEqualTo("bar");
-    assertThat(create("foo/").getBaseName()).isEqualTo("foo");
-    assertThat(create("foo").getBaseName()).isEqualTo("foo");
-    assertThat(create("").getBaseName()).isEmpty();
-  }
-
-  @Test
-  public void testStartsWith() {
-    // (relative path, relative prefix) => true
-    assertThat(create("foo/bar").startsWith(create("foo/bar"))).isTrue();
-    assertThat(create("foo/bar").startsWith(create("foo"))).isTrue();
-    assertThat(create("foot/bar").startsWith(create("foo"))).isFalse();
-  }
-
-  @Test
-  public void testNormalize() {
-    assertThat(create("a/b")).isEqualTo(create("a/b"));
-    assertThat(create("a/../../b")).isEqualTo(create("../b"));
-    assertThat(create("a/../..")).isEqualTo(create(".."));
-    assertThat(create("a/../b")).isEqualTo(create("b"));
-    assertThat(create("a/b/../b")).isEqualTo(create("a/b"));
-  }
-
-  @Test
-  public void testNormalStringsDoNotAllocate() {
-    String normal1 = "a/b/hello.txt";
-    assertThat(create(normal1).getPathString()).isSameAs(normal1);
-
-    // Sanity check our testing strategy
-    String notNormal = "a/../b";
-    assertThat(create(notNormal).getPathString()).isNotSameAs(notNormal);
-  }
-
-  @Test
-  public void testComparableSortOrder() {
-    List<LocalPath> list =
-        Lists.newArrayList(
-            create("zzz"),
-            create("ZZZ"),
-            create("ABC"),
-            create("aBc"),
-            create("AbC"),
-            create("abc"));
-    Collections.sort(list);
-    List<String> result = list.stream().map(LocalPath::getPathString).collect(toList());
-
-    if (os.isCaseSensitive()) {
-      assertThat(result).containsExactly("ABC", "AbC", "ZZZ", "aBc", "abc", "zzz").inOrder();
-    } else {
-      // Partial ordering among case-insensitive items guaranteed by Collections.sort stability
-      assertThat(result).containsExactly("ABC", "aBc", "AbC", "abc", "zzz", "ZZZ").inOrder();
-    }
-  }
-
-  protected abstract OsPathPolicy getFilePathOs();
-
-  protected LocalPath create(String path) {
-    return LocalPath.createWithOs(path, os);
-  }
-}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/MacOsLocalPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/MacOsLocalPathTest.java
deleted file mode 100644
index c99ad48..0000000
--- a/src/test/java/com/google/devtools/build/lib/vfs/MacOsLocalPathTest.java
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2017 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.google.common.testing.EqualsTester;
-import com.google.devtools.build.lib.vfs.LocalPath.MacOsPathPolicy;
-import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Tests Mac-specific parts of {@link LocalPath}. */
-@RunWith(JUnit4.class)
-public class MacOsLocalPathTest extends UnixLocalPathTest {
-
-  @Override
-  protected OsPathPolicy getFilePathOs() {
-    return new MacOsPathPolicy();
-  }
-
-  @Test
-  public void testMacEqualsAndHashCode() {
-    new EqualsTester()
-        .addEqualityGroup(create("a/b"), create("A/B"))
-        .addEqualityGroup(create("/a/b"), create("/A/B"))
-        .addEqualityGroup(create("something/else"))
-        .addEqualityGroup(create("/something/else"))
-        .testEquals();
-  }
-
-  @Test
-  public void testCaseIsPreserved() {
-    assertThat(create("a/B").getPathString()).isEqualTo("a/B");
-  }
-}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java
index 6d11285..5dc43a2 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java
@@ -106,13 +106,6 @@
   }
 
   @Test
-  public void testParentOfRootIsRoot() {
-    assertThat(fs.getPath("/..")).isEqualTo(fs.getPath("/"));
-    assertThat(fs.getPath("/../../../../../..")).isEqualTo(fs.getPath("/"));
-    assertThat(fs.getPath("/../../../foo")).isEqualTo(fs.getPath("/foo"));
-  }
-
-  @Test
   public void testIsDirectory() {
     assertThat(fs.getPath(aDirectory.getPath()).isDirectory()).isTrue();
     assertThat(fs.getPath(aFile.getPath()).isDirectory()).isFalse();
@@ -241,14 +234,4 @@
     assertThat(in.read()).isEqualTo(-1);
     in.close();
   }
-
-  @Test
-  public void testDerivedSegmentEquality() {
-    Path absoluteSegment = fs.getRootDirectory();
-
-    Path derivedNode = absoluteSegment.getChild("derivedSegment");
-    Path otherDerivedNode = absoluteSegment.getChild("derivedSegment");
-
-    assertThat(otherDerivedNode).isSameAs(derivedNode);
-  }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathAbstractTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathAbstractTest.java
new file mode 100644
index 0000000..7494683
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathAbstractTest.java
@@ -0,0 +1,141 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.vfs;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.stream.Collectors.toList;
+
+import com.google.common.collect.Lists;
+import com.google.common.testing.EqualsTester;
+import com.google.devtools.build.lib.clock.BlazeClock;
+import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+
+/** Tests for {@link Path}. */
+public abstract class PathAbstractTest {
+
+  private FileSystem fileSystem;
+  private boolean isCaseSensitive;
+
+  @Before
+  public void setup() {
+    fileSystem = new InMemoryFileSystem(BlazeClock.instance());
+    isCaseSensitive = OsPathPolicy.getFilePathOs().isCaseSensitive();
+  }
+
+  @Test
+  public void testStripsTrailingSlash() {
+    // compare string forms
+    assertThat(create("/foo/bar/").getPathString()).isEqualTo("/foo/bar");
+    // compare fragment forms
+    assertThat(create("/foo/bar/")).isEqualTo(create("/foo/bar"));
+  }
+
+  @Test
+  public void testBasename() throws Exception {
+    assertThat(create("/foo/bar").getBaseName()).isEqualTo("bar");
+    assertThat(create("/foo/").getBaseName()).isEqualTo("foo");
+    assertThat(create("/foo").getBaseName()).isEqualTo("foo");
+    assertThat(create("/").getBaseName()).isEmpty();
+  }
+
+  @Test
+  public void testNormalStringsDoNotAllocate() {
+    String normal1 = "/a/b/hello.txt";
+    assertThat(create(normal1).getPathString()).isSameAs(normal1);
+
+    // Sanity check our testing strategy
+    String notNormal = "/a/../b";
+    assertThat(create(notNormal).getPathString()).isNotSameAs(notNormal);
+  }
+
+  @Test
+  public void testComparableSortOrder() {
+    List<Path> list =
+        Lists.newArrayList(
+            create("/zzz"),
+            create("/ZZZ"),
+            create("/ABC"),
+            create("/aBc"),
+            create("/AbC"),
+            create("/abc"));
+    Collections.sort(list);
+    List<String> result = list.stream().map(Path::getPathString).collect(toList());
+
+    if (isCaseSensitive) {
+      assertThat(result).containsExactly("/ABC", "/AbC", "/ZZZ", "/aBc", "/abc", "/zzz").inOrder();
+    } else {
+      // Partial ordering among case-insensitive items guaranteed by Collections.sort stability
+      assertThat(result).containsExactly("/ABC", "/aBc", "/AbC", "/abc", "/zzz", "/ZZZ").inOrder();
+    }
+  }
+
+  @Test
+  public void testSerialization() throws Exception {
+    FileSystem oldFileSystem = Path.getFileSystemForSerialization();
+    try {
+      Path.setFileSystemForSerialization(fileSystem);
+      Path root = fileSystem.getPath("/");
+      Path p1 = fileSystem.getPath("/foo");
+      Path p2 = fileSystem.getPath("/foo/bar");
+
+      ByteArrayOutputStream bos = new ByteArrayOutputStream();
+      ObjectOutputStream oos = new ObjectOutputStream(bos);
+
+      oos.writeObject(root);
+      oos.writeObject(p1);
+      oos.writeObject(p2);
+
+      ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
+      ObjectInputStream ois = new ObjectInputStream(bis);
+
+      Path dsRoot = (Path) ois.readObject();
+      Path dsP1 = (Path) ois.readObject();
+      Path dsP2 = (Path) ois.readObject();
+
+      new EqualsTester()
+          .addEqualityGroup(root, dsRoot)
+          .addEqualityGroup(p1, dsP1)
+          .addEqualityGroup(p2, dsP2)
+          .testEquals();
+
+      assertThat(p2.startsWith(p1)).isTrue();
+      assertThat(p2.startsWith(dsP1)).isTrue();
+      assertThat(dsP2.startsWith(p1)).isTrue();
+      assertThat(dsP2.startsWith(dsP1)).isTrue();
+
+      // Regression test for a very specific bug in compareTo involving our incorrect usage of
+      // reference equality rather than logical equality.
+      String relativePathStringA = "child/grandchildA";
+      String relativePathStringB = "child/grandchildB";
+      assertThat(
+              p1.getRelative(relativePathStringA).compareTo(dsP1.getRelative(relativePathStringB)))
+          .isEqualTo(
+              p1.getRelative(relativePathStringA).compareTo(p1.getRelative(relativePathStringB)));
+    } finally {
+      Path.setFileSystemForSerialization(oldFileSystem);
+    }
+  }
+
+  protected Path create(String path) {
+    return Path.create(path, fileSystem);
+  }
+}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java
index 7fa3c73..02446c0 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java
@@ -15,13 +15,14 @@
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.fail;
+import static com.google.devtools.build.lib.vfs.PathFragment.create;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.testing.EqualsTester;
 import com.google.devtools.build.lib.skyframe.serialization.testutils.ObjectCodecTester;
+import com.google.devtools.build.lib.testutil.MoreAsserts;
 import com.google.devtools.build.lib.testutil.TestUtils;
 import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
 import java.io.File;
@@ -36,32 +37,6 @@
  */
 @RunWith(JUnit4.class)
 public class PathFragmentTest {
-  @Test
-  public void testMergeFourPathsWithAbsolute() {
-    assertThat(
-            PathFragment.create(
-                PathFragment.create("x/y"),
-                PathFragment.create("z/a"),
-                PathFragment.create("/b/c"),
-                PathFragment.create("d/e")))
-        .isEqualTo(PathFragment.create("x/y/z/a/b/c/d/e"));
-  }
-
-  @Test
-  public void testCreateInternsPathFragments() {
-    String[] firstSegments = new String[] {"hello", "world"};
-    PathFragment first = PathFragment.create(
-        /*driveLetter=*/ '\0', /*isAbsolute=*/ false, firstSegments);
-
-    String[] secondSegments = new String[] {new String("hello"), new String("world")};
-    PathFragment second = PathFragment.create(
-        /*driveLetter=*/ '\0', /*isAbsolute=*/ false, secondSegments);
-
-    assertThat(first.segmentCount()).isEqualTo(second.segmentCount());
-    for (int i = 0; i < first.segmentCount(); i++) {
-      assertThat(first.getSegment(i)).isSameAs(second.getSegment(i));
-    }
-  }
 
   @Test
   public void testEqualsAndHashCode() {
@@ -69,23 +44,21 @@
 
     new EqualsTester()
         .addEqualityGroup(
-            PathFragment.create("../relative/path"),
-            PathFragment.create("..").getRelative("relative").getRelative("path"),
-            PathFragment.createAlreadyInterned(
-                '\0', false, new String[] {"..", "relative", "path"}),
-            PathFragment.create(new File("../relative/path")))
-        .addEqualityGroup(PathFragment.create("something/else"))
-        .addEqualityGroup(PathFragment.create("/something/else"))
-        .addEqualityGroup(PathFragment.create("/"), PathFragment.create("//////"))
-        .addEqualityGroup(PathFragment.create(""), PathFragment.EMPTY_FRAGMENT)
+            create("../relative/path"),
+            create("..").getRelative("relative").getRelative("path"),
+            create(new File("../relative/path").getPath()))
+        .addEqualityGroup(create("something/else"))
+        .addEqualityGroup(create("/something/else"))
+        .addEqualityGroup(create("/"), create("//////"))
+        .addEqualityGroup(create(""), PathFragment.EMPTY_FRAGMENT)
         .addEqualityGroup(filesystem.getPath("/")) // A Path object.
         .testEquals();
   }
 
   @Test
   public void testHashCodeCache() {
-    PathFragment relativePath = PathFragment.create("../relative/path");
-    PathFragment rootPath = PathFragment.create("/");
+    PathFragment relativePath = create("../relative/path");
+    PathFragment rootPath = create("/");
 
     int oldResult = relativePath.hashCode();
     int rootResult = rootPath.hashCode();
@@ -93,279 +66,272 @@
     assertThat(rootPath.hashCode()).isEqualTo(rootResult);
   }
 
-  private void checkRelativeTo(String path, String base) {
-    PathFragment relative = PathFragment.create(path).relativeTo(base);
-    assertThat(PathFragment.create(base).getRelative(relative).normalize())
-        .isEqualTo(PathFragment.create(path));
-  }
-
   @Test
   public void testRelativeTo() {
-    assertPath("bar/baz", PathFragment.create("foo/bar/baz").relativeTo("foo"));
-    assertPath("bar/baz", PathFragment.create("/foo/bar/baz").relativeTo("/foo"));
-    assertPath("baz", PathFragment.create("foo/bar/baz").relativeTo("foo/bar"));
-    assertPath("baz", PathFragment.create("/foo/bar/baz").relativeTo("/foo/bar"));
-    assertPath("foo", PathFragment.create("/foo").relativeTo("/"));
-    assertPath("foo", PathFragment.create("foo").relativeTo(""));
-    assertPath("foo/bar", PathFragment.create("foo/bar").relativeTo(""));
-
-    checkRelativeTo("foo/bar/baz", "foo");
-    checkRelativeTo("/foo/bar/baz", "/foo");
-    checkRelativeTo("foo/bar/baz", "foo/bar");
-    checkRelativeTo("/foo/bar/baz", "/foo/bar");
-    checkRelativeTo("/foo", "/");
-    checkRelativeTo("foo", "");
-    checkRelativeTo("foo/bar", "");
+    assertThat(create("foo/bar/baz").relativeTo("foo").getPathString()).isEqualTo("bar/baz");
+    assertThat(create("/foo/bar/baz").relativeTo("/foo").getPathString()).isEqualTo("bar/baz");
+    assertThat(create("foo/bar/baz").relativeTo("foo/bar").getPathString()).isEqualTo("baz");
+    assertThat(create("/foo/bar/baz").relativeTo("/foo/bar").getPathString()).isEqualTo("baz");
+    assertThat(create("/foo").relativeTo("/").getPathString()).isEqualTo("foo");
+    assertThat(create("foo").relativeTo("").getPathString()).isEqualTo("foo");
+    assertThat(create("foo/bar").relativeTo("").getPathString()).isEqualTo("foo/bar");
   }
 
   @Test
   public void testIsAbsolute() {
-    assertThat(PathFragment.create("/absolute/test").isAbsolute()).isTrue();
-    assertThat(PathFragment.create("relative/test").isAbsolute()).isFalse();
-    assertThat(PathFragment.create(new File("/absolute/test")).isAbsolute()).isTrue();
-    assertThat(PathFragment.create(new File("relative/test")).isAbsolute()).isFalse();
+    assertThat(create("/absolute/test").isAbsolute()).isTrue();
+    assertThat(create("relative/test").isAbsolute()).isFalse();
+    assertThat(create(new File("/absolute/test").getPath()).isAbsolute()).isTrue();
+    assertThat(create(new File("relative/test").getPath()).isAbsolute()).isFalse();
   }
 
   @Test
   public void testIsNormalized() {
-    assertThat(PathFragment.create("/absolute/path").isNormalized()).isTrue();
-    assertThat(PathFragment.create("some//path").isNormalized()).isTrue();
-    assertThat(PathFragment.create("some/./path").isNormalized()).isFalse();
-    assertThat(PathFragment.create("../some/path").isNormalized()).isFalse();
-    assertThat(PathFragment.create("some/other/../path").isNormalized()).isFalse();
-    assertThat(PathFragment.create("some/other//tricky..path..").isNormalized()).isTrue();
-    assertThat(PathFragment.create("/some/other//tricky..path..").isNormalized()).isTrue();
+    assertThat(PathFragment.isNormalized("/absolute/path")).isTrue();
+    assertThat(PathFragment.isNormalized("some//path")).isTrue();
+    assertThat(PathFragment.isNormalized("some/./path")).isFalse();
+    assertThat(PathFragment.isNormalized("../some/path")).isFalse();
+    assertThat(PathFragment.isNormalized("./some/path")).isFalse();
+    assertThat(PathFragment.isNormalized("some/path/..")).isFalse();
+    assertThat(PathFragment.isNormalized("some/path/.")).isFalse();
+    assertThat(PathFragment.isNormalized("some/other/../path")).isFalse();
+    assertThat(PathFragment.isNormalized("some/other//tricky..path..")).isTrue();
+    assertThat(PathFragment.isNormalized("/some/other//tricky..path..")).isTrue();
+  }
+
+  @Test
+  public void testContainsUpLevelReferences() {
+    assertThat(PathFragment.containsUplevelReferences("/absolute/path")).isFalse();
+    assertThat(PathFragment.containsUplevelReferences("some//path")).isFalse();
+    assertThat(PathFragment.containsUplevelReferences("some/./path")).isFalse();
+    assertThat(PathFragment.containsUplevelReferences("../some/path")).isTrue();
+    assertThat(PathFragment.containsUplevelReferences("./some/path")).isFalse();
+    assertThat(PathFragment.containsUplevelReferences("some/path/..")).isTrue();
+    assertThat(PathFragment.containsUplevelReferences("some/path/.")).isFalse();
+    assertThat(PathFragment.containsUplevelReferences("some/other/../path")).isTrue();
+    assertThat(PathFragment.containsUplevelReferences("some/other//tricky..path..")).isFalse();
+    assertThat(PathFragment.containsUplevelReferences("/some/other//tricky..path..")).isFalse();
+
+    // Normalization cannot remove leading uplevel references, so this will be true
+    assertThat(create("../some/path").containsUplevelReferences()).isTrue();
+    // Normalization will remove these, so no uplevel references left
+    assertThat(create("some/path/..").containsUplevelReferences()).isFalse();
   }
 
   @Test
   public void testRootNodeReturnsRootString() {
-    PathFragment rootFragment = PathFragment.create("/");
+    PathFragment rootFragment = create("/");
     assertThat(rootFragment.getPathString()).isEqualTo("/");
   }
 
   @Test
-  public void testGetPathFragmentDoesNotNormalize() {
-    String nonCanonicalPath = "/a/weird/noncanonical/../path/.";
-    assertThat(PathFragment.create(nonCanonicalPath).getPathString()).isEqualTo(nonCanonicalPath);
-  }
-
-  @Test
   public void testGetRelative() {
-    assertThat(PathFragment.create("a").getRelative("b").getPathString()).isEqualTo("a/b");
-    assertThat(PathFragment.create("a/b").getRelative("c/d").getPathString()).isEqualTo("a/b/c/d");
-    assertThat(PathFragment.create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b");
-    assertThat(PathFragment.create("a").getRelative("").getPathString()).isEqualTo("a");
-    assertThat(PathFragment.create("/").getRelative("").getPathString()).isEqualTo("/");
+    assertThat(create("a").getRelative("b").getPathString()).isEqualTo("a/b");
+    assertThat(create("a/b").getRelative("c/d").getPathString()).isEqualTo("a/b/c/d");
+    assertThat(create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b");
+    assertThat(create("a").getRelative("").getPathString()).isEqualTo("a");
+    assertThat(create("/").getRelative("").getPathString()).isEqualTo("/");
+    assertThat(create("a/b").getRelative("../foo").getPathString()).isEqualTo("a/foo");
+    assertThat(create("/a/b").getRelative("../foo").getPathString()).isEqualTo("/a/foo");
+
+    // Make sure any fast path of PathFragment#getRelative(PathFragment) works
+    assertThat(create("a/b").getRelative(create("../foo")).getPathString()).isEqualTo("a/foo");
+    assertThat(create("/a/b").getRelative(create("../foo")).getPathString()).isEqualTo("/a/foo");
+
+    // Make sure any fast path of PathFragment#getRelative(PathFragment) works
+    assertThat(create("c/d").getRelative(create("/a/b")).getPathString()).isEqualTo("/a/b");
+
+    // Test normalization
+    assertThat(create("a").getRelative(".").getPathString()).isEqualTo("a");
   }
 
   @Test
   public void testGetChildWorks() {
-    PathFragment pf = PathFragment.create("../some/path");
-    assertThat(pf.getChild("hi")).isEqualTo(PathFragment.create("../some/path/hi"));
+    PathFragment pf = create("../some/path");
+    assertThat(pf.getChild("hi")).isEqualTo(create("../some/path/hi"));
   }
 
   @Test
   public void testGetChildRejectsInvalidBaseNames() {
-    PathFragment pf = PathFragment.create("../some/path");
-    assertGetChildFails(pf, ".");
-    assertGetChildFails(pf, "..");
-    assertGetChildFails(pf, "x/y");
-    assertGetChildFails(pf, "/y");
-    assertGetChildFails(pf, "y/");
-    assertGetChildFails(pf, "");
-  }
-
-  private void assertGetChildFails(PathFragment pf, String baseName) {
-    try {
-      pf.getChild(baseName);
-      fail();
-    } catch (Exception e) { /* Expected. */ }
-  }
-
-  // Tests after here test the canonicalization
-  private void assertRegular(String expected, String actual) {
-    // compare string forms
-    assertThat(PathFragment.create(actual).getPathString()).isEqualTo(expected);
-    // compare fragment forms
-    assertThat(PathFragment.create(actual)).isEqualTo(PathFragment.create(expected));
+    PathFragment pf = create("../some/path");
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("."));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild(".."));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("x/y"));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("/y"));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("y/"));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild(""));
   }
 
   @Test
   public void testEmptyPathToEmptyPath() {
-    assertRegular("/", "/");
-    assertRegular("", "");
+    assertThat(create("/").getPathString()).isEqualTo("/");
+    assertThat(create("").getPathString()).isEqualTo("");
   }
 
   @Test
   public void testRedundantSlashes() {
-    assertRegular("/", "///");
-    assertRegular("/foo/bar", "/foo///bar");
-    assertRegular("/foo/bar", "////foo//bar");
+    assertThat(create("///").getPathString()).isEqualTo("/");
+    assertThat(create("/foo///bar").getPathString()).isEqualTo("/foo/bar");
+    assertThat(create("////foo//bar").getPathString()).isEqualTo("/foo/bar");
   }
 
   @Test
   public void testSimpleNameToSimpleName() {
-    assertRegular("/foo", "/foo");
-    assertRegular("foo", "foo");
+    assertThat(create("/foo").getPathString()).isEqualTo("/foo");
+    assertThat(create("foo").getPathString()).isEqualTo("foo");
   }
 
   @Test
   public void testSimplePathToSimplePath() {
-    assertRegular("/foo/bar", "/foo/bar");
-    assertRegular("foo/bar", "foo/bar");
+    assertThat(create("/foo/bar").getPathString()).isEqualTo("/foo/bar");
+    assertThat(create("foo/bar").getPathString()).isEqualTo("foo/bar");
   }
 
   @Test
   public void testStripsTrailingSlash() {
-    assertRegular("/foo/bar", "/foo/bar/");
+    assertThat(create("/foo/bar/").getPathString()).isEqualTo("/foo/bar");
   }
 
   @Test
   public void testGetParentDirectory() {
-    PathFragment fooBarWiz = PathFragment.create("foo/bar/wiz");
-    PathFragment fooBar = PathFragment.create("foo/bar");
-    PathFragment foo = PathFragment.create("foo");
-    PathFragment empty = PathFragment.create("");
+    PathFragment fooBarWiz = create("foo/bar/wiz");
+    PathFragment fooBar = create("foo/bar");
+    PathFragment foo = create("foo");
+    PathFragment empty = create("");
     assertThat(fooBarWiz.getParentDirectory()).isEqualTo(fooBar);
     assertThat(fooBar.getParentDirectory()).isEqualTo(foo);
     assertThat(foo.getParentDirectory()).isEqualTo(empty);
     assertThat(empty.getParentDirectory()).isNull();
 
-    PathFragment fooBarWizAbs = PathFragment.create("/foo/bar/wiz");
-    PathFragment fooBarAbs = PathFragment.create("/foo/bar");
-    PathFragment fooAbs = PathFragment.create("/foo");
-    PathFragment rootAbs = PathFragment.create("/");
+    PathFragment fooBarWizAbs = create("/foo/bar/wiz");
+    PathFragment fooBarAbs = create("/foo/bar");
+    PathFragment fooAbs = create("/foo");
+    PathFragment rootAbs = create("/");
     assertThat(fooBarWizAbs.getParentDirectory()).isEqualTo(fooBarAbs);
     assertThat(fooBarAbs.getParentDirectory()).isEqualTo(fooAbs);
     assertThat(fooAbs.getParentDirectory()).isEqualTo(rootAbs);
     assertThat(rootAbs.getParentDirectory()).isNull();
-
-    // Note, this is surprising but correct behavior:
-    assertThat(PathFragment.create("/foo/bar/..").getParentDirectory()).isEqualTo(fooBarAbs);
   }
 
   @Test
   public void testSegmentsCount() {
-    assertThat(PathFragment.create("foo/bar").segmentCount()).isEqualTo(2);
-    assertThat(PathFragment.create("/foo/bar").segmentCount()).isEqualTo(2);
-    assertThat(PathFragment.create("foo//bar").segmentCount()).isEqualTo(2);
-    assertThat(PathFragment.create("/foo//bar").segmentCount()).isEqualTo(2);
-    assertThat(PathFragment.create("foo/").segmentCount()).isEqualTo(1);
-    assertThat(PathFragment.create("/foo/").segmentCount()).isEqualTo(1);
-    assertThat(PathFragment.create("foo").segmentCount()).isEqualTo(1);
-    assertThat(PathFragment.create("/foo").segmentCount()).isEqualTo(1);
-    assertThat(PathFragment.create("/").segmentCount()).isEqualTo(0);
-    assertThat(PathFragment.create("").segmentCount()).isEqualTo(0);
+    assertThat(create("foo/bar").segmentCount()).isEqualTo(2);
+    assertThat(create("/foo/bar").segmentCount()).isEqualTo(2);
+    assertThat(create("foo//bar").segmentCount()).isEqualTo(2);
+    assertThat(create("/foo//bar").segmentCount()).isEqualTo(2);
+    assertThat(create("foo/").segmentCount()).isEqualTo(1);
+    assertThat(create("/foo/").segmentCount()).isEqualTo(1);
+    assertThat(create("foo").segmentCount()).isEqualTo(1);
+    assertThat(create("/foo").segmentCount()).isEqualTo(1);
+    assertThat(create("/").segmentCount()).isEqualTo(0);
+    assertThat(create("").segmentCount()).isEqualTo(0);
   }
 
 
   @Test
   public void testGetSegment() {
-    assertThat(PathFragment.create("foo/bar").getSegment(0)).isEqualTo("foo");
-    assertThat(PathFragment.create("foo/bar").getSegment(1)).isEqualTo("bar");
-    assertThat(PathFragment.create("/foo/bar").getSegment(0)).isEqualTo("foo");
-    assertThat(PathFragment.create("/foo/bar").getSegment(1)).isEqualTo("bar");
-    assertThat(PathFragment.create("foo/").getSegment(0)).isEqualTo("foo");
-    assertThat(PathFragment.create("/foo/").getSegment(0)).isEqualTo("foo");
-    assertThat(PathFragment.create("foo").getSegment(0)).isEqualTo("foo");
-    assertThat(PathFragment.create("/foo").getSegment(0)).isEqualTo("foo");
+    assertThat(create("foo/bar").getSegment(0)).isEqualTo("foo");
+    assertThat(create("foo/bar").getSegment(1)).isEqualTo("bar");
+    assertThat(create("/foo/bar").getSegment(0)).isEqualTo("foo");
+    assertThat(create("/foo/bar").getSegment(1)).isEqualTo("bar");
+    assertThat(create("foo/").getSegment(0)).isEqualTo("foo");
+    assertThat(create("/foo/").getSegment(0)).isEqualTo("foo");
+    assertThat(create("foo").getSegment(0)).isEqualTo("foo");
+    assertThat(create("/foo").getSegment(0)).isEqualTo("foo");
   }
 
   @Test
   public void testBasename() throws Exception {
-    assertThat(PathFragment.create("foo/bar").getBaseName()).isEqualTo("bar");
-    assertThat(PathFragment.create("/foo/bar").getBaseName()).isEqualTo("bar");
-    assertThat(PathFragment.create("foo/").getBaseName()).isEqualTo("foo");
-    assertThat(PathFragment.create("/foo/").getBaseName()).isEqualTo("foo");
-    assertThat(PathFragment.create("foo").getBaseName()).isEqualTo("foo");
-    assertThat(PathFragment.create("/foo").getBaseName()).isEqualTo("foo");
-    assertThat(PathFragment.create("/").getBaseName()).isEmpty();
-    assertThat(PathFragment.create("").getBaseName()).isEmpty();
+    assertThat(create("foo/bar").getBaseName()).isEqualTo("bar");
+    assertThat(create("/foo/bar").getBaseName()).isEqualTo("bar");
+    assertThat(create("foo/").getBaseName()).isEqualTo("foo");
+    assertThat(create("/foo/").getBaseName()).isEqualTo("foo");
+    assertThat(create("foo").getBaseName()).isEqualTo("foo");
+    assertThat(create("/foo").getBaseName()).isEqualTo("foo");
+    assertThat(create("/").getBaseName()).isEmpty();
+    assertThat(create("").getBaseName()).isEmpty();
   }
 
   @Test
   public void testFileExtension() throws Exception {
-    assertThat(PathFragment.create("foo.bar").getFileExtension()).isEqualTo("bar");
-    assertThat(PathFragment.create("foo.barr").getFileExtension()).isEqualTo("barr");
-    assertThat(PathFragment.create("foo.b").getFileExtension()).isEqualTo("b");
-    assertThat(PathFragment.create("foo.").getFileExtension()).isEmpty();
-    assertThat(PathFragment.create("foo").getFileExtension()).isEmpty();
-    assertThat(PathFragment.create(".").getFileExtension()).isEmpty();
-    assertThat(PathFragment.create("").getFileExtension()).isEmpty();
-    assertThat(PathFragment.create("foo/bar.baz").getFileExtension()).isEqualTo("baz");
-    assertThat(PathFragment.create("foo.bar.baz").getFileExtension()).isEqualTo("baz");
-    assertThat(PathFragment.create("foo.bar/baz").getFileExtension()).isEmpty();
-  }
-
-  private static void assertPath(String expected, PathFragment actual) {
-    assertThat(actual.getPathString()).isEqualTo(expected);
+    assertThat(create("foo.bar").getFileExtension()).isEqualTo("bar");
+    assertThat(create("foo.barr").getFileExtension()).isEqualTo("barr");
+    assertThat(create("foo.b").getFileExtension()).isEqualTo("b");
+    assertThat(create("foo.").getFileExtension()).isEmpty();
+    assertThat(create("foo").getFileExtension()).isEmpty();
+    assertThat(create(".").getFileExtension()).isEmpty();
+    assertThat(create("").getFileExtension()).isEmpty();
+    assertThat(create("foo/bar.baz").getFileExtension()).isEqualTo("baz");
+    assertThat(create("foo.bar.baz").getFileExtension()).isEqualTo("baz");
+    assertThat(create("foo.bar/baz").getFileExtension()).isEmpty();
   }
 
   @Test
   public void testReplaceName() throws Exception {
-    assertPath("foo/baz", PathFragment.create("foo/bar").replaceName("baz"));
-    assertPath("/foo/baz", PathFragment.create("/foo/bar").replaceName("baz"));
-    assertPath("foo", PathFragment.create("foo/bar").replaceName(""));
-    assertPath("baz", PathFragment.create("foo/").replaceName("baz"));
-    assertPath("/baz", PathFragment.create("/foo/").replaceName("baz"));
-    assertPath("baz", PathFragment.create("foo").replaceName("baz"));
-    assertPath("/baz", PathFragment.create("/foo").replaceName("baz"));
-    assertThat(PathFragment.create("/").replaceName("baz")).isNull();
-    assertThat(PathFragment.create("/").replaceName("")).isNull();
-    assertThat(PathFragment.create("").replaceName("baz")).isNull();
-    assertThat(PathFragment.create("").replaceName("")).isNull();
+    assertThat(create("foo/bar").replaceName("baz").getPathString()).isEqualTo("foo/baz");
+    assertThat(create("/foo/bar").replaceName("baz").getPathString()).isEqualTo("/foo/baz");
+    assertThat(create("foo/bar").replaceName("").getPathString()).isEqualTo("foo");
+    assertThat(create("foo/").replaceName("baz").getPathString()).isEqualTo("baz");
+    assertThat(create("/foo/").replaceName("baz").getPathString()).isEqualTo("/baz");
+    assertThat(create("foo").replaceName("baz").getPathString()).isEqualTo("baz");
+    assertThat(create("/foo").replaceName("baz").getPathString()).isEqualTo("/baz");
+    assertThat(create("/").replaceName("baz")).isNull();
+    assertThat(create("/").replaceName("")).isNull();
+    assertThat(create("").replaceName("baz")).isNull();
+    assertThat(create("").replaceName("")).isNull();
 
-    assertPath("foo/bar/baz", PathFragment.create("foo/bar").replaceName("bar/baz"));
-    assertPath("foo/bar/baz", PathFragment.create("foo/bar").replaceName("bar/baz/"));
+    assertThat(create("foo/bar").replaceName("bar/baz").getPathString()).isEqualTo("foo/bar/baz");
+    assertThat(create("foo/bar").replaceName("bar/baz/").getPathString()).isEqualTo("foo/bar/baz");
 
     // Absolute path arguments will clobber the original path.
-    assertPath("/absolute", PathFragment.create("foo/bar").replaceName("/absolute"));
-    assertPath("/", PathFragment.create("foo/bar").replaceName("/"));
+    assertThat(create("foo/bar").replaceName("/absolute").getPathString()).isEqualTo("/absolute");
+    assertThat(create("foo/bar").replaceName("/").getPathString()).isEqualTo("/");
   }
   @Test
   public void testSubFragment() throws Exception {
-    assertPath("/foo/bar/baz",
-        PathFragment.create("/foo/bar/baz").subFragment(0, 3));
-    assertPath("foo/bar/baz",
-        PathFragment.create("foo/bar/baz").subFragment(0, 3));
-    assertPath("/foo/bar",
-               PathFragment.create("/foo/bar/baz").subFragment(0, 2));
-    assertPath("bar/baz",
-               PathFragment.create("/foo/bar/baz").subFragment(1, 3));
-    assertPath("/foo",
-               PathFragment.create("/foo/bar/baz").subFragment(0, 1));
-    assertPath("bar",
-               PathFragment.create("/foo/bar/baz").subFragment(1, 2));
-    assertPath("baz", PathFragment.create("/foo/bar/baz").subFragment(2, 3));
-    assertPath("/", PathFragment.create("/foo/bar/baz").subFragment(0, 0));
-    assertPath("", PathFragment.create("foo/bar/baz").subFragment(0, 0));
-    assertPath("", PathFragment.create("foo/bar/baz").subFragment(1, 1));
-    assertPath("/foo/bar/baz", PathFragment.create("/foo/bar/baz").subFragment(0));
-    assertPath("bar/baz", PathFragment.create("/foo/bar/baz").subFragment(1));
-    try {
-      fail("unexpectedly succeeded: " + PathFragment.create("foo/bar/baz").subFragment(3, 2));
-    } catch (IndexOutOfBoundsException e) { /* Expected. */ }
-    try {
-      fail("unexpectedly succeeded: " + PathFragment.create("foo/bar/baz").subFragment(4, 4));
-    } catch (IndexOutOfBoundsException e) { /* Expected. */ }
+    assertThat(create("/foo/bar/baz").subFragment(0, 3).getPathString()).isEqualTo("/foo/bar/baz");
+    assertThat(create("foo/bar/baz").subFragment(0, 3).getPathString()).isEqualTo("foo/bar/baz");
+    assertThat(create("/foo/bar/baz").subFragment(0, 2).getPathString()).isEqualTo("/foo/bar");
+    assertThat(create("/foo/bar/baz").subFragment(1, 3).getPathString()).isEqualTo("bar/baz");
+    assertThat(create("/foo/bar/baz").subFragment(0, 1).getPathString()).isEqualTo("/foo");
+    assertThat(create("/foo/bar/baz").subFragment(1, 2).getPathString()).isEqualTo("bar");
+    assertThat(create("/foo/bar/baz").subFragment(2, 3).getPathString()).isEqualTo("baz");
+    assertThat(create("/foo/bar/baz").subFragment(0, 0).getPathString()).isEqualTo("/");
+    assertThat(create("foo/bar/baz").subFragment(0, 0).getPathString()).isEqualTo("");
+    assertThat(create("foo/bar/baz").subFragment(1, 1).getPathString()).isEqualTo("");
+
+    assertThat(create("/foo/bar/baz").subFragment(0).getPathString()).isEqualTo("/foo/bar/baz");
+    assertThat(create("foo/bar/baz").subFragment(0).getPathString()).isEqualTo("foo/bar/baz");
+    assertThat(create("/foo/bar/baz").subFragment(1).getPathString()).isEqualTo("bar/baz");
+    assertThat(create("foo/bar/baz").subFragment(1).getPathString()).isEqualTo("bar/baz");
+    assertThat(create("foo/bar/baz").subFragment(2).getPathString()).isEqualTo("baz");
+    assertThat(create("foo/bar/baz").subFragment(3).getPathString()).isEqualTo("");
+
+    MoreAsserts.expectThrows(
+        IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(3, 2));
+    MoreAsserts.expectThrows(
+        IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(4, 4));
+    MoreAsserts.expectThrows(
+        IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(3, 2));
+    MoreAsserts.expectThrows(
+        IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(4));
   }
 
   @Test
   public void testStartsWith() {
-    PathFragment foobar = PathFragment.create("/foo/bar");
-    PathFragment foobarRelative = PathFragment.create("foo/bar");
+    PathFragment foobar = create("/foo/bar");
+    PathFragment foobarRelative = create("foo/bar");
 
     // (path, prefix) => true
     assertThat(foobar.startsWith(foobar)).isTrue();
-    assertThat(foobar.startsWith(PathFragment.create("/"))).isTrue();
-    assertThat(foobar.startsWith(PathFragment.create("/foo"))).isTrue();
-    assertThat(foobar.startsWith(PathFragment.create("/foo/"))).isTrue();
-    assertThat(foobar.startsWith(PathFragment.create("/foo/bar/")))
-        .isTrue(); // Includes trailing slash.
+    assertThat(foobar.startsWith(create("/"))).isTrue();
+    assertThat(foobar.startsWith(create("/foo"))).isTrue();
+    assertThat(foobar.startsWith(create("/foo/"))).isTrue();
+    assertThat(foobar.startsWith(create("/foo/bar/"))).isTrue(); // Includes trailing slash.
 
     // (prefix, path) => false
-    assertThat(PathFragment.create("/foo").startsWith(foobar)).isFalse();
-    assertThat(PathFragment.create("/").startsWith(foobar)).isFalse();
+    assertThat(create("/foo").startsWith(foobar)).isFalse();
+    assertThat(create("/").startsWith(foobar)).isFalse();
 
     // (absolute, relative) => false
     assertThat(foobar.startsWith(foobarRelative)).isFalse();
@@ -373,69 +339,53 @@
 
     // (relative path, relative prefix) => true
     assertThat(foobarRelative.startsWith(foobarRelative)).isTrue();
-    assertThat(foobarRelative.startsWith(PathFragment.create("foo"))).isTrue();
-    assertThat(foobarRelative.startsWith(PathFragment.create(""))).isTrue();
+    assertThat(foobarRelative.startsWith(create("foo"))).isTrue();
+    assertThat(foobarRelative.startsWith(create(""))).isTrue();
 
     // (path, sibling) => false
-    assertThat(PathFragment.create("/foo/wiz").startsWith(foobar)).isFalse();
-    assertThat(foobar.startsWith(PathFragment.create("/foo/wiz"))).isFalse();
-
-    // Does not normalize.
-    PathFragment foodotbar = PathFragment.create("foo/./bar");
-    assertThat(foodotbar.startsWith(foodotbar)).isTrue();
-    assertThat(foodotbar.startsWith(PathFragment.create("foo/."))).isTrue();
-    assertThat(foodotbar.startsWith(PathFragment.create("foo/./"))).isTrue();
-    assertThat(foodotbar.startsWith(PathFragment.create("foo/./bar"))).isTrue();
-    assertThat(foodotbar.startsWith(PathFragment.create("foo/bar"))).isFalse();
+    assertThat(create("/foo/wiz").startsWith(foobar)).isFalse();
+    assertThat(foobar.startsWith(create("/foo/wiz"))).isFalse();
   }
 
   @Test
   public void testCheckAllPathsStartWithButAreNotEqualTo() {
     // Check passes:
-    PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a/c"),
-        PathFragment.create("a"));
+    PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a/c"), create("a"));
 
     // Check trivially passes:
-    PathFragment.checkAllPathsAreUnder(ImmutableList.<PathFragment>of(),
-        PathFragment.create("a"));
+    PathFragment.checkAllPathsAreUnder(ImmutableList.<PathFragment>of(), create("a"));
 
     // Check fails when some path does not start with startingWithPath:
-    try {
-      PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "b/c"),
-          PathFragment.create("a"));
-      fail();
-    } catch (IllegalArgumentException expected) {
-    }
+    MoreAsserts.expectThrows(
+        IllegalArgumentException.class,
+        () -> PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "b/c"), create("a")));
 
     // Check fails when some path is equal to startingWithPath:
-    try {
-      PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a"),
-          PathFragment.create("a"));
-      fail();
-    } catch (IllegalArgumentException expected) {
-    }
+    MoreAsserts.expectThrows(
+        IllegalArgumentException.class,
+        () -> PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a"), create("a")));
   }
 
   @Test
   public void testEndsWith() {
-    PathFragment foobar = PathFragment.create("/foo/bar");
-    PathFragment foobarRelative = PathFragment.create("foo/bar");
+    PathFragment foobar = create("/foo/bar");
+    PathFragment foobarRelative = create("foo/bar");
 
     // (path, suffix) => true
     assertThat(foobar.endsWith(foobar)).isTrue();
-    assertThat(foobar.endsWith(PathFragment.create("bar"))).isTrue();
-    assertThat(foobar.endsWith(PathFragment.create("foo/bar"))).isTrue();
-    assertThat(foobar.endsWith(PathFragment.create("/foo/bar"))).isTrue();
-    assertThat(foobar.endsWith(PathFragment.create("/bar"))).isFalse();
+    assertThat(foobar.endsWith(create("bar"))).isTrue();
+    assertThat(foobar.endsWith(create("foo/bar"))).isTrue();
+    assertThat(foobar.endsWith(create("/foo/bar"))).isTrue();
+    assertThat(foobar.endsWith(create("/bar"))).isFalse();
 
     // (prefix, path) => false
-    assertThat(PathFragment.create("/foo").endsWith(foobar)).isFalse();
-    assertThat(PathFragment.create("/").endsWith(foobar)).isFalse();
+    assertThat(create("/foo").endsWith(foobar)).isFalse();
+    assertThat(create("/").endsWith(foobar)).isFalse();
 
     // (suffix, path) => false
-    assertThat(PathFragment.create("/bar").endsWith(foobar)).isFalse();
-    assertThat(PathFragment.create("bar").endsWith(foobar)).isFalse();
-    assertThat(PathFragment.create("").endsWith(foobar)).isFalse();
+    assertThat(create("/bar").endsWith(foobar)).isFalse();
+    assertThat(create("bar").endsWith(foobar)).isFalse();
+    assertThat(create("").endsWith(foobar)).isFalse();
 
     // (absolute, relative) => true
     assertThat(foobar.endsWith(foobarRelative)).isTrue();
@@ -445,18 +395,32 @@
 
     // (relative path, relative prefix) => true
     assertThat(foobarRelative.endsWith(foobarRelative)).isTrue();
-    assertThat(foobarRelative.endsWith(PathFragment.create("bar"))).isTrue();
-    assertThat(foobarRelative.endsWith(PathFragment.create(""))).isTrue();
+    assertThat(foobarRelative.endsWith(create("bar"))).isTrue();
+    assertThat(foobarRelative.endsWith(create(""))).isTrue();
 
     // (path, sibling) => false
-    assertThat(PathFragment.create("/foo/wiz").endsWith(foobar)).isFalse();
-    assertThat(foobar.endsWith(PathFragment.create("/foo/wiz"))).isFalse();
+    assertThat(create("/foo/wiz").endsWith(foobar)).isFalse();
+    assertThat(foobar.endsWith(create("/foo/wiz"))).isFalse();
+  }
+
+  @Test
+  public void testToRelative() {
+    assertThat(create("/foo/bar").toRelative()).isEqualTo(create("foo/bar"));
+    assertThat(create("/").toRelative()).isEqualTo(create(""));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").toRelative());
+  }
+
+  @Test
+  public void testGetDriveStr() {
+    assertThat(create("/foo/bar").getDriveStr()).isEqualTo("/");
+    assertThat(create("/").getDriveStr()).isEqualTo("/");
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").getDriveStr());
   }
 
   static List<PathFragment> toPaths(List<String> strs) {
     List<PathFragment> paths = Lists.newArrayList();
     for (String s : strs) {
-      paths.add(PathFragment.create(s));
+      paths.add(create(s));
     }
     return paths;
   }
@@ -464,15 +428,26 @@
   static ImmutableSet<PathFragment> toPathsSet(String... strs) {
     ImmutableSet.Builder<PathFragment> builder = ImmutableSet.builder();
     for (String str : strs) {
-      builder.add(PathFragment.create(str));
+      builder.add(create(str));
     }
     return builder.build();
   }
 
   @Test
   public void testCompareTo() throws Exception {
-    List<String> pathStrs = ImmutableList.of(
-        "", "/", "//", ".", "/./", "foo/.//bar", "foo", "/foo", "foo/bar", "foo/Bar", "Foo/bar");
+    List<String> pathStrs =
+        ImmutableList.of(
+            "",
+            "/",
+            "foo",
+            "/foo",
+            "foo/bar",
+            "foo.bar",
+            "foo/bar.baz",
+            "foo/bar/baz",
+            "foo/barfile",
+            "foo/Bar",
+            "Foo/bar");
     List<PathFragment> paths = toPaths(pathStrs);
     // First test that compareTo is self-consistent.
     for (PathFragment x : paths) {
@@ -493,36 +468,80 @@
         }
       }
     }
-    // Now test that compareTo does what we expect.  The exact ordering here doesn't matter much,
-    // but there are three things to notice: 1. absolute < relative, 2. comparison is lexicographic
-    // 3. repeated slashes are ignored. (PathFragment("//") prints as "/").
+    // Now test that compareTo does what we expect.  The exact ordering here doesn't matter much.
     Collections.shuffle(paths);
     Collections.sort(paths);
-    List<PathFragment> expectedOrder = toPaths(ImmutableList.of(
-        "/", "//", "/./", "/foo", "", ".", "Foo/bar", "foo", "foo/.//bar", "foo/Bar", "foo/bar"));
+    List<PathFragment> expectedOrder =
+        toPaths(
+            ImmutableList.of(
+                "",
+                "/",
+                "/foo",
+                "Foo/bar",
+                "foo",
+                "foo.bar",
+                "foo/Bar",
+                "foo/bar",
+                "foo/bar.baz",
+                "foo/bar/baz",
+                "foo/barfile"));
     assertThat(paths).isEqualTo(expectedOrder);
   }
 
   @Test
   public void testGetSafePathString() {
-    assertThat(PathFragment.create("/").getSafePathString()).isEqualTo("/");
-    assertThat(PathFragment.create("/abc").getSafePathString()).isEqualTo("/abc");
-    assertThat(PathFragment.create("").getSafePathString()).isEqualTo(".");
+    assertThat(create("/").getSafePathString()).isEqualTo("/");
+    assertThat(create("/abc").getSafePathString()).isEqualTo("/abc");
+    assertThat(create("").getSafePathString()).isEqualTo(".");
     assertThat(PathFragment.EMPTY_FRAGMENT.getSafePathString()).isEqualTo(".");
-    assertThat(PathFragment.create("abc/def").getSafePathString()).isEqualTo("abc/def");
+    assertThat(create("abc/def").getSafePathString()).isEqualTo("abc/def");
   }
 
   @Test
   public void testNormalize() {
-    assertThat(PathFragment.create("/a/b").normalize()).isEqualTo(PathFragment.create("/a/b"));
-    assertThat(PathFragment.create("/a/./b").normalize()).isEqualTo(PathFragment.create("/a/b"));
-    assertThat(PathFragment.create("/a/../b").normalize()).isEqualTo(PathFragment.create("/b"));
-    assertThat(PathFragment.create("a/b").normalize()).isEqualTo(PathFragment.create("a/b"));
-    assertThat(PathFragment.create("a/../../b").normalize()).isEqualTo(PathFragment.create("../b"));
-    assertThat(PathFragment.create("a/../..").normalize()).isEqualTo(PathFragment.create(".."));
-    assertThat(PathFragment.create("a/../b").normalize()).isEqualTo(PathFragment.create("b"));
-    assertThat(PathFragment.create("a/b/../b").normalize()).isEqualTo(PathFragment.create("a/b"));
-    assertThat(PathFragment.create("/..").normalize()).isEqualTo(PathFragment.create("/.."));
+    assertThat(create("/a/b")).isEqualTo(create("/a/b"));
+    assertThat(create("/a/./b")).isEqualTo(create("/a/b"));
+    assertThat(create("/a/../b")).isEqualTo(create("/b"));
+    assertThat(create("a/b")).isEqualTo(create("a/b"));
+    assertThat(create("a/../../b")).isEqualTo(create("../b"));
+    assertThat(create("a/../..")).isEqualTo(create(".."));
+    assertThat(create("a/../b")).isEqualTo(create("b"));
+    assertThat(create("a/b/../b")).isEqualTo(create("a/b"));
+    assertThat(create("/..")).isEqualTo(create("/.."));
+    assertThat(create("..")).isEqualTo(create(".."));
+  }
+
+  @Test
+  public void testSegments() {
+    assertThat(create("").segmentCount()).isEqualTo(0);
+    assertThat(create("a").segmentCount()).isEqualTo(1);
+    assertThat(create("a/b").segmentCount()).isEqualTo(2);
+    assertThat(create("a/b/c").segmentCount()).isEqualTo(3);
+    assertThat(create("/").segmentCount()).isEqualTo(0);
+    assertThat(create("/a").segmentCount()).isEqualTo(1);
+    assertThat(create("/a/b").segmentCount()).isEqualTo(2);
+    assertThat(create("/a/b/c").segmentCount()).isEqualTo(3);
+
+    assertThat(create("").getSegments()).isEmpty();
+    assertThat(create("a").getSegments()).containsExactly("a").inOrder();
+    assertThat(create("a/b").getSegments()).containsExactly("a", "b").inOrder();
+    assertThat(create("a/b/c").getSegments()).containsExactly("a", "b", "c").inOrder();
+    assertThat(create("/").getSegments()).isEmpty();
+    assertThat(create("/a").getSegments()).containsExactly("a").inOrder();
+    assertThat(create("/a/b").getSegments()).containsExactly("a", "b").inOrder();
+    assertThat(create("/a/b/c").getSegments()).containsExactly("a", "b", "c").inOrder();
+
+    assertThat(create("a").getSegment(0)).isEqualTo("a");
+    assertThat(create("a/b").getSegment(0)).isEqualTo("a");
+    assertThat(create("a/b").getSegment(1)).isEqualTo("b");
+    assertThat(create("a/b/c").getSegment(2)).isEqualTo("c");
+    assertThat(create("/a").getSegment(0)).isEqualTo("a");
+    assertThat(create("/a/b").getSegment(0)).isEqualTo("a");
+    assertThat(create("/a/b").getSegment(1)).isEqualTo("b");
+    assertThat(create("/a/b/c").getSegment(2)).isEqualTo("c");
+
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("").getSegment(0));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("a/b").getSegment(2));
   }
 
   @Test
@@ -552,7 +571,7 @@
   }
 
   private void checkSerialization(String pathFragmentString, int expectedSize) throws Exception {
-    PathFragment a = PathFragment.create(pathFragmentString);
+    PathFragment a = create(pathFragmentString);
     byte[] sa = TestUtils.serializeObject(a);
     assertThat(sa).hasLength(expectedSize);
 
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java
index 1f18d07..b2a8a52 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java
@@ -14,9 +14,9 @@
 package com.google.devtools.build.lib.vfs;
 
 import static com.google.common.truth.Truth.assertThat;
-import static com.google.common.truth.Truth.assertWithMessage;
-import static org.junit.Assert.fail;
+import static com.google.devtools.build.lib.vfs.PathFragment.create;
 
+import com.google.devtools.build.lib.testutil.MoreAsserts;
 import java.io.File;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -30,303 +30,199 @@
 
   @Test
   public void testWindowsSeparator() {
-    assertThat(PathFragment.create("bar\\baz").toString()).isEqualTo("bar/baz");
-    assertThat(PathFragment.create("c:\\bar\\baz").toString()).isEqualTo("C:/bar/baz");
+    assertThat(create("bar\\baz").toString()).isEqualTo("bar/baz");
+    assertThat(create("c:\\bar\\baz").toString()).isEqualTo("C:/bar/baz");
   }
 
   @Test
   public void testIsAbsoluteWindows() {
-    assertThat(PathFragment.create("C:/").isAbsolute()).isTrue();
-    assertThat(PathFragment.create("C:/").isAbsolute()).isTrue();
-    assertThat(PathFragment.create("C:/foo").isAbsolute()).isTrue();
-    assertThat(PathFragment.create("d:/foo/bar").isAbsolute()).isTrue();
+    assertThat(create("C:/").isAbsolute()).isTrue();
+    assertThat(create("C:/").isAbsolute()).isTrue();
+    assertThat(create("C:/foo").isAbsolute()).isTrue();
+    assertThat(create("d:/foo/bar").isAbsolute()).isTrue();
 
-    assertThat(PathFragment.create("*:/").isAbsolute()).isFalse();
+    assertThat(create("*:/").isAbsolute()).isFalse();
   }
 
   @Test
   public void testAbsoluteAndAbsoluteLookingPaths() {
-    PathFragment p1 = PathFragment.create("/c");
-    assertThat(p1.isAbsolute()).isTrue();
-    assertThat(p1.getDriveLetter()).isEqualTo('\0');
-    assertThat(p1.getSegments()).containsExactly("c");
+    assertThat(create("/c").isAbsolute()).isTrue();
+    assertThat(create("/c").getSegments()).containsExactly("c");
 
-    PathFragment p2 = PathFragment.create("/c/");
-    assertThat(p2.isAbsolute()).isTrue();
-    assertThat(p2.getDriveLetter()).isEqualTo('\0');
-    assertThat(p2.getSegments()).containsExactly("c");
+    assertThat(create("/c/").isAbsolute()).isTrue();
+    assertThat(create("/c/").getSegments()).containsExactly("c");
 
-    PathFragment p3 = PathFragment.create("C:/");
-    assertThat(p3.isAbsolute()).isTrue();
-    assertThat(p3.getDriveLetter()).isEqualTo('C');
-    assertThat(p3.getSegments()).isEmpty();
+    assertThat(create("C:/").isAbsolute()).isTrue();
+    assertThat(create("C:/").getSegments()).isEmpty();
 
-    PathFragment p5 = PathFragment.create("/c:");
+    PathFragment p5 = create("/c:");
     assertThat(p5.isAbsolute()).isTrue();
-    assertThat(p5.getDriveLetter()).isEqualTo('\0');
     assertThat(p5.getSegments()).containsExactly("c:");
+    assertThat(create("C:").isAbsolute()).isFalse();
 
-    assertThat(p1).isEqualTo(p2);
-    assertThat(p1).isNotEqualTo(p3);
-    assertThat(p1).isNotEqualTo(p5);
-    assertThat(p3).isNotEqualTo(p5);
+    assertThat(create("/c:").isAbsolute()).isTrue();
+    assertThat(create("/c:").getSegments()).containsExactly("c:");
+
+    assertThat(create("/c")).isEqualTo(create("/c/"));
+    assertThat(create("/c")).isNotEqualTo(create("C:/"));
+    assertThat(create("/c")).isNotEqualTo(create("C:"));
+    assertThat(create("/c")).isNotEqualTo(create("/c:"));
+    assertThat(create("C:/")).isNotEqualTo(create("C:"));
+    assertThat(create("C:/")).isNotEqualTo(create("/c:"));
   }
 
   @Test
   public void testIsAbsoluteWindowsBackslash() {
-    assertThat(PathFragment.create(new File("C:\\blah")).isAbsolute()).isTrue();
-    assertThat(PathFragment.create(new File("C:\\")).isAbsolute()).isTrue();
-    assertThat(PathFragment.create(new File("\\blah")).isAbsolute()).isTrue();
-    assertThat(PathFragment.create(new File("\\")).isAbsolute()).isTrue();
-  }
-
-  @Test
-  public void testIsNormalizedWindows() {
-    assertThat(PathFragment.create("C:/").isNormalized()).isTrue();
-    assertThat(PathFragment.create("C:/absolute/path").isNormalized()).isTrue();
-    assertThat(PathFragment.create("C:/absolute/./path").isNormalized()).isFalse();
-    assertThat(PathFragment.create("C:/absolute/../path").isNormalized()).isFalse();
+    assertThat(create(new File("C:\\blah").getPath()).isAbsolute()).isTrue();
+    assertThat(create(new File("C:\\").getPath()).isAbsolute()).isTrue();
+    assertThat(create(new File("\\blah").getPath()).isAbsolute()).isTrue();
+    assertThat(create(new File("\\").getPath()).isAbsolute()).isTrue();
   }
 
   @Test
   public void testRootNodeReturnsRootStringWindows() {
-    PathFragment rootFragment = PathFragment.create("C:/");
-    assertThat(rootFragment.getPathString()).isEqualTo("C:/");
+    assertThat(create("C:/").getPathString()).isEqualTo("C:/");
   }
 
   @Test
   public void testGetRelativeWindows() {
-    assertThat(PathFragment.create("C:/a").getRelative("b").getPathString()).isEqualTo("C:/a/b");
-    assertThat(PathFragment.create("C:/a/b").getRelative("c/d").getPathString())
-        .isEqualTo("C:/a/b/c/d");
-    assertThat(PathFragment.create("C:/a").getRelative("C:/b").getPathString()).isEqualTo("C:/b");
-    assertThat(PathFragment.create("C:/a/b").getRelative("C:/c/d").getPathString())
-        .isEqualTo("C:/c/d");
-    assertThat(PathFragment.create("a").getRelative("C:/b").getPathString()).isEqualTo("C:/b");
-    assertThat(PathFragment.create("a/b").getRelative("C:/c/d").getPathString())
-        .isEqualTo("C:/c/d");
-  }
-
-  private void assertGetRelative(String path, String relative, PathFragment expected)
-      throws Exception {
-    PathFragment actual = PathFragment.create(path).getRelative(relative);
-    assertThat(actual.getPathString()).isEqualTo(expected.getPathString());
-    assertThat(actual).isEqualTo(expected);
-    assertThat(actual.getDriveLetter()).isEqualTo(expected.getDriveLetter());
-    assertThat(actual.hashCode()).isEqualTo(expected.hashCode());
-  }
-
-  private void assertRelativeTo(String path, String relativeTo, String... expectedPathSegments)
-      throws Exception {
-    PathFragment expected = PathFragment.createAlreadyInterned('\0', false, expectedPathSegments);
-    PathFragment actual = PathFragment.create(path).relativeTo(relativeTo);
-    assertThat(actual.getPathString()).isEqualTo(expected.getPathString());
-    assertThat(actual).isEqualTo(expected);
-    assertThat(actual.getDriveLetter()).isEqualTo(expected.getDriveLetter());
-    assertThat(actual.hashCode()).isEqualTo(expected.hashCode());
-  }
-
-  private void assertCantComputeRelativeTo(String path, String relativeTo) throws Exception {
-    try {
-      PathFragment.create(path).relativeTo(relativeTo);
-      fail("expected failure");
-    } catch (Exception e) {
-      assertThat(e).hasMessageThat().contains("is not beneath");
-    }
-  }
-
-  private static PathFragment makePath(char drive, boolean absolute, String... segments) {
-    return PathFragment.createAlreadyInterned(drive, absolute, segments);
+    assertThat(create("C:/a").getRelative("b").getPathString()).isEqualTo("C:/a/b");
+    assertThat(create("C:/a/b").getRelative("c/d").getPathString()).isEqualTo("C:/a/b/c/d");
+    assertThat(create("C:/a").getRelative("C:/b").getPathString()).isEqualTo("C:/b");
+    assertThat(create("C:/a/b").getRelative("C:/c/d").getPathString()).isEqualTo("C:/c/d");
+    assertThat(create("a").getRelative("C:/b").getPathString()).isEqualTo("C:/b");
+    assertThat(create("a/b").getRelative("C:/c/d").getPathString()).isEqualTo("C:/c/d");
   }
 
   @Test
   public void testGetRelativeMixed() throws Exception {
-    assertGetRelative("a", "b", makePath('\0', false, "a", "b"));
-    assertGetRelative("a", "/b", makePath('\0', true, "b"));
-    assertGetRelative("a", "E:/b", makePath('E', true, "b"));
+    assertThat(create("a").getRelative("b")).isEqualTo(create("a/b"));
+    assertThat(create("a").getRelative("/b")).isEqualTo(create("/b"));
+    assertThat(create("a").getRelative("E:/b")).isEqualTo(create("E:/b"));
 
-    assertGetRelative("/a", "b", makePath('\0', true, "a", "b"));
-    assertGetRelative("/a", "/b", makePath('\0', true, "b"));
-    assertGetRelative("/a", "E:/b", makePath('E', true, "b"));
+    assertThat(create("/a").getRelative("b")).isEqualTo(create("/a/b"));
+    assertThat(create("/a").getRelative("/b")).isEqualTo(create("/b"));
+    assertThat(create("/a").getRelative("E:/b")).isEqualTo(create("E:/b"));
 
-    assertGetRelative("D:/a", "b", makePath('D', true, "a", "b"));
-    assertGetRelative("D:/a", "/b", makePath('D', true, "b"));
-    assertGetRelative("D:/a", "E:/b", makePath('E', true, "b"));
+    assertThat(create("D:/a").getRelative("b")).isEqualTo(create("D:/a/b"));
+    assertThat(create("D:/a").getRelative("/b")).isEqualTo(create("/b"));
+    assertThat(create("D:/a").getRelative("E:/b")).isEqualTo(create("E:/b"));
   }
 
   @Test
   public void testRelativeTo() throws Exception {
-    assertRelativeTo("", "");
-    assertCantComputeRelativeTo("", "a");
+    assertThat(create("").relativeTo("").getPathString()).isEqualTo("");
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("").relativeTo("a"));
 
-    assertRelativeTo("a", "", "a");
-    assertRelativeTo("a", "a");
-    assertCantComputeRelativeTo("a", "b");
-    assertRelativeTo("a/b", "a", "b");
+    assertThat(create("a").relativeTo("")).isEqualTo(create("a"));
+    assertThat(create("a").relativeTo("a").getPathString()).isEqualTo("");
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("a").relativeTo("b"));
+    assertThat(create("a/b").relativeTo("a")).isEqualTo(create("b"));
 
-    assertCantComputeRelativeTo("C:/", "");
-    assertRelativeTo("C:/", "C:/");
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("C:/").relativeTo(""));
+    assertThat(create("C:/").relativeTo("C:/").getPathString()).isEqualTo("");
   }
 
   @Test
   public void testGetChildWorks() {
-    PathFragment pf = PathFragment.create("../some/path");
-    assertThat(pf.getChild("hi")).isEqualTo(PathFragment.create("../some/path/hi"));
-  }
-
-  // Tests after here test the canonicalization
-  private void assertRegular(String expected, String actual) {
-    PathFragment exp = PathFragment.create(expected);
-    PathFragment act = PathFragment.create(actual);
-    assertThat(exp.getPathString()).isEqualTo(expected);
-    assertThat(act.getPathString()).isEqualTo(expected);
-    assertThat(act).isEqualTo(exp);
-    assertThat(act.hashCode()).isEqualTo(exp.hashCode());
+    assertThat(create("../some/path").getChild("hi")).isEqualTo(create("../some/path/hi"));
   }
 
   @Test
   public void testEmptyPathToEmptyPathWindows() {
-    assertRegular("C:/", "C:/");
-  }
-
-  private void assertAllEqual(PathFragment... ps) {
-    assertThat(ps.length).isGreaterThan(1);
-    for (int i = 1; i < ps.length; i++) {
-      String msg = "comparing items 0 and " + i;
-      assertWithMessage(msg + " for getPathString")
-          .that(ps[i].getPathString())
-          .isEqualTo(ps[0].getPathString());
-      assertWithMessage(msg + " for equals").that(ps[0]).isEqualTo(ps[i]);
-      assertWithMessage(msg + " for hashCode").that(ps[0].hashCode()).isEqualTo(ps[i].hashCode());
-    }
-  }
-
-  @Test
-  public void testEmptyRelativePathToEmptyPathWindows() {
-    // Surprising but correct behavior: a PathFragment made of just a drive identifier (and not the
-    // absolute path "C:/") is equal not only to the empty fragment, but (therefore) also to other
-    // drive identifiers.
-    // This makes sense if you consider that these are still empty paths, the drive letter adds no
-    // information to the path itself.
-    assertAllEqual(
-        PathFragment.EMPTY_FRAGMENT,
-        PathFragment.createAlreadyInterned('\0', false, new String[0]),
-        PathFragment.createAlreadyInterned('C', false, new String[0]),
-        PathFragment.createAlreadyInterned('D', false, new String[0]));
-    assertAllEqual(PathFragment.create("/c"), PathFragment.create("/c/"));
-    assertThat(PathFragment.create("C:/")).isNotEqualTo(PathFragment.create("/c"));
-    assertThat(PathFragment.create("C:/foo")).isNotEqualTo(PathFragment.create("/c/foo"));
-
-    assertThat(PathFragment.create("C:/")).isNotEqualTo(PathFragment.create("C:"));
-    assertThat(PathFragment.create("C:/").getPathString())
-        .isNotEqualTo(PathFragment.create("C:").getPathString());
+    assertThat(create("C:/")).isEqualTo(create("C:/"));
   }
 
   @Test
   public void testWindowsVolumeUppercase() {
-    assertRegular("C:/", "c:/");
+    assertThat(create("C:/")).isEqualTo(create("c:/"));
   }
 
   @Test
   public void testRedundantSlashesWindows() {
-    assertRegular("C:/", "C:///");
-    assertRegular("C:/foo/bar", "C:/foo///bar");
-    assertRegular("C:/foo/bar", "C:////foo//bar");
+    assertThat(create("C:/")).isEqualTo(create("C:///"));
+    assertThat(create("C:/foo/bar")).isEqualTo(create("C:/foo///bar"));
+    assertThat(create("C:/foo/bar")).isEqualTo(create("C:////foo//bar"));
   }
 
   @Test
   public void testSimpleNameToSimpleNameWindows() {
-    assertRegular("C:/foo", "C:/foo");
+    assertThat(create("C:/foo")).isEqualTo(create("C:/foo"));
   }
 
   @Test
   public void testStripsTrailingSlashWindows() {
-    assertRegular("C:/foo/bar", "C:/foo/bar/");
+    assertThat(create("C:/foo/bar")).isEqualTo(create("C:/foo/bar/"));
   }
 
   @Test
   public void testGetParentDirectoryWindows() {
-    PathFragment fooBarWizAbs = PathFragment.create("C:/foo/bar/wiz");
-    PathFragment fooBarAbs = PathFragment.create("C:/foo/bar");
-    PathFragment fooAbs = PathFragment.create("C:/foo");
-    PathFragment rootAbs = PathFragment.create("C:/");
-    assertThat(fooBarWizAbs.getParentDirectory()).isEqualTo(fooBarAbs);
-    assertThat(fooBarAbs.getParentDirectory()).isEqualTo(fooAbs);
-    assertThat(fooAbs.getParentDirectory()).isEqualTo(rootAbs);
-    assertThat(rootAbs.getParentDirectory()).isNull();
-
-    // Note, this is suprising but correct behaviour:
-    assertThat(PathFragment.create("C:/foo/bar/..").getParentDirectory()).isEqualTo(fooBarAbs);
+    assertThat(create("C:/foo/bar/wiz").getParentDirectory()).isEqualTo(create("C:/foo/bar"));
+    assertThat(create("C:/foo/bar").getParentDirectory()).isEqualTo(create("C:/foo"));
+    assertThat(create("C:/foo").getParentDirectory()).isEqualTo(create("C:/"));
+    assertThat(create("C:/").getParentDirectory()).isNull();
   }
 
   @Test
   public void testSegmentsCountWindows() {
-    assertThat(PathFragment.create("C:/foo").segmentCount()).isEqualTo(1);
-    assertThat(PathFragment.create("C:/").segmentCount()).isEqualTo(0);
+    assertThat(create("C:/foo").segmentCount()).isEqualTo(1);
+    assertThat(create("C:/").segmentCount()).isEqualTo(0);
   }
 
   @Test
   public void testGetSegmentWindows() {
-    assertThat(PathFragment.create("C:/foo/bar").getSegment(0)).isEqualTo("foo");
-    assertThat(PathFragment.create("C:/foo/bar").getSegment(1)).isEqualTo("bar");
-    assertThat(PathFragment.create("C:/foo/").getSegment(0)).isEqualTo("foo");
-    assertThat(PathFragment.create("C:/foo").getSegment(0)).isEqualTo("foo");
+    assertThat(create("C:/foo/bar").getSegment(0)).isEqualTo("foo");
+    assertThat(create("C:/foo/bar").getSegment(1)).isEqualTo("bar");
+    assertThat(create("C:/foo/").getSegment(0)).isEqualTo("foo");
+    assertThat(create("C:/foo").getSegment(0)).isEqualTo("foo");
   }
 
   @Test
   public void testBasenameWindows() throws Exception {
-    assertThat(PathFragment.create("C:/foo/bar").getBaseName()).isEqualTo("bar");
-    assertThat(PathFragment.create("C:/foo").getBaseName()).isEqualTo("foo");
+    assertThat(create("C:/foo/bar").getBaseName()).isEqualTo("bar");
+    assertThat(create("C:/foo").getBaseName()).isEqualTo("foo");
     // Never return the drive name as a basename.
-    assertThat(PathFragment.create("C:/").getBaseName()).isEmpty();
-  }
-
-  private static void assertPath(String expected, PathFragment actual) {
-    assertThat(actual.getPathString()).isEqualTo(expected);
+    assertThat(create("C:/").getBaseName()).isEmpty();
   }
 
   @Test
   public void testReplaceNameWindows() throws Exception {
-    assertPath("C:/foo/baz", PathFragment.create("C:/foo/bar").replaceName("baz"));
-    assertThat(PathFragment.create("C:/").replaceName("baz")).isNull();
+    assertThat(create("C:/foo/bar").replaceName("baz").getPathString()).isEqualTo("C:/foo/baz");
+    assertThat(create("C:/").replaceName("baz")).isNull();
   }
 
   @Test
   public void testStartsWithWindows() {
-    assertThat(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:/foo")))
-        .isTrue();
-    assertThat(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:/"))).isTrue();
-    assertThat(PathFragment.create("C:/").startsWith(PathFragment.create("C:/"))).isTrue();
+    assertThat(create("C:/foo/bar").startsWith(create("C:/foo"))).isTrue();
+    assertThat(create("C:/foo/bar").startsWith(create("C:/"))).isTrue();
+    assertThat(create("C:/").startsWith(create("C:/"))).isTrue();
 
     // The first path is absolute, the second is not.
-    assertThat(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:"))).isFalse();
-    assertThat(PathFragment.create("C:/").startsWith(PathFragment.create("C:"))).isFalse();
+    assertThat(create("C:/foo/bar").startsWith(create("C:"))).isFalse();
+    assertThat(create("C:/").startsWith(create("C:"))).isFalse();
   }
 
   @Test
   public void testEndsWithWindows() {
-    assertThat(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("bar"))).isTrue();
-    assertThat(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("foo/bar"))).isTrue();
-    assertThat(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("C:/foo/bar")))
-        .isTrue();
-    assertThat(PathFragment.create("C:/").endsWith(PathFragment.create("C:/"))).isTrue();
+    assertThat(create("C:/foo/bar").endsWith(create("bar"))).isTrue();
+    assertThat(create("C:/foo/bar").endsWith(create("foo/bar"))).isTrue();
+    assertThat(create("C:/foo/bar").endsWith(create("C:/foo/bar"))).isTrue();
+    assertThat(create("C:/").endsWith(create("C:/"))).isTrue();
   }
 
   @Test
   public void testGetSafePathStringWindows() {
-    assertThat(PathFragment.create("C:/").getSafePathString()).isEqualTo("C:/");
-    assertThat(PathFragment.create("C:/abc").getSafePathString()).isEqualTo("C:/abc");
-    assertThat(PathFragment.create("C:/abc/def").getSafePathString()).isEqualTo("C:/abc/def");
+    assertThat(create("C:/").getSafePathString()).isEqualTo("C:/");
+    assertThat(create("C:/abc").getSafePathString()).isEqualTo("C:/abc");
+    assertThat(create("C:/abc/def").getSafePathString()).isEqualTo("C:/abc/def");
   }
 
   @Test
   public void testNormalizeWindows() {
-    assertThat(PathFragment.create("C:/a/b").normalize()).isEqualTo(PathFragment.create("C:/a/b"));
-    assertThat(PathFragment.create("C:/a/./b").normalize())
-        .isEqualTo(PathFragment.create("C:/a/b"));
-    assertThat(PathFragment.create("C:/a/../b").normalize()).isEqualTo(PathFragment.create("C:/b"));
-    assertThat(PathFragment.create("C:/../b").normalize())
-        .isEqualTo(PathFragment.create("C:/../b"));
+    assertThat(create("C:/a/b")).isEqualTo(create("C:/a/b"));
+    assertThat(create("C:/a/./b")).isEqualTo(create("C:/a/b"));
+    assertThat(create("C:/a/../b")).isEqualTo(create("C:/b"));
+    assertThat(create("C:/../b")).isEqualTo(create("C:/../b"));
   }
 
   @Test
@@ -335,8 +231,21 @@
     // of drive C:\".
     // Bazel doesn't resolve such paths, and just takes them literally like normal path segments.
     // If the user attempts to open files under such paths, the file system API will give an error.
-    assertThat(PathFragment.create("C:").isAbsolute()).isFalse();
-    assertThat(PathFragment.create("C:").getDriveLetter()).isEqualTo('\0');
-    assertThat(PathFragment.create("C:").getSegments()).containsExactly("C:");
+    assertThat(create("C:").isAbsolute()).isFalse();
+    assertThat(create("C:").getSegments()).containsExactly("C:");
+  }
+
+  @Test
+  public void testToRelative() {
+    assertThat(create("C:/foo/bar").toRelative()).isEqualTo(create("foo/bar"));
+    assertThat(create("C:/").toRelative()).isEqualTo(create(""));
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").toRelative());
+  }
+
+  @Test
+  public void testGetDriveStr() {
+    assertThat(create("C:/foo/bar").getDriveStr()).isEqualTo("C:/");
+    assertThat(create("C:/").getDriveStr()).isEqualTo("C:/");
+    MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").getDriveStr());
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java
deleted file mode 100644
index eaad458..0000000
--- a/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright 2014 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.fail;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.google.common.testing.EqualsTester;
-import com.google.common.testing.GcFinalization;
-import com.google.devtools.build.lib.clock.BlazeClock;
-import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodecAdapter;
-import com.google.devtools.build.lib.skyframe.serialization.testutils.FsUtils;
-import com.google.devtools.build.lib.skyframe.serialization.testutils.ObjectCodecTester;
-import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.lang.ref.WeakReference;
-import java.net.URI;
-import java.util.Collections;
-import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * A test for {@link Path}.
- */
-@RunWith(JUnit4.class)
-public class PathTest {
-  private FileSystem filesystem;
-  private Path root;
-
-  @Before
-  public final void initializeFileSystem() throws Exception  {
-    filesystem = new InMemoryFileSystem(BlazeClock.instance());
-    root = filesystem.getRootDirectory();
-    Path first = root.getChild("first");
-    first.createDirectory();
-  }
-
-  @Test
-  public void testStartsWithWorksForSelf() {
-    assertStartsWithReturns(true, "/first/child", "/first/child");
-  }
-
-  @Test
-  public void testStartsWithWorksForChild() {
-    assertStartsWithReturns(true,
-        "/first/child", "/first/child/grandchild");
-  }
-
-  @Test
-  public void testStartsWithWorksForDeepDescendant() {
-    assertStartsWithReturns(true,
-        "/first/child", "/first/child/grandchild/x/y/z");
-  }
-
-  @Test
-  public void testStartsWithFailsForParent() {
-    assertStartsWithReturns(false, "/first/child", "/first");
-  }
-
-  @Test
-  public void testStartsWithFailsForSibling() {
-    assertStartsWithReturns(false, "/first/child", "/first/child2");
-  }
-
-  @Test
-  public void testStartsWithFailsForLinkToDescendant()
-      throws Exception {
-    Path linkTarget = filesystem.getPath("/first/linked_to");
-    FileSystemUtils.createEmptyFile(linkTarget);
-    Path second = filesystem.getPath("/second/");
-    second.createDirectory();
-    second.getChild("child_link").createSymbolicLink(linkTarget);
-    assertStartsWithReturns(false, "/first", "/second/child_link");
-  }
-
-  @Test
-  public void testStartsWithFailsForNullPrefix() {
-    try {
-      filesystem.getPath("/first").startsWith(null);
-      fail();
-    } catch (Exception e) {
-    }
-  }
-
-  private void assertStartsWithReturns(boolean expected,
-                                       String ancestor,
-                                       String descendant) {
-    Path parent = filesystem.getPath(ancestor);
-    Path child = filesystem.getPath(descendant);
-    assertThat(child.startsWith(parent)).isEqualTo(expected);
-  }
-
-  @Test
-  public void testGetChildWorks() {
-    assertGetChildWorks("second");
-    assertGetChildWorks("...");
-    assertGetChildWorks("....");
-  }
-
-  private void assertGetChildWorks(String childName) {
-    assertThat(filesystem.getPath("/first").getChild(childName))
-        .isEqualTo(filesystem.getPath("/first/" + childName));
-  }
-
-  @Test
-  public void testGetChildFailsForChildWithSlashes() {
-    assertGetChildFails("second/third");
-    assertGetChildFails("./third");
-    assertGetChildFails("../third");
-    assertGetChildFails("second/..");
-    assertGetChildFails("second/.");
-    assertGetChildFails("/third");
-    assertGetChildFails("third/");
-  }
-
-  private void assertGetChildFails(String childName) {
-    try {
-      filesystem.getPath("/first").getChild(childName);
-      fail();
-    } catch (IllegalArgumentException e) {
-      // Expected.
-    }
-  }
-
-  @Test
-  public void testGetChildFailsForDotAndDotDot() {
-    assertGetChildFails(".");
-    assertGetChildFails("..");
-  }
-
-  @Test
-  public void testGetChildFailsForEmptyString() {
-    assertGetChildFails("");
-  }
-
-  @Test
-  public void testRelativeToWorks() {
-    assertRelativeToWorks("apple", "/fruit/apple", "/fruit");
-    assertRelativeToWorks("apple/jonagold", "/fruit/apple/jonagold", "/fruit");
-  }
-
-  @Test
-  public void testGetRelativeWithStringWorks() {
-    assertGetRelativeWorks("/first/x/y", "y");
-    assertGetRelativeWorks("/y", "/y");
-    assertGetRelativeWorks("/first/x/x", "./x");
-    assertGetRelativeWorks("/first/y", "../y");
-    assertGetRelativeWorks("/", "../../../../..");
-  }
-
-  @Test
-  public void testAsFragmentWorks() {
-    assertAsFragmentWorks("/");
-    assertAsFragmentWorks("//");
-    assertAsFragmentWorks("/first");
-    assertAsFragmentWorks("/first/x/y");
-    assertAsFragmentWorks("/first/x/y.foo");
-  }
-
-  @Test
-  public void testGetRelativeWithFragmentWorks() {
-    Path dir = filesystem.getPath("/first/x");
-    assertThat(dir.getRelative(PathFragment.create("y")).toString()).isEqualTo("/first/x/y");
-    assertThat(dir.getRelative(PathFragment.create("./x")).toString()).isEqualTo("/first/x/x");
-    assertThat(dir.getRelative(PathFragment.create("../y")).toString()).isEqualTo("/first/y");
-  }
-
-  @Test
-  public void testGetRelativeWithAbsoluteFragmentWorks() {
-    Path root = filesystem.getPath("/first/x");
-    assertThat(root.getRelative(PathFragment.create("/x/y")).toString()).isEqualTo("/x/y");
-  }
-
-  @Test
-  public void testGetRelativeWithAbsoluteStringWorks() {
-    Path root = filesystem.getPath("/first/x");
-    assertThat(root.getRelative("/x/y").toString()).isEqualTo("/x/y");
-  }
-
-  @Test
-  public void testComparableSortOrder() {
-    Path zzz = filesystem.getPath("/zzz");
-    Path ZZZ = filesystem.getPath("/ZZZ");
-    Path abc = filesystem.getPath("/abc");
-    Path aBc = filesystem.getPath("/aBc");
-    Path AbC = filesystem.getPath("/AbC");
-    Path ABC = filesystem.getPath("/ABC");
-    List<Path> list = Lists.newArrayList(zzz, ZZZ, ABC, aBc, AbC, abc);
-    Collections.sort(list);
-    assertThat(list).containsExactly(ABC, AbC, ZZZ, aBc, abc, zzz).inOrder();
-  }
-
-  @Test
-  public void testParentOfRootIsRoot() {
-    assertThat(root.getRelative("..")).isSameAs(root);
-
-    assertThat(root.getRelative("broken/../../dots")).isSameAs(root.getRelative("dots"));
-  }
-
-  @Test
-  public void testSingleSegmentEquivalence() {
-    assertThat(root.getRelative("aSingleSegment")).isSameAs(root.getRelative("aSingleSegment"));
-  }
-
-  @Test
-  public void testSiblingNonEquivalenceString() {
-    assertThat(root.getRelative("aDifferentSegment"))
-        .isNotSameAs(root.getRelative("aSingleSegment"));
-  }
-
-  @Test
-  public void testSiblingNonEquivalenceFragment() {
-    assertThat(root.getRelative(PathFragment.create("aDifferentSegment")))
-        .isNotSameAs(root.getRelative(PathFragment.create("aSingleSegment")));
-  }
-
-  @Test
-  public void testHashCodeStableAcrossGarbageCollections() {
-    Path parent = filesystem.getPath("/a");
-    PathFragment childFragment = PathFragment.create("b");
-    Path child = parent.getRelative(childFragment);
-    WeakReference<Path> childRef = new WeakReference<>(child);
-    int childHashCode1 = childRef.get().hashCode();
-    assertThat(parent.getRelative(childFragment).hashCode()).isEqualTo(childHashCode1);
-    child = null;
-    GcFinalization.awaitClear(childRef);
-    int childHashCode2 = parent.getRelative(childFragment).hashCode();
-    assertThat(childHashCode2).isEqualTo(childHashCode1);
-  }
-
-  @Test
-  public void testSerialization() throws Exception {
-    FileSystem oldFileSystem = Path.getFileSystemForSerialization();
-    try {
-      Path.setFileSystemForSerialization(filesystem);
-      Path root = filesystem.getPath("/");
-      Path p1 = filesystem.getPath("/foo");
-      Path p2 = filesystem.getPath("/foo/bar");
-
-      ByteArrayOutputStream bos = new ByteArrayOutputStream();
-      ObjectOutputStream oos = new ObjectOutputStream(bos);
-
-      oos.writeObject(root);
-      oos.writeObject(p1);
-      oos.writeObject(p2);
-
-      ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
-      ObjectInputStream ois = new ObjectInputStream(bis);
-
-      Path dsRoot = (Path) ois.readObject();
-      Path dsP1 = (Path) ois.readObject();
-      Path dsP2 = (Path) ois.readObject();
-
-      new EqualsTester()
-          .addEqualityGroup(root, dsRoot)
-          .addEqualityGroup(p1, dsP1)
-          .addEqualityGroup(p2, dsP2)
-          .testEquals();
-
-      assertThat(p2.startsWith(p1)).isTrue();
-      assertThat(p2.startsWith(dsP1)).isTrue();
-      assertThat(dsP2.startsWith(p1)).isTrue();
-      assertThat(dsP2.startsWith(dsP1)).isTrue();
-
-      // Regression test for a very specific bug in compareTo involving our incorrect usage of
-      // reference equality rather than logical equality.
-      String relativePathStringA = "child/grandchildA";
-      String relativePathStringB = "child/grandchildB";
-      assertThat(
-              p1.getRelative(relativePathStringA).compareTo(dsP1.getRelative(relativePathStringB)))
-          .isEqualTo(
-              p1.getRelative(relativePathStringA).compareTo(p1.getRelative(relativePathStringB)));
-    } finally {
-      Path.setFileSystemForSerialization(oldFileSystem);
-    }
-  }
-
-  @Test
-  public void testAbsolutePathRoot() {
-    assertThat(new Path(null).toString()).isEqualTo("/");
-  }
-
-  @Test
-  public void testAbsolutePath() {
-    Path segment = new Path(null, "bar.txt",
-      new Path(null, "foo", new Path(null)));
-    assertThat(segment.toString()).isEqualTo("/foo/bar.txt");
-  }
-
-  @Test
-  public void testToURI() throws Exception {
-    Path p = root.getRelative("/tmp/foo bar.txt");
-    URI uri = p.toURI();
-    assertThat(uri.toString()).isEqualTo("file:///tmp/foo%20bar.txt");
-  }
-
-  @Test
-  public void testCodec() throws Exception {
-    ObjectCodecTester.newBuilder(
-            new InjectingObjectCodecAdapter<>(Path.CODEC, FsUtils.TEST_FILESYSTEM_PROVIDER))
-        .addSubjects(
-            ImmutableList.of(
-                FsUtils.TEST_FILESYSTEM.getPath("/"),
-                FsUtils.TEST_FILESYSTEM.getPath("/some/path"),
-                FsUtils.TEST_FILESYSTEM.getPath("/some/other/path/with/empty/last/fragment/")))
-        .buildAndRunTests();
-  }
-
-  private void assertAsFragmentWorks(String expected) {
-    assertThat(filesystem.getPath(expected).asFragment()).isEqualTo(PathFragment.create(expected));
-  }
-
-  private void assertGetRelativeWorks(String expected, String relative) {
-    assertThat(filesystem.getPath("/first/x").getRelative(relative))
-        .isEqualTo(filesystem.getPath(expected));
-  }
-
-  private void assertRelativeToWorks(String expected, String relative, String original) {
-    assertThat(filesystem.getPath(relative).relativeTo(filesystem.getPath(original)))
-        .isEqualTo(PathFragment.create(expected));
-  }
-}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathTrieTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathTrieTest.java
deleted file mode 100644
index 0807b4a..0000000
--- a/src/test/java/com/google/devtools/build/lib/vfs/PathTrieTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2014 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.vfs;
-
-import static com.google.common.truth.Truth.assertThat;
-import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link PathTrie}. */
-@RunWith(JUnit4.class)
-public class PathTrieTest {
-  @Test
-  public void empty() {
-    PathTrie<Integer> pathTrie = new PathTrie<>();
-    assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/x"))).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/x/y"))).isNull();
-  }
-
-  @Test
-  public void simpleBranches() {
-    PathTrie<Integer> pathTrie = new PathTrie<>();
-    pathTrie.put(PathFragment.create("/a"), 1);
-    pathTrie.put(PathFragment.create("/b"), 2);
-
-    assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/a"))).isEqualTo(1);
-    assertThat(pathTrie.get(PathFragment.create("/a/b"))).isEqualTo(1);
-    assertThat(pathTrie.get(PathFragment.create("/a/b/c"))).isEqualTo(1);
-    assertThat(pathTrie.get(PathFragment.create("/b"))).isEqualTo(2);
-    assertThat(pathTrie.get(PathFragment.create("/b/c"))).isEqualTo(2);
-  }
-
-  @Test
-  public void nestedDirectories() {
-    PathTrie<Integer> pathTrie = new PathTrie<>();
-    pathTrie.put(PathFragment.create("/a/b/c"), 3);
-    assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/a"))).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/a/b"))).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/a/b/c"))).isEqualTo(3);
-    assertThat(pathTrie.get(PathFragment.create("/a/b/c/d"))).isEqualTo(3);
-
-    pathTrie.put(PathFragment.create("/a"), 1);
-    assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/b"))).isNull();
-    assertThat(pathTrie.get(PathFragment.create("/a"))).isEqualTo(1);
-    assertThat(pathTrie.get(PathFragment.create("/a/b"))).isEqualTo(1);
-    assertThat(pathTrie.get(PathFragment.create("/a/b/c"))).isEqualTo(3);
-    assertThat(pathTrie.get(PathFragment.create("/a/b/c/d"))).isEqualTo(3);
-
-    pathTrie.put(PathFragment.ROOT_FRAGMENT, 0);
-    assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isEqualTo(0);
-    assertThat(pathTrie.get(PathFragment.create("/b"))).isEqualTo(0);
-    assertThat(pathTrie.get(PathFragment.create("/a"))).isEqualTo(1);
-    assertThat(pathTrie.get(PathFragment.create("/a/b"))).isEqualTo(1);
-  }
-
-  @Test
-  public void unrootedDirectoriesError() {
-    PathTrie<Integer> pathTrie = new PathTrie<>();
-    assertThrows(IllegalArgumentException.class, () -> pathTrie.put(PathFragment.create("a"), 1));
-  }
-}
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java
index 4720a6e..ba7029d 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java
@@ -16,6 +16,7 @@
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
+import com.google.devtools.build.lib.util.OS;
 import com.google.devtools.build.lib.vfs.FileSystem.NotASymlinkException;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -197,7 +198,8 @@
       linkPath.delete();
       createSymbolicLink(linkPath, relative);
       if (testFS.supportsSymbolicLinksNatively(linkPath)) {
-        assertThat(linkPath.getFileSize(Symlinks.NOFOLLOW)).isEqualTo(linkTarget.length());
+        assertThat(linkPath.getFileSize(Symlinks.NOFOLLOW))
+            .isEqualTo(relative.getSafePathString().length());
         assertThat(linkPath.readSymbolicLink()).isEqualTo(relative);
       }
     }
@@ -205,6 +207,10 @@
 
   @Test
   public void testLinkToRootResolvesCorrectly() throws IOException {
+    if (OS.getCurrent() == OS.WINDOWS) {
+      // This test cannot be run on Windows, it mixes "/" paths with "C:/" paths
+      return;
+    }
     Path rootPath = testFS.getPath("/");
 
     try {
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java
index 1e877a5..3799cfd 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java
@@ -163,7 +163,7 @@
 
     // FileSystemTest.setUp() silently creates the test root on the filesystem...
     Path testDirUnderRoot = unionfs.getPath(workingDir.asFragment().subFragment(0, 1));
-    assertThat(unionfs.getDirectoryEntries(unionfs.getRootDirectory()))
+    assertThat(unionfs.getDirectoryEntries(unionfs.getPath("/")))
         .containsExactly(
             foo.getBaseName(),
             bar.getBaseName(),
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnixLocalPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java
similarity index 76%
rename from src/test/java/com/google/devtools/build/lib/vfs/UnixLocalPathTest.java
rename to src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java
index 2cdb401..306ca9b 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/UnixLocalPathTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java
@@ -17,15 +17,13 @@
 import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;
 
 import com.google.common.testing.EqualsTester;
-import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy;
-import com.google.devtools.build.lib.vfs.LocalPath.UnixOsPathPolicy;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-/** Tests the unix implementation of {@link LocalPath}. */
+/** Tests the unix implementation of {@link Path}. */
 @RunWith(JUnit4.class)
-public class UnixLocalPathTest extends LocalPathAbstractTest {
+public class UnixPathTest extends PathAbstractTest {
 
   @Test
   public void testEqualsAndHashCodeUnix() {
@@ -37,8 +35,6 @@
 
   @Test
   public void testRelativeToUnix() {
-    // Cannot relativize absolute and non-absolute
-    assertThat(create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b");
     assertThat(create("/").relativeTo(create("/")).getPathString()).isEmpty();
     assertThat(create("/foo").relativeTo(create("/foo")).getPathString()).isEmpty();
     assertThat(create("/foo/bar/baz").relativeTo(create("/foo")).getPathString())
@@ -53,16 +49,24 @@
   }
 
   @Test
-  public void testIsAbsoluteUnix() {
-    assertThat(create("/absolute/test").isAbsolute()).isTrue();
-    assertThat(create("relative/test").isAbsolute()).isFalse();
-  }
-
-  @Test
   public void testGetRelativeUnix() {
     assertThat(create("/a").getRelative("b").getPathString()).isEqualTo("/a/b");
+    assertThat(create("/a/b").getRelative("c/d").getPathString()).isEqualTo("/a/b/c/d");
+    assertThat(create("/c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b");
+    assertThat(create("/a").getRelative("").getPathString()).isEqualTo("/a");
     assertThat(create("/").getRelative("").getPathString()).isEqualTo("/");
-    assertThat(create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b");
+    assertThat(create("/a/b").getRelative("../foo").getPathString()).isEqualTo("/a/foo");
+
+    // Make sure any fast path of Path#getRelative(PathFragment) works
+    assertThat(create("/a/b").getRelative(PathFragment.create("../foo")).getPathString())
+        .isEqualTo("/a/foo");
+
+    // Make sure any fast path of Path#getRelative(PathFragment) works
+    assertThat(create("/c/d").getRelative(PathFragment.create("/a/b")).getPathString())
+        .isEqualTo("/a/b");
+
+    // Test normalization
+    assertThat(create("/a").getRelative(".").getPathString()).isEqualTo("/a");
   }
 
   @Test
@@ -107,14 +111,10 @@
 
   @Test
   public void testGetParentDirectoryUnix() {
-    LocalPath fooBarWizAbs = create("/foo/bar/wiz");
-    LocalPath fooBarAbs = create("/foo/bar");
-    LocalPath fooAbs = create("/foo");
-    LocalPath rootAbs = create("/");
-    assertThat(fooBarWizAbs.getParentDirectory()).isEqualTo(fooBarAbs);
-    assertThat(fooBarAbs.getParentDirectory()).isEqualTo(fooAbs);
-    assertThat(fooAbs.getParentDirectory()).isEqualTo(rootAbs);
-    assertThat(rootAbs.getParentDirectory()).isNull();
+    assertThat(create("/foo/bar/wiz").getParentDirectory()).isEqualTo(create("/foo/bar"));
+    assertThat(create("/foo/bar").getParentDirectory()).isEqualTo(create("/foo"));
+    assertThat(create("/foo").getParentDirectory()).isEqualTo(create("/"));
+    assertThat(create("/").getParentDirectory()).isNull();
   }
 
   @Test
@@ -127,8 +127,7 @@
 
   @Test
   public void testStartsWithUnix() {
-    LocalPath foobar = create("/foo/bar");
-    LocalPath foobarRelative = create("foo/bar");
+    Path foobar = create("/foo/bar");
 
     // (path, prefix) => true
     assertThat(foobar.startsWith(foobar)).isTrue();
@@ -141,13 +140,6 @@
     assertThat(create("/foo").startsWith(foobar)).isFalse();
     assertThat(create("/").startsWith(foobar)).isFalse();
 
-    // (absolute, relative) => false
-    assertThat(foobar.startsWith(foobarRelative)).isFalse();
-    assertThat(foobarRelative.startsWith(foobar)).isFalse();
-
-    // relative paths start with nothing, absolute paths do not
-    assertThat(foobar.startsWith(create(""))).isFalse();
-
     // (path, sibling) => false
     assertThat(create("/foo/wiz").startsWith(foobar)).isFalse();
     assertThat(foobar.startsWith(create("/foo/wiz"))).isFalse();
@@ -162,8 +154,10 @@
     assertThat(create("/..")).isEqualTo(create("/.."));
   }
 
-  @Override
-  protected OsPathPolicy getFilePathOs() {
-    return new UnixOsPathPolicy();
+  @Test
+  public void testParentOfRootIsRootUnix() {
+    assertThat(create("/..")).isEqualTo(create("/"));
+    assertThat(create("/../../../../../..")).isEqualTo(create("/"));
+    assertThat(create("/../../../foo")).isEqualTo(create("/foo"));
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/WindowsLocalPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/WindowsPathTest.java
similarity index 62%
rename from src/test/java/com/google/devtools/build/lib/vfs/WindowsLocalPathTest.java
rename to src/test/java/com/google/devtools/build/lib/vfs/WindowsPathTest.java
index ac5acef..c759219 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/WindowsLocalPathTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/WindowsPathTest.java
@@ -17,18 +17,16 @@
 
 import com.google.common.testing.EqualsTester;
 import com.google.devtools.build.lib.testutil.MoreAsserts;
-import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy;
-import com.google.devtools.build.lib.vfs.LocalPath.WindowsOsPathPolicy;
-import com.google.devtools.build.lib.vfs.LocalPath.WindowsOsPathPolicy.ShortPathResolver;
+import com.google.devtools.build.lib.vfs.WindowsOsPathPolicy.ShortPathResolver;
 import java.util.HashMap;
 import java.util.Map;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-/** Tests windows-specific parts of {@link LocalPath} */
+/** Tests windows-specific parts of {@link Path} */
 @RunWith(JUnit4.class)
-public class WindowsLocalPathTest extends LocalPathAbstractTest {
+public class WindowsPathTest extends PathAbstractTest {
 
   private static final class MockShortPathResolver implements ShortPathResolver {
     // Full path to resolved child mapping.
@@ -52,26 +50,18 @@
     }
   }
 
-  private final MockShortPathResolver shortPathResolver = new MockShortPathResolver();
-
-  @Override
-  protected OsPathPolicy getFilePathOs() {
-    return new WindowsOsPathPolicy(shortPathResolver);
-  }
-
   @Test
   public void testEqualsAndHashcodeWindows() {
     new EqualsTester()
-        .addEqualityGroup(create("a/b"), create("A/B"))
         .addEqualityGroup(create("/a/b"), create("/A/B"))
         .addEqualityGroup(create("c:/a/b"), create("C:\\A\\B"))
-        .addEqualityGroup(create("something/else"))
+        .addEqualityGroup(create("C:/something/else"))
         .testEquals();
   }
 
   @Test
   public void testCaseIsPreserved() {
-    assertThat(create("a/B").getPathString()).isEqualTo("a/B");
+    assertThat(create("C:/a/B").getPathString()).isEqualTo("C:/a/B");
   }
 
   @Test
@@ -96,69 +86,62 @@
   public void testGetParentDirectoryWindows() {
     assertThat(create("C:/foo").getParentDirectory()).isEqualTo(create("C:/"));
     assertThat(create("C:/").getParentDirectory()).isNull();
+    assertThat(create("/").getParentDirectory()).isNull();
   }
 
   @Test
-  public void testisAbsoluteWindows() {
-    assertThat(create("C:/").isAbsolute()).isTrue();
-    // test that msys paths turn into absolute paths
-    assertThat(create("/").isAbsolute()).isTrue();
+  public void testParentOfRootIsRootWindows() {
+    assertThat(create("C:/..")).isEqualTo(create("C:/"));
+    assertThat(create("C:/../../../../../..")).isEqualTo(create("C:/"));
+    assertThat(create("C:/../../../foo")).isEqualTo(create("C:/foo"));
   }
 
   @Test
   public void testRelativeToWindows() {
-    assertThat(create("C:/foo").relativeTo(create("C:/"))).isEqualTo(create("foo"));
+    assertThat(create("C:/foo").relativeTo(create("C:/")).getPathString()).isEqualTo("foo");
     // Case insensitivity test
-    assertThat(create("C:/foo/bar").relativeTo(create("C:/FOO"))).isEqualTo(create("bar"));
+    assertThat(create("C:/foo/bar").relativeTo(create("C:/FOO")).getPathString()).isEqualTo("bar");
     MoreAsserts.assertThrows(
         IllegalArgumentException.class, () -> create("D:/foo").relativeTo(create("C:/")));
   }
 
   @Test
-  public void testAbsoluteUnixPathIsRelativeToWindowsUnixRoot() {
-    assertThat(create("/").getPathString()).isEqualTo("C:/fake/msys");
-    assertThat(create("/foo/bar").getPathString()).isEqualTo("C:/fake/msys/foo/bar");
-    assertThat(create("/foo/bar").getPathString()).isEqualTo("C:/fake/msys/foo/bar");
-  }
-
-  @Test
-  public void testAbsoluteUnixPathReferringToDriveIsRecognized() {
-    assertThat(create("/c/foo").getPathString()).isEqualTo("C:/foo");
-    assertThat(create("/c/foo").getPathString()).isEqualTo("C:/foo");
-    assertThat(create("/c:").getPathString()).isNotEqualTo("C:/foo");
-  }
-
-  @Test
   public void testResolvesShortenedPaths() {
+    MockShortPathResolver shortPathResolver = new MockShortPathResolver();
+    WindowsOsPathPolicy osPathPolicy = new WindowsOsPathPolicy(shortPathResolver);
     shortPathResolver.resolutions.put("d:/progra~1", "program files");
     shortPathResolver.resolutions.put("d:/program files/micros~1", "microsoft something");
     shortPathResolver.resolutions.put(
         "d:/program files/microsoft something/foo/~bar~1", "~bar_hello");
 
     // Assert normal shortpath resolution.
-    LocalPath normal = create("d:/progra~1/micros~1/foo/~bar~1/baz");
-    // The path string has an upper-case drive letter because that's how path printing works.
-    assertThat(normal.getPathString())
+    assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1/foo/~bar~1/baz"))
         .isEqualTo("D:/program files/microsoft something/foo/~bar_hello/baz");
-    LocalPath notYetExistent = create("d:/progra~1/micros~1/foo/will~1.exi/bar");
-    // The path string has an upper-case drive letter because that's how path printing works.
-    assertThat(notYetExistent.getPathString())
+    assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1/foo/will~1.exi/bar"))
         .isEqualTo("D:/program files/microsoft something/foo/will~1.exi/bar");
 
-    LocalPath msRoot = create("d:/progra~1/micros~1");
-    assertThat(msRoot.getPathString()).isEqualTo("D:/program files/microsoft something");
+    assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1"))
+        .isEqualTo("D:/program files/microsoft something");
 
     // Pretend that a path we already failed to resolve once came into existence.
     shortPathResolver.resolutions.put(
         "d:/program files/microsoft something/foo/will~1.exi", "will.exist");
 
     // Assert that this time we can resolve the previously non-existent path.
-    LocalPath nowExists = create("d:/progra~1/micros~1/foo/will~1.exi/bar");
     // The path string has an upper-case drive letter because that's how path printing works.
-    assertThat(nowExists.getPathString())
+    assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1/foo/will~1.exi/bar"))
         .isEqualTo("D:/program files/microsoft something/foo/will.exist/bar");
 
-    // Assert relative paths that look like short paths are untouched
-    assertThat(create("progra~1").getPathString()).isEqualTo("progra~1");
+    // Check needsToNormalized
+    assertThat(osPathPolicy.needsToNormalize("d:/progra~1/micros~1/foo/will~1.exi/bar"))
+        .isEqualTo(WindowsOsPathPolicy.NEEDS_SHORT_PATH_NORMALIZATION);
+    assertThat(osPathPolicy.needsToNormalize("will~1.exi"))
+        .isEqualTo(WindowsOsPathPolicy.NEEDS_SHORT_PATH_NORMALIZATION);
+    assertThat(osPathPolicy.needsToNormalize("d:/no-normalization"))
+        .isEqualTo(WindowsOsPathPolicy.NORMALIZED); // Sanity check
+  }
+
+  private static String normalize(OsPathPolicy osPathPolicy, String str) {
+    return osPathPolicy.normalize(str, osPathPolicy.needsToNormalize(str));
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/windows/PathWindowsTest.java b/src/test/java/com/google/devtools/build/lib/windows/PathWindowsTest.java
deleted file mode 100644
index e77de52..0000000
--- a/src/test/java/com/google/devtools/build/lib/windows/PathWindowsTest.java
+++ /dev/null
@@ -1,298 +0,0 @@
-// Copyright 2014 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.lib.windows;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.google.common.base.Function;
-import com.google.common.base.Predicate;
-import com.google.devtools.build.lib.clock.BlazeClock;
-import com.google.devtools.build.lib.vfs.FileSystem;
-import com.google.devtools.build.lib.vfs.Path;
-import com.google.devtools.build.lib.vfs.Path.PathFactory;
-import com.google.devtools.build.lib.vfs.PathFragment;
-import com.google.devtools.build.lib.vfs.Root;
-import com.google.devtools.build.lib.vfs.RootedPath;
-import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
-import com.google.devtools.build.lib.windows.WindowsFileSystem.WindowsPath;
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** A test for windows aspects of {@link Path}. */
-@RunWith(JUnit4.class)
-public class PathWindowsTest {
-
-  private static final class MockShortPathResolver implements Function<String, String> {
-    public List<String> resolutionQueries = new ArrayList<>();
-
-    // Full path to resolved child mapping.
-    public Map<String, String> resolutions = new HashMap<>();
-
-    @Override
-    public String apply(String path) {
-      path = path.toLowerCase();
-      resolutionQueries.add(path);
-      return resolutions.get(path);
-    }
-  }
-
-  private FileSystem filesystem;
-  private WindowsPath root;
-  private final MockShortPathResolver shortPathResolver = new MockShortPathResolver();
-
-  @Before
-  public final void initializeFileSystem() throws Exception {
-    filesystem =
-        new InMemoryFileSystem(BlazeClock.instance()) {
-          @Override
-          protected PathFactory getPathFactory() {
-            return WindowsFileSystem.getPathFactoryForTesting(shortPathResolver);
-          }
-
-          @Override
-          public boolean isFilePathCaseSensitive() {
-            return false;
-          }
-        };
-    root = (WindowsPath) filesystem.getRootDirectory().getRelative("C:/");
-    root.createDirectory();
-  }
-
-  private void assertAsFragmentWorks(String expected) {
-    assertThat(filesystem.getPath(expected).asFragment()).isEqualTo(PathFragment.create(expected));
-  }
-
-  @Test
-  public void testWindowsPath() {
-    Path p = filesystem.getPath("C:/foo/bar");
-    assertThat(p.getPathString()).isEqualTo("C:/foo/bar");
-    assertThat(p.toString()).isEqualTo("C:/foo/bar");
-  }
-
-  @Test
-  public void testAsFragmentWindows() {
-    assertAsFragmentWorks("C:/");
-    assertAsFragmentWorks("C://");
-    assertAsFragmentWorks("C:/first");
-    assertAsFragmentWorks("C:/first/x/y");
-    assertAsFragmentWorks("C:/first/x/y.foo");
-  }
-
-  @Test
-  public void testGetRelativeWithFragmentWindows() {
-    Path dir = filesystem.getPath("C:/first/x");
-    assertThat(dir.getRelative(PathFragment.create("y")).toString()).isEqualTo("C:/first/x/y");
-    assertThat(dir.getRelative(PathFragment.create("./x")).toString()).isEqualTo("C:/first/x/x");
-    assertThat(dir.getRelative(PathFragment.create("../y")).toString()).isEqualTo("C:/first/y");
-    assertThat(dir.getRelative(PathFragment.create("../y")).toString()).isEqualTo("C:/first/y");
-    assertThat(dir.getRelative(PathFragment.create("../../../y")).toString()).isEqualTo("C:/y");
-  }
-
-  @Test
-  public void testGetRelativeWithAbsoluteFragmentWindows() {
-    Path x = filesystem.getPath("C:/first/x");
-    assertThat(x.getRelative(PathFragment.create("C:/x/y")).toString()).isEqualTo("C:/x/y");
-  }
-
-  @Test
-  public void testGetRelativeWithAbsoluteStringWorksWindows() {
-    Path x = filesystem.getPath("C:/first/x");
-    assertThat(x.getRelative("C:/x/y").toString()).isEqualTo("C:/x/y");
-  }
-
-  @Test
-  public void testParentOfRootIsRootWindows() {
-    assertThat(root).isSameAs(root.getRelative(".."));
-    assertThat(root.getRelative("dots")).isSameAs(root.getRelative("broken/../../dots"));
-  }
-
-  @Test
-  public void testStartsWithWorksOnWindows() {
-    assertStartsWithReturnsOnWindows(true, "C:/first/x", "C:/first/x/y");
-    assertStartsWithReturnsOnWindows(true, "c:/first/x", "C:/FIRST/X/Y");
-    assertStartsWithReturnsOnWindows(true, "C:/FIRST/X", "c:/first/x/y");
-    assertStartsWithReturnsOnWindows(false, "C:/", "/");
-    assertStartsWithReturnsOnWindows(false, "C:/", "D:/");
-    assertStartsWithReturnsOnWindows(false, "C:/", "D:/foo");
-  }
-
-  @Test
-  public void testGetRelative() {
-    Path x = filesystem.getPath("C:\\first\\x");
-    Path other = x.getRelative("a\\b\\c");
-    assertThat(other.asFragment().getPathString()).isEqualTo("C:/first/x/a/b/c");
-  }
-
-  private static void assertStartsWithReturnsOnWindows(
-      boolean expected, String ancestor, String descendant) {
-    FileSystem windowsFileSystem = new WindowsFileSystem();
-    Path parent = windowsFileSystem.getPath(ancestor);
-    Path child = windowsFileSystem.getPath(descendant);
-    assertThat(child.startsWith(parent)).isEqualTo(expected);
-  }
-
-  @Test
-  public void testResolvesShortenedPaths() {
-    shortPathResolver.resolutions.put("d:/progra~1", "program files");
-    shortPathResolver.resolutions.put("d:/program files/micros~1", "microsoft something");
-    shortPathResolver.resolutions.put(
-        "d:/program files/microsoft something/foo/~bar~1", "~bar_hello");
-
-    // Assert normal shortpath resolution.
-    Path normal = root.getRelative("d:/progra~1/micros~1/foo/~bar~1/baz");
-    // The path string has an upper-case drive letter because that's how path printing works.
-    assertThat(normal.getPathString())
-        .isEqualTo("D:/program files/microsoft something/foo/~bar_hello/baz");
-    // Assert that we only try to resolve the path segments that look like they may be shortened.
-    assertThat(shortPathResolver.resolutionQueries)
-        .containsExactly(
-            "d:/progra~1",
-            "d:/program files/micros~1",
-            "d:/program files/microsoft something/foo/~bar~1");
-
-    // Assert resolving a path that has a segment which doesn't exist but later will.
-    shortPathResolver.resolutionQueries.clear();
-    Path notYetExistent = root.getRelative("d:/progra~1/micros~1/foo/will~1.exi/bar");
-    // The path string has an upper-case drive letter because that's how path printing works.
-    assertThat(notYetExistent.getPathString())
-        .isEqualTo("D:/program files/microsoft something/foo/will~1.exi/bar");
-    // Assert that we only try to resolve the path segments that look like they may be shortened.
-    assertThat(shortPathResolver.resolutionQueries)
-        .containsExactly(
-            "d:/progra~1",
-            "d:/program files/micros~1",
-            "d:/program files/microsoft something/foo/will~1.exi");
-
-    // Assert that the paths we failed to resolve don't get cached.
-    final List<String> children = new ArrayList<>(2);
-    Predicate<Path> collector =
-        new Predicate<Path>() {
-          @Override
-          public boolean apply(Path child) {
-            children.add(child.getPathString());
-            return true;
-          }
-        };
-
-    WindowsPath msRoot = (WindowsPath) root.getRelative("d:/progra~1/micros~1");
-    assertThat(msRoot.getPathString()).isEqualTo("D:/program files/microsoft something");
-    msRoot.applyToChildren(collector);
-    // The path string has an upper-case drive letter because that's how path printing works.
-    assertThat(children).containsExactly("D:/program files/microsoft something/foo");
-
-    // Assert that the non-resolvable path was not cached.
-    children.clear();
-    WindowsPath foo = (WindowsPath) msRoot.getRelative("foo");
-    foo.applyToChildren(collector);
-    assertThat(children).containsExactly("D:/program files/microsoft something/foo/~bar_hello");
-
-    // Pretend that a path we already failed to resolve once came into existence.
-    shortPathResolver.resolutions.put(
-        "d:/program files/microsoft something/foo/will~1.exi", "will.exist");
-
-    // Assert that this time we can resolve the previously non-existent path.
-    shortPathResolver.resolutionQueries.clear();
-    Path nowExists = root.getRelative("d:/progra~1/micros~1/foo/will~1.exi/bar");
-    // The path string has an upper-case drive letter because that's how path printing works.
-    assertThat(nowExists.getPathString())
-        .isEqualTo("D:/program files/microsoft something/foo/will.exist/bar");
-    // Assert that we only try to resolve the path segments that look like they may be shortened.
-    assertThat(shortPathResolver.resolutionQueries)
-        .containsExactly(
-            "d:/progra~1",
-            "d:/program files/micros~1",
-            "d:/program files/microsoft something/foo/will~1.exi");
-
-    // Assert that this time we cached the previously non-existent path.
-    children.clear();
-    foo.applyToChildren(collector);
-    // The path strings have upper-case drive letters because that's how path printing works.
-    children.clear();
-    foo.applyToChildren(collector);
-    assertThat(children)
-        .containsExactly(
-            "D:/program files/microsoft something/foo/~bar_hello",
-            "D:/program files/microsoft something/foo/will.exist");
-  }
-
-  @Test
-  public void testCaseInsensitivePathFragment() {
-    // equals
-    assertThat(PathFragment.create("c:/FOO/BAR")).isEqualTo(PathFragment.create("c:\\foo\\bar"));
-    assertThat(PathFragment.create("c:/FOO/BAR")).isNotEqualTo(PathFragment.create("d:\\foo\\bar"));
-    assertThat(PathFragment.create("c:/FOO/BAR")).isNotEqualTo(PathFragment.create("/foo/bar"));
-    // equals for the string representation
-    assertThat(PathFragment.create("c:/FOO/BAR").toString())
-        .isNotEqualTo(PathFragment.create("c:/foo/bar").toString());
-    // hashCode
-    assertThat(PathFragment.create("c:/FOO/BAR").hashCode())
-        .isEqualTo(PathFragment.create("c:\\foo\\bar").hashCode());
-    assertThat(PathFragment.create("c:/FOO/BAR").hashCode())
-        .isNotEqualTo(PathFragment.create("d:\\foo\\bar").hashCode());
-    assertThat(PathFragment.create("c:/FOO/BAR").hashCode())
-        .isNotEqualTo(PathFragment.create("/foo/bar").hashCode());
-    // compareTo
-    assertThat(PathFragment.create("c:/FOO/BAR").compareTo(PathFragment.create("c:\\foo\\bar")))
-        .isEqualTo(0);
-    assertThat(PathFragment.create("c:/FOO/BAR").compareTo(PathFragment.create("d:\\foo\\bar")))
-        .isLessThan(0);
-    assertThat(PathFragment.create("c:/FOO/BAR").compareTo(PathFragment.create("/foo/bar")))
-        .isGreaterThan(0);
-    // startsWith
-    assertThat(PathFragment.create("c:/FOO/BAR").startsWith(PathFragment.create("c:\\foo")))
-        .isTrue();
-    assertThat(PathFragment.create("c:/FOO/BAR").startsWith(PathFragment.create("d:\\foo")))
-        .isFalse();
-    // endsWith
-    assertThat(PathFragment.create("c:/FOO/BAR/BAZ").endsWith(PathFragment.create("bar\\baz")))
-        .isTrue();
-    assertThat(PathFragment.create("c:/FOO/BAR/BAZ").endsWith(PathFragment.create("/bar/baz")))
-        .isFalse();
-    assertThat(PathFragment.create("c:/FOO/BAR/BAZ").endsWith(PathFragment.create("d:\\bar\\baz")))
-        .isFalse();
-    // relativeTo
-    assertThat(
-            PathFragment.create("c:/FOO/BAR/BAZ/QUX")
-                .relativeTo(PathFragment.create("c:\\foo\\bar")))
-        .isEqualTo(PathFragment.create("Baz/Qux"));
-  }
-
-  @Test
-  public void testCaseInsensitiveRootedPath() {
-    Path ancestor = filesystem.getPath("C:\\foo\\bar");
-    assertThat(ancestor).isInstanceOf(WindowsPath.class);
-    Path child = filesystem.getPath("C:\\FOO\\Bar\\baz");
-    assertThat(child).isInstanceOf(WindowsPath.class);
-    assertThat(child.startsWith(ancestor)).isTrue();
-    assertThat(child.relativeTo(ancestor)).isEqualTo(PathFragment.create("baz"));
-    RootedPath actual = RootedPath.toRootedPath(Root.fromPath(ancestor), child);
-    assertThat(actual.getRoot()).isEqualTo(Root.fromPath(ancestor));
-    assertThat(actual.getRootRelativePath()).isEqualTo(PathFragment.create("baz"));
-  }
-
-  @Test
-  public void testToURI() {
-    // See https://blogs.msdn.microsoft.com/ie/2006/12/06/file-uris-in-windows/
-    Path p = root.getRelative("Temp\\Foo Bar.txt");
-    URI uri = p.toURI();
-    assertThat(uri.toString()).isEqualTo("file:///C:/Temp/Foo%20Bar.txt");
-  }
-}
diff --git a/src/test/java/com/google/devtools/build/lib/windows/WindowsFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/windows/WindowsFileSystemTest.java
index 8937c45..3e9cd27 100644
--- a/src/test/java/com/google/devtools/build/lib/windows/WindowsFileSystemTest.java
+++ b/src/test/java/com/google/devtools/build/lib/windows/WindowsFileSystemTest.java
@@ -18,7 +18,6 @@
 import static org.junit.Assert.fail;
 
 import com.google.common.base.Function;
-import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
@@ -27,16 +26,13 @@
 import com.google.devtools.build.lib.vfs.Path;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import com.google.devtools.build.lib.vfs.Symlinks;
-import com.google.devtools.build.lib.windows.WindowsFileSystem.WindowsPath;
 import com.google.devtools.build.lib.windows.jni.WindowsFileOperations;
 import com.google.devtools.build.lib.windows.util.WindowsTestUtil;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import org.junit.After;
 import org.junit.Before;
@@ -246,42 +242,22 @@
     assertThat(p.getPathString()).endsWith(longPath);
     assertThat(p).isEqualTo(fs.getPath(scratchRoot).getRelative(shortPath));
     assertThat(p).isEqualTo(fs.getPath(scratchRoot).getRelative(longPath));
-    assertThat(fs.getPath(scratchRoot).getRelative(shortPath)).isSameAs(p);
-    assertThat(fs.getPath(scratchRoot).getRelative(longPath)).isSameAs(p);
+    assertThat(fs.getPath(scratchRoot).getRelative(shortPath)).isEqualTo(p);
+    assertThat(fs.getPath(scratchRoot).getRelative(longPath)).isEqualTo(p);
   }
 
   @Test
   public void testUnresolvableShortPathWhichIsThenCreated() throws Exception {
     String shortPath = "unreso~1.sho/foo/will~1.exi/bar/hello.txt";
-    String longPrefix = "unresolvable.shortpath/foo/";
-    String longPath = longPrefix + "will.exist/bar/hello.txt";
-    testUtil.scratchDir(longPrefix);
-    final WindowsPath foo = (WindowsPath) fs.getPath(scratchRoot).getRelative(longPrefix);
-
+    String longPath = "unresolvable.shortpath/foo/will.exist/bar/hello.txt";
     // Assert that we can create an unresolvable path.
     Path p = fs.getPath(scratchRoot).getRelative(shortPath);
-    assertThat(p.getPathString()).endsWith(longPrefix + "will~1.exi/bar/hello.txt");
-    // Assert that said path is not cached in its parent's `children` cache.
-    final List<String> children = new ArrayList<>();
-    Predicate<Path> collector =
-        new Predicate<Path>() {
-          @Override
-          public boolean apply(Path child) {
-            children.add(child.relativeTo(foo).getPathString());
-            return true;
-          }
-        };
-    foo.applyToChildren(collector);
-    assertThat(children).isEmpty();
+    assertThat(p.getPathString()).endsWith(shortPath);
     // Assert that we can then create the whole path, and can now resolve the short form.
     testUtil.scratchFile(longPath, "hello");
     Path q = fs.getPath(scratchRoot).getRelative(shortPath);
     assertThat(q.getPathString()).endsWith(longPath);
-    // Assert however that the unresolved and resolved Path objects are different, and only the
-    // resolved one is cached.
     assertThat(p).isNotEqualTo(q);
-    foo.applyToChildren(collector);
-    assertThat(children).containsExactly("will.exist");
   }
 
   /**
@@ -297,18 +273,11 @@
     Path p2 = fs.getPath(scratchRoot).getRelative("longpa~1");
     assertThat(p1.exists()).isFalse();
     assertThat(p1).isEqualTo(p2);
-    assertThat(p1).isNotSameAs(p2);
 
     testUtil.scratchDir("longpathnow");
     Path q1 = fs.getPath(scratchRoot).getRelative("longpa~1");
-    Path q2 = fs.getPath(scratchRoot).getRelative("longpa~1");
     assertThat(q1.exists()).isTrue();
-    assertThat(q1).isEqualTo(q2);
-    // Assert q1 == q2, because we could successfully resolve the short path to a long name and we
-    // cache them by the long name, so it's irrelevant they were created from a 8dot3 name, or what
-    // that name resolves to later in time.
-    assertThat(q1).isSameAs(q2);
-    assertThat(q1).isSameAs(fs.getPath(scratchRoot).getRelative("longpathnow"));
+    assertThat(q1).isEqualTo(fs.getPath(scratchRoot).getRelative("longpathnow"));
 
     // Delete the original resolution of "longpa~1" ("longpathnow").
     assertThat(q1.delete()).isTrue();
@@ -317,14 +286,8 @@
     // Create a directory whose 8dot3 name is also "longpa~1" but its long name is different.
     testUtil.scratchDir("longpaththen");
     Path r1 = fs.getPath(scratchRoot).getRelative("longpa~1");
-    Path r2 = fs.getPath(scratchRoot).getRelative("longpa~1");
     assertThat(r1.exists()).isTrue();
-    assertThat(r1).isEqualTo(r2);
-    assertThat(r1).isSameAs(r2);
-    assertThat(r1).isSameAs(fs.getPath(scratchRoot).getRelative("longpaththen"));
-    // r1 == r2 and q1 == q2, but r1 != q1, because the resolution of "longpa~1" changed over time.
-    assertThat(r1).isNotEqualTo(q1);
-    assertThat(r1).isNotSameAs(q1);
+    assertThat(r1).isEqualTo(fs.getPath(scratchRoot).getRelative("longpaththen"));
   }
 
   @Test