Refactor all ctor callsites of PathFragment to instead call a static 'create' method.

This paves the way for changing PathFragment to e.g. an abstract class with multiple subclasses. This way we can split out the windows-specific stuff into one of these concrete classes, making the code more readable and also saving memory (since the shallow heap size of the NonWindowsPathFragment subclass will hopefully be smaller than that of the current PathFragment).

This also lets us pursue gc churn optimizations. We can now do interning in PathFragment#create and can also get rid of unnecessary intermediate PathFragment allocations.

RELNOTES: None

PiperOrigin-RevId: 152145768

12 files changed, 356 insertions, 342 deletions

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 8b4255b510..0a1d052002 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
@@ -306,7 +306,7 @@ public abstract class FileSystemTest {
   @Test
   public void testCreatePathRelativeToWorkingDirectory() {
     Path relativeCreatedPath = absolutize("some-file");
-    Path expectedResult = workingDir.getRelative(new PathFragment("some-file"));
+    Path expectedResult = workingDir.getRelative(PathFragment.create("some-file"));
 
     assertEquals(expectedResult, relativeCreatedPath);
   }
@@ -1091,7 +1091,7 @@ public abstract class FileSystemTest {
   @Test
   public void testGetPathOnlyAcceptsAbsolutePathFragment() {
     try {
-      testFS.getPath(new PathFragment("not-absolute"));
+      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)");
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 f9f4850320..421b9fbd59 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
@@ -227,69 +227,70 @@ public class FileSystemUtilsTest {
   @Test
   public void testReplaceExtension_PathFragment() throws Exception {
     assertPath("foo/bar.baz",
-               FileSystemUtils.replaceExtension(new PathFragment("foo/bar"), ".baz"));
+               FileSystemUtils.replaceExtension(PathFragment.create("foo/bar"), ".baz"));
     assertPath("foo/bar.baz",
-               FileSystemUtils.replaceExtension(new PathFragment("foo/bar.cc"), ".baz"));
+               FileSystemUtils.replaceExtension(PathFragment.create("foo/bar.cc"), ".baz"));
     assertPath("/foo/bar.baz",
-               FileSystemUtils.replaceExtension(new PathFragment("/foo/bar"), ".baz"));
+               FileSystemUtils.replaceExtension(PathFragment.create("/foo/bar"), ".baz"));
     assertPath("/foo/bar.baz",
-               FileSystemUtils.replaceExtension(new PathFragment("/foo/bar.cc"), ".baz"));
-    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo/"), ".baz"));
-    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo.cc/"), ".baz"));
-    assertPath("/foo.baz", FileSystemUtils.replaceExtension(new PathFragment("/foo/"), ".baz"));
+               FileSystemUtils.replaceExtension(PathFragment.create("/foo/bar.cc"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo/"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo.cc/"), ".baz"));
+    assertPath("/foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("/foo/"), ".baz"));
     assertPath("/foo.baz",
-               FileSystemUtils.replaceExtension(new PathFragment("/foo.cc/"), ".baz"));
-    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo"), ".baz"));
-    assertPath("foo.baz", FileSystemUtils.replaceExtension(new PathFragment("foo.cc"), ".baz"));
-    assertPath("/foo.baz", FileSystemUtils.replaceExtension(new PathFragment("/foo"), ".baz"));
+               FileSystemUtils.replaceExtension(PathFragment.create("/foo.cc/"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo"), ".baz"));
+    assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo.cc"), ".baz"));
+    assertPath("/foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("/foo"), ".baz"));
     assertPath("/foo.baz",
-               FileSystemUtils.replaceExtension(new PathFragment("/foo.cc"), ".baz"));
-    assertPath(".baz", FileSystemUtils.replaceExtension(new PathFragment(".cc"), ".baz"));
-    assertNull(FileSystemUtils.replaceExtension(new PathFragment("/"), ".baz"));
-    assertNull(FileSystemUtils.replaceExtension(new PathFragment(""), ".baz"));
+               FileSystemUtils.replaceExtension(PathFragment.create("/foo.cc"), ".baz"));
+    assertPath(".baz", FileSystemUtils.replaceExtension(PathFragment.create(".cc"), ".baz"));
+    assertNull(FileSystemUtils.replaceExtension(PathFragment.create("/"), ".baz"));
+    assertNull(FileSystemUtils.replaceExtension(PathFragment.create(""), ".baz"));
     assertPath("foo/bar.baz",
-        FileSystemUtils.replaceExtension(new PathFragment("foo/bar.pony"), ".baz", ".pony"));
+        FileSystemUtils.replaceExtension(PathFragment.create("foo/bar.pony"), ".baz", ".pony"));
     assertPath("foo/bar.baz",
-        FileSystemUtils.replaceExtension(new PathFragment("foo/bar"), ".baz", ""));
-    assertNull(FileSystemUtils.replaceExtension(new PathFragment(""), ".baz", ".pony"));
+        FileSystemUtils.replaceExtension(PathFragment.create("foo/bar"), ".baz", ""));
+    assertNull(FileSystemUtils.replaceExtension(PathFragment.create(""), ".baz", ".pony"));
     assertNull(
-        FileSystemUtils.replaceExtension(new PathFragment("foo/bar.pony"), ".baz", ".unicorn"));
+        FileSystemUtils.replaceExtension(PathFragment.create("foo/bar.pony"), ".baz", ".unicorn"));
   }
 
   @Test
   public void testAppendWithoutExtension() throws Exception {
     assertPath("libfoo-src.jar",
-        appendWithoutExtension(new PathFragment("libfoo.jar"), "-src"));
+        appendWithoutExtension(PathFragment.create("libfoo.jar"), "-src"));
     assertPath("foo/libfoo-src.jar",
-        appendWithoutExtension(new PathFragment("foo/libfoo.jar"), "-src"));
+        appendWithoutExtension(PathFragment.create("foo/libfoo.jar"), "-src"));
     assertPath("java/com/google/foo/libfoo-src.jar",
-        appendWithoutExtension(new PathFragment("java/com/google/foo/libfoo.jar"), "-src"));
+        appendWithoutExtension(PathFragment.create("java/com/google/foo/libfoo.jar"), "-src"));
     assertPath("libfoo.bar-src.jar",
-        appendWithoutExtension(new PathFragment("libfoo.bar.jar"), "-src"));
+        appendWithoutExtension(PathFragment.create("libfoo.bar.jar"), "-src"));
     assertPath("libfoo-src",
-        appendWithoutExtension(new PathFragment("libfoo"), "-src"));
+        appendWithoutExtension(PathFragment.create("libfoo"), "-src"));
     assertPath("libfoo-src.jar",
-        appendWithoutExtension(new PathFragment("libfoo.jar/"), "-src"));
+        appendWithoutExtension(PathFragment.create("libfoo.jar/"), "-src"));
     assertPath("libfoo.src.jar",
-        appendWithoutExtension(new PathFragment("libfoo.jar"), ".src"));
-    assertNull(appendWithoutExtension(new PathFragment("/"), "-src"));
-    assertNull(appendWithoutExtension(new PathFragment(""), "-src"));
+        appendWithoutExtension(PathFragment.create("libfoo.jar"), ".src"));
+    assertNull(appendWithoutExtension(PathFragment.create("/"), "-src"));
+    assertNull(appendWithoutExtension(PathFragment.create(""), "-src"));
   }
 
   @Test
   public void testReplaceSegments() {
     assertPath(
         "poo/bar/baz.cc",
-        FileSystemUtils.replaceSegments(new PathFragment("foo/bar/baz.cc"), "foo", "poo", true));
+        FileSystemUtils.replaceSegments(PathFragment.create("foo/bar/baz.cc"), "foo", "poo", true));
     assertPath(
         "poo/poo/baz.cc",
-        FileSystemUtils.replaceSegments(new PathFragment("foo/foo/baz.cc"), "foo", "poo", true));
+        FileSystemUtils.replaceSegments(PathFragment.create("foo/foo/baz.cc"), "foo", "poo", true));
     assertPath(
         "poo/foo/baz.cc",
-        FileSystemUtils.replaceSegments(new PathFragment("foo/foo/baz.cc"), "foo", "poo", false));
+        FileSystemUtils.replaceSegments(
+            PathFragment.create("foo/foo/baz.cc"), "foo", "poo", false));
     assertPath(
         "foo/bar/baz.cc",
-        FileSystemUtils.replaceSegments(new PathFragment("foo/bar/baz.cc"), "boo", "poo", true));
+        FileSystemUtils.replaceSegments(PathFragment.create("foo/bar/baz.cc"), "boo", "poo", true));
   }
 
   @Test
@@ -308,11 +309,11 @@ public class FileSystemUtilsTest {
 
   @Test
   public void testResolveRelativeToFilesystemWorkingDir() {
-    PathFragment relativePath = new PathFragment("relative/path");
+    PathFragment relativePath = PathFragment.create("relative/path");
     assertEquals(workingDir.getRelative(relativePath),
                  workingDir.getRelative(relativePath));
 
-    PathFragment absolutePath = new PathFragment("/absolute/path");
+    PathFragment absolutePath = PathFragment.create("/absolute/path");
     assertEquals(fileSystem.getPath(absolutePath),
                  workingDir.getRelative(absolutePath));
   }
@@ -781,16 +782,16 @@ public class FileSystemUtilsTest {
 
   @Test
   public void testStartsWithAnySuccess() throws Exception {
-    PathFragment a = new PathFragment("a");
+    PathFragment a = PathFragment.create("a");
     assertTrue(FileSystemUtils.startsWithAny(a,
-        Arrays.asList(new PathFragment("b"), new PathFragment("a"))));
+        Arrays.asList(PathFragment.create("b"), PathFragment.create("a"))));
   }
 
   @Test
   public void testStartsWithAnyNotFound() throws Exception {
-    PathFragment a = new PathFragment("a");
+    PathFragment a = PathFragment.create("a");
     assertFalse(FileSystemUtils.startsWithAny(a,
-        Arrays.asList(new PathFragment("b"), new PathFragment("c"))));
+        Arrays.asList(PathFragment.create("b"), PathFragment.create("c"))));
   }
 
   @Test
@@ -811,7 +812,7 @@ public class FileSystemUtilsTest {
 
   @Test
   public void testEnsureSymbolicLinkDoesNotMakeUnnecessaryChanges() throws Exception {
-    PathFragment target = new PathFragment("/b");
+    PathFragment target = PathFragment.create("/b");
     Path file = fileSystem.getPath("/a");
     file.createSymbolicLink(target);
     long prevTimeMillis = clock.currentTimeMillis();
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/ModifiedFileSetTest.java b/src/test/java/com/google/devtools/build/lib/vfs/ModifiedFileSetTest.java
index 07eedbeded..f3c5eb63e7 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/ModifiedFileSetTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/ModifiedFileSetTest.java
@@ -28,8 +28,8 @@ public class ModifiedFileSetTest {
 
   @Test
   public void testHashCodeAndEqualsContract() throws Exception {
-    PathFragment fragA = new PathFragment("a");
-    PathFragment fragB = new PathFragment("b");
+    PathFragment fragA = PathFragment.create("a");
+    PathFragment fragB = PathFragment.create("b");
 
     ModifiedFileSet empty1 = ModifiedFileSet.NOTHING_MODIFIED;
     ModifiedFileSet empty2 = ModifiedFileSet.builder().build();
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 c4ac7c1b32..2e455ccae8 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
@@ -40,10 +40,13 @@ import org.junit.runners.JUnit4;
 public class PathFragmentTest {
   @Test
   public void testMergeFourPathsWithAbsolute() {
-    assertEquals(new PathFragment("x/y/z/a/b/c/d/e"),
-        new PathFragment(new PathFragment("x/y"), new PathFragment("z/a"),
-            new PathFragment("/b/c"), // absolute!
-            new PathFragment("d/e")));
+    assertEquals(
+        PathFragment.create("x/y/z/a/b/c/d/e"),
+        PathFragment.create(
+            PathFragment.create("x/y"),
+            PathFragment.create("z/a"),
+            PathFragment.create("/b/c"),
+            PathFragment.create("d/e")));
   }
 
   @Test
@@ -68,22 +71,22 @@ public class PathFragmentTest {
 
     new EqualsTester()
         .addEqualityGroup(
-            new PathFragment("../relative/path"),
-            new PathFragment("..").getRelative("relative").getRelative("path"),
-            new PathFragment('\0', false, new String[] {"..", "relative", "path"}),
-            new PathFragment(new File("../relative/path")))
-        .addEqualityGroup(new PathFragment("something/else"))
-        .addEqualityGroup(new PathFragment("/something/else"))
-        .addEqualityGroup(new PathFragment("/"), new PathFragment("//////"))
-        .addEqualityGroup(new PathFragment(""), PathFragment.EMPTY_FRAGMENT)
+            PathFragment.create("../relative/path"),
+            PathFragment.create("..").getRelative("relative").getRelative("path"),
+            PathFragment.createNoClone('\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)
         .addEqualityGroup(filesystem.getRootDirectory()) // A Path object.
         .testEquals();
   }
 
   @Test
   public void testHashCodeCache() {
-    PathFragment relativePath = new PathFragment("../relative/path");
-    PathFragment rootPath = new PathFragment("/");
+    PathFragment relativePath = PathFragment.create("../relative/path");
+    PathFragment rootPath = PathFragment.create("/");
 
     int oldResult = relativePath.hashCode();
     int rootResult = rootPath.hashCode();
@@ -92,19 +95,21 @@ public class PathFragmentTest {
   }
 
   private void checkRelativeTo(String path, String base) {
-    PathFragment relative = new PathFragment(path).relativeTo(base);
-    assertEquals(new PathFragment(path), new PathFragment(base).getRelative(relative).normalize());
+    PathFragment relative = PathFragment.create(path).relativeTo(base);
+    assertEquals(
+        PathFragment.create(path),
+        PathFragment.create(base).getRelative(relative).normalize());
   }
 
   @Test
   public void testRelativeTo() {
-    assertPath("bar/baz", new PathFragment("foo/bar/baz").relativeTo("foo"));
-    assertPath("bar/baz", new PathFragment("/foo/bar/baz").relativeTo("/foo"));
-    assertPath("baz", new PathFragment("foo/bar/baz").relativeTo("foo/bar"));
-    assertPath("baz", new PathFragment("/foo/bar/baz").relativeTo("/foo/bar"));
-    assertPath("foo", new PathFragment("/foo").relativeTo("/"));
-    assertPath("foo", new PathFragment("foo").relativeTo(""));
-    assertPath("foo/bar", new PathFragment("foo/bar").relativeTo(""));
+    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");
@@ -117,26 +122,26 @@ public class PathFragmentTest {
 
   @Test
   public void testIsAbsolute() {
-    assertTrue(new PathFragment("/absolute/test").isAbsolute());
-    assertFalse(new PathFragment("relative/test").isAbsolute());
-    assertTrue(new PathFragment(new File("/absolute/test")).isAbsolute());
-    assertFalse(new PathFragment(new File("relative/test")).isAbsolute());
+    assertTrue(PathFragment.create("/absolute/test").isAbsolute());
+    assertFalse(PathFragment.create("relative/test").isAbsolute());
+    assertTrue(PathFragment.create(new File("/absolute/test")).isAbsolute());
+    assertFalse(PathFragment.create(new File("relative/test")).isAbsolute());
   }
 
   @Test
   public void testIsNormalized() {
-    assertTrue(new PathFragment("/absolute/path").isNormalized());
-    assertTrue(new PathFragment("some//path").isNormalized());
-    assertFalse(new PathFragment("some/./path").isNormalized());
-    assertFalse(new PathFragment("../some/path").isNormalized());
-    assertFalse(new PathFragment("some/other/../path").isNormalized());
-    assertTrue(new PathFragment("some/other//tricky..path..").isNormalized());
-    assertTrue(new PathFragment("/some/other//tricky..path..").isNormalized());
+    assertTrue(PathFragment.create("/absolute/path").isNormalized());
+    assertTrue(PathFragment.create("some//path").isNormalized());
+    assertFalse(PathFragment.create("some/./path").isNormalized());
+    assertFalse(PathFragment.create("../some/path").isNormalized());
+    assertFalse(PathFragment.create("some/other/../path").isNormalized());
+    assertTrue(PathFragment.create("some/other//tricky..path..").isNormalized());
+    assertTrue(PathFragment.create("/some/other//tricky..path..").isNormalized());
   }
 
   @Test
   public void testRootNodeReturnsRootString() {
-    PathFragment rootFragment = new PathFragment("/");
+    PathFragment rootFragment = PathFragment.create("/");
     assertEquals("/", rootFragment.getPathString());
   }
 
@@ -144,27 +149,27 @@ public class PathFragmentTest {
   public void testGetPathFragmentDoesNotNormalize() {
     String nonCanonicalPath = "/a/weird/noncanonical/../path/.";
     assertEquals(nonCanonicalPath,
-        new PathFragment(nonCanonicalPath).getPathString());
+        PathFragment.create(nonCanonicalPath).getPathString());
   }
 
   @Test
   public void testGetRelative() {
-    assertEquals("a/b", new PathFragment("a").getRelative("b").getPathString());
-    assertEquals("a/b/c/d", new PathFragment("a/b").getRelative("c/d").getPathString());
-    assertEquals("/a/b", new PathFragment("c/d").getRelative("/a/b").getPathString());
-    assertEquals("a", new PathFragment("a").getRelative("").getPathString());
-    assertEquals("/", new PathFragment("/").getRelative("").getPathString());
+    assertEquals("a/b", PathFragment.create("a").getRelative("b").getPathString());
+    assertEquals("a/b/c/d", PathFragment.create("a/b").getRelative("c/d").getPathString());
+    assertEquals("/a/b", PathFragment.create("c/d").getRelative("/a/b").getPathString());
+    assertEquals("a", PathFragment.create("a").getRelative("").getPathString());
+    assertEquals("/", PathFragment.create("/").getRelative("").getPathString());
   }
 
   @Test
   public void testGetChildWorks() {
-    PathFragment pf = new PathFragment("../some/path");
-    assertEquals(new PathFragment("../some/path/hi"), pf.getChild("hi"));
+    PathFragment pf = PathFragment.create("../some/path");
+    assertEquals(PathFragment.create("../some/path/hi"), pf.getChild("hi"));
   }
 
   @Test
   public void testGetChildRejectsInvalidBaseNames() {
-    PathFragment pf = new PathFragment("../some/path");
+    PathFragment pf = PathFragment.create("../some/path");
     assertGetChildFails(pf, ".");
     assertGetChildFails(pf, "..");
     assertGetChildFails(pf, "x/y");
@@ -182,8 +187,14 @@ public class PathFragmentTest {
 
   // Tests after here test the canonicalization
   private void assertRegular(String expected, String actual) {
-    assertEquals(expected, new PathFragment(actual).getPathString()); // compare string forms
-    assertEquals(new PathFragment(expected), new PathFragment(actual)); // compare fragment forms
+    // compare string forms
+    assertEquals(
+        expected,
+        PathFragment.create(actual).getPathString());
+    // compare fragment forms
+    assertEquals(
+        PathFragment.create(expected),
+        PathFragment.create(actual));
   }
 
   @Test
@@ -218,19 +229,19 @@ public class PathFragmentTest {
 
   @Test
   public void testGetParentDirectory() {
-    PathFragment fooBarWiz = new PathFragment("foo/bar/wiz");
-    PathFragment fooBar = new PathFragment("foo/bar");
-    PathFragment foo = new PathFragment("foo");
-    PathFragment empty = new PathFragment("");
+    PathFragment fooBarWiz = PathFragment.create("foo/bar/wiz");
+    PathFragment fooBar = PathFragment.create("foo/bar");
+    PathFragment foo = PathFragment.create("foo");
+    PathFragment empty = PathFragment.create("");
     assertEquals(fooBar, fooBarWiz.getParentDirectory());
     assertEquals(foo, fooBar.getParentDirectory());
     assertEquals(empty, foo.getParentDirectory());
     assertNull(empty.getParentDirectory());
 
-    PathFragment fooBarWizAbs = new PathFragment("/foo/bar/wiz");
-    PathFragment fooBarAbs = new PathFragment("/foo/bar");
-    PathFragment fooAbs = new PathFragment("/foo");
-    PathFragment rootAbs = new PathFragment("/");
+    PathFragment fooBarWizAbs = PathFragment.create("/foo/bar/wiz");
+    PathFragment fooBarAbs = PathFragment.create("/foo/bar");
+    PathFragment fooAbs = PathFragment.create("/foo");
+    PathFragment rootAbs = PathFragment.create("/");
     assertEquals(fooBarAbs, fooBarWizAbs.getParentDirectory());
     assertEquals(fooAbs, fooBarAbs.getParentDirectory());
     assertEquals(rootAbs, fooAbs.getParentDirectory());
@@ -238,60 +249,60 @@ public class PathFragmentTest {
 
     // Note, this is surprising but correct behavior:
     assertEquals(fooBarAbs,
-                 new PathFragment("/foo/bar/..").getParentDirectory());
+                 PathFragment.create("/foo/bar/..").getParentDirectory());
   }
 
   @Test
   public void testSegmentsCount() {
-    assertEquals(2, new PathFragment("foo/bar").segmentCount());
-    assertEquals(2, new PathFragment("/foo/bar").segmentCount());
-    assertEquals(2, new PathFragment("foo//bar").segmentCount());
-    assertEquals(2, new PathFragment("/foo//bar").segmentCount());
-    assertEquals(1, new PathFragment("foo/").segmentCount());
-    assertEquals(1, new PathFragment("/foo/").segmentCount());
-    assertEquals(1, new PathFragment("foo").segmentCount());
-    assertEquals(1, new PathFragment("/foo").segmentCount());
-    assertEquals(0, new PathFragment("/").segmentCount());
-    assertEquals(0, new PathFragment("").segmentCount());
+    assertEquals(2, PathFragment.create("foo/bar").segmentCount());
+    assertEquals(2, PathFragment.create("/foo/bar").segmentCount());
+    assertEquals(2, PathFragment.create("foo//bar").segmentCount());
+    assertEquals(2, PathFragment.create("/foo//bar").segmentCount());
+    assertEquals(1, PathFragment.create("foo/").segmentCount());
+    assertEquals(1, PathFragment.create("/foo/").segmentCount());
+    assertEquals(1, PathFragment.create("foo").segmentCount());
+    assertEquals(1, PathFragment.create("/foo").segmentCount());
+    assertEquals(0, PathFragment.create("/").segmentCount());
+    assertEquals(0, PathFragment.create("").segmentCount());
   }
 
 
   @Test
   public void testGetSegment() {
-    assertEquals("foo", new PathFragment("foo/bar").getSegment(0));
-    assertEquals("bar", new PathFragment("foo/bar").getSegment(1));
-    assertEquals("foo", new PathFragment("/foo/bar").getSegment(0));
-    assertEquals("bar", new PathFragment("/foo/bar").getSegment(1));
-    assertEquals("foo", new PathFragment("foo/").getSegment(0));
-    assertEquals("foo", new PathFragment("/foo/").getSegment(0));
-    assertEquals("foo", new PathFragment("foo").getSegment(0));
-    assertEquals("foo", new PathFragment("/foo").getSegment(0));
+    assertEquals("foo", PathFragment.create("foo/bar").getSegment(0));
+    assertEquals("bar", PathFragment.create("foo/bar").getSegment(1));
+    assertEquals("foo", PathFragment.create("/foo/bar").getSegment(0));
+    assertEquals("bar", PathFragment.create("/foo/bar").getSegment(1));
+    assertEquals("foo", PathFragment.create("foo/").getSegment(0));
+    assertEquals("foo", PathFragment.create("/foo/").getSegment(0));
+    assertEquals("foo", PathFragment.create("foo").getSegment(0));
+    assertEquals("foo", PathFragment.create("/foo").getSegment(0));
   }
 
   @Test
   public void testBasename() throws Exception {
-    assertEquals("bar", new PathFragment("foo/bar").getBaseName());
-    assertEquals("bar", new PathFragment("/foo/bar").getBaseName());
-    assertEquals("foo", new PathFragment("foo/").getBaseName());
-    assertEquals("foo", new PathFragment("/foo/").getBaseName());
-    assertEquals("foo", new PathFragment("foo").getBaseName());
-    assertEquals("foo", new PathFragment("/foo").getBaseName());
-    assertThat(new PathFragment("/").getBaseName()).isEmpty();
-    assertThat(new PathFragment("").getBaseName()).isEmpty();
+    assertEquals("bar", PathFragment.create("foo/bar").getBaseName());
+    assertEquals("bar", PathFragment.create("/foo/bar").getBaseName());
+    assertEquals("foo", PathFragment.create("foo/").getBaseName());
+    assertEquals("foo", PathFragment.create("/foo/").getBaseName());
+    assertEquals("foo", PathFragment.create("foo").getBaseName());
+    assertEquals("foo", PathFragment.create("/foo").getBaseName());
+    assertThat(PathFragment.create("/").getBaseName()).isEmpty();
+    assertThat(PathFragment.create("").getBaseName()).isEmpty();
   }
 
   @Test
   public void testFileExtension() throws Exception {
-    assertThat(new PathFragment("foo.bar").getFileExtension()).isEqualTo("bar");
-    assertThat(new PathFragment("foo.barr").getFileExtension()).isEqualTo("barr");
-    assertThat(new PathFragment("foo.b").getFileExtension()).isEqualTo("b");
-    assertThat(new PathFragment("foo.").getFileExtension()).isEmpty();
-    assertThat(new PathFragment("foo").getFileExtension()).isEmpty();
-    assertThat(new PathFragment(".").getFileExtension()).isEmpty();
-    assertThat(new PathFragment("").getFileExtension()).isEmpty();
-    assertThat(new PathFragment("foo/bar.baz").getFileExtension()).isEqualTo("baz");
-    assertThat(new PathFragment("foo.bar.baz").getFileExtension()).isEqualTo("baz");
-    assertThat(new PathFragment("foo.bar/baz").getFileExtension()).isEmpty();
+    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) {
@@ -300,66 +311,66 @@ public class PathFragmentTest {
 
   @Test
   public void testReplaceName() throws Exception {
-    assertPath("foo/baz", new PathFragment("foo/bar").replaceName("baz"));
-    assertPath("/foo/baz", new PathFragment("/foo/bar").replaceName("baz"));
-    assertPath("foo", new PathFragment("foo/bar").replaceName(""));
-    assertPath("baz", new PathFragment("foo/").replaceName("baz"));
-    assertPath("/baz", new PathFragment("/foo/").replaceName("baz"));
-    assertPath("baz", new PathFragment("foo").replaceName("baz"));
-    assertPath("/baz", new PathFragment("/foo").replaceName("baz"));
-    assertNull(new PathFragment("/").replaceName("baz"));
-    assertNull(new PathFragment("/").replaceName(""));
-    assertNull(new PathFragment("").replaceName("baz"));
-    assertNull(new PathFragment("").replaceName(""));
-
-    assertPath("foo/bar/baz", new PathFragment("foo/bar").replaceName("bar/baz"));
-    assertPath("foo/bar/baz", new PathFragment("foo/bar").replaceName("bar/baz/"));
+    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"));
+    assertNull(PathFragment.create("/").replaceName("baz"));
+    assertNull(PathFragment.create("/").replaceName(""));
+    assertNull(PathFragment.create("").replaceName("baz"));
+    assertNull(PathFragment.create("").replaceName(""));
+
+    assertPath("foo/bar/baz", PathFragment.create("foo/bar").replaceName("bar/baz"));
+    assertPath("foo/bar/baz", PathFragment.create("foo/bar").replaceName("bar/baz/"));
 
     // Absolute path arguments will clobber the original path.
-    assertPath("/absolute", new PathFragment("foo/bar").replaceName("/absolute"));
-    assertPath("/", new PathFragment("foo/bar").replaceName("/"));
+    assertPath("/absolute", PathFragment.create("foo/bar").replaceName("/absolute"));
+    assertPath("/", PathFragment.create("foo/bar").replaceName("/"));
   }
   @Test
   public void testSubFragment() throws Exception {
     assertPath("/foo/bar/baz",
-        new PathFragment("/foo/bar/baz").subFragment(0, 3));
+        PathFragment.create("/foo/bar/baz").subFragment(0, 3));
     assertPath("foo/bar/baz",
-        new PathFragment("foo/bar/baz").subFragment(0, 3));
+        PathFragment.create("foo/bar/baz").subFragment(0, 3));
     assertPath("/foo/bar",
-               new PathFragment("/foo/bar/baz").subFragment(0, 2));
+               PathFragment.create("/foo/bar/baz").subFragment(0, 2));
     assertPath("bar/baz",
-               new PathFragment("/foo/bar/baz").subFragment(1, 3));
+               PathFragment.create("/foo/bar/baz").subFragment(1, 3));
     assertPath("/foo",
-               new PathFragment("/foo/bar/baz").subFragment(0, 1));
+               PathFragment.create("/foo/bar/baz").subFragment(0, 1));
     assertPath("bar",
-               new PathFragment("/foo/bar/baz").subFragment(1, 2));
-    assertPath("baz", new PathFragment("/foo/bar/baz").subFragment(2, 3));
-    assertPath("/", new PathFragment("/foo/bar/baz").subFragment(0, 0));
-    assertPath("", new PathFragment("foo/bar/baz").subFragment(0, 0));
-    assertPath("", new PathFragment("foo/bar/baz").subFragment(1, 1));
+               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));
     try {
-      fail("unexpectedly succeeded: " + new PathFragment("foo/bar/baz").subFragment(3, 2));
+      fail("unexpectedly succeeded: " + PathFragment.create("foo/bar/baz").subFragment(3, 2));
     } catch (IndexOutOfBoundsException e) { /* Expected. */ }
     try {
-      fail("unexpectedly succeeded: " + new PathFragment("foo/bar/baz").subFragment(4, 4));
+      fail("unexpectedly succeeded: " + PathFragment.create("foo/bar/baz").subFragment(4, 4));
     } catch (IndexOutOfBoundsException e) { /* Expected. */ }
   }
 
   @Test
   public void testStartsWith() {
-    PathFragment foobar = new PathFragment("/foo/bar");
-    PathFragment foobarRelative = new PathFragment("foo/bar");
+    PathFragment foobar = PathFragment.create("/foo/bar");
+    PathFragment foobarRelative = PathFragment.create("foo/bar");
 
     // (path, prefix) => true
     assertTrue(foobar.startsWith(foobar));
-    assertTrue(foobar.startsWith(new PathFragment("/")));
-    assertTrue(foobar.startsWith(new PathFragment("/foo")));
-    assertTrue(foobar.startsWith(new PathFragment("/foo/")));
-    assertTrue(foobar.startsWith(new PathFragment("/foo/bar/")));  // Includes trailing slash.
+    assertTrue(foobar.startsWith(PathFragment.create("/")));
+    assertTrue(foobar.startsWith(PathFragment.create("/foo")));
+    assertTrue(foobar.startsWith(PathFragment.create("/foo/")));
+    assertTrue(foobar.startsWith(PathFragment.create("/foo/bar/")));  // Includes trailing slash.
 
     // (prefix, path) => false
-    assertFalse(new PathFragment("/foo").startsWith(foobar));
-    assertFalse(new PathFragment("/").startsWith(foobar));
+    assertFalse(PathFragment.create("/foo").startsWith(foobar));
+    assertFalse(PathFragment.create("/").startsWith(foobar));
 
     // (absolute, relative) => false
     assertFalse(foobar.startsWith(foobarRelative));
@@ -367,40 +378,40 @@ public class PathFragmentTest {
 
     // (relative path, relative prefix) => true
     assertTrue(foobarRelative.startsWith(foobarRelative));
-    assertTrue(foobarRelative.startsWith(new PathFragment("foo")));
-    assertTrue(foobarRelative.startsWith(new PathFragment("")));
+    assertTrue(foobarRelative.startsWith(PathFragment.create("foo")));
+    assertTrue(foobarRelative.startsWith(PathFragment.create("")));
 
     // (path, sibling) => false
-    assertFalse(new PathFragment("/foo/wiz").startsWith(foobar));
-    assertFalse(foobar.startsWith(new PathFragment("/foo/wiz")));
+    assertFalse(PathFragment.create("/foo/wiz").startsWith(foobar));
+    assertFalse(foobar.startsWith(PathFragment.create("/foo/wiz")));
 
     // Does not normalize.
-    PathFragment foodotbar = new PathFragment("foo/./bar");
+    PathFragment foodotbar = PathFragment.create("foo/./bar");
     assertTrue(foodotbar.startsWith(foodotbar));
-    assertTrue(foodotbar.startsWith(new PathFragment("foo/.")));
-    assertTrue(foodotbar.startsWith(new PathFragment("foo/./")));
-    assertTrue(foodotbar.startsWith(new PathFragment("foo/./bar")));
-    assertFalse(foodotbar.startsWith(new PathFragment("foo/bar")));
+    assertTrue(foodotbar.startsWith(PathFragment.create("foo/.")));
+    assertTrue(foodotbar.startsWith(PathFragment.create("foo/./")));
+    assertTrue(foodotbar.startsWith(PathFragment.create("foo/./bar")));
+    assertFalse(foodotbar.startsWith(PathFragment.create("foo/bar")));
   }
 
   @Test
   public void testFilterPathsStartingWith() {
     // Retains everything:
     ImmutableSet<PathFragment> allUnderA = toPathsSet("a/b", "a/c", "a/d");
-    assertThat(PathFragment.filterPathsStartingWith(allUnderA, new PathFragment("a")))
+    assertThat(PathFragment.filterPathsStartingWith(allUnderA, PathFragment.create("a")))
         .containsExactlyElementsIn(allUnderA);
 
     // Retains some but not others:
     ImmutableSet<PathFragment> mixed = toPathsSet("a/b", "a/c", "b/c");
     assertThat(PathFragment.filterPathsStartingWith(mixed,
-        new PathFragment("a"))).containsExactlyElementsIn(toPathsSet("a/b", "a/c"));
+        PathFragment.create("a"))).containsExactlyElementsIn(toPathsSet("a/b", "a/c"));
 
     // Retains none:
-    assertThat(PathFragment.filterPathsStartingWith(allUnderA, new PathFragment("b"))).isEmpty();
+    assertThat(PathFragment.filterPathsStartingWith(allUnderA, PathFragment.create("b"))).isEmpty();
 
     // Retains paths equal to the startingWithPath:
     assertThat(PathFragment.filterPathsStartingWith(toPathsSet("a"),
-        new PathFragment("a"))).containsExactlyElementsIn(toPathsSet("a"));
+        PathFragment.create("a"))).containsExactlyElementsIn(toPathsSet("a"));
 
     // Retains everything when startingWithPath is the empty fragment:
     assertThat(PathFragment.filterPathsStartingWith(mixed, PathFragment.EMPTY_FRAGMENT))
@@ -408,23 +419,23 @@ public class PathFragmentTest {
 
     // Supports multi-segment startingWithPaths:
     assertThat(PathFragment.filterPathsStartingWith(toPathsSet("a/b/c", "a/b/d", "a/c/d"),
-        new PathFragment("a/b"))).containsExactlyElementsIn(toPathsSet("a/b/c", "a/b/d"));
+        PathFragment.create("a/b"))).containsExactlyElementsIn(toPathsSet("a/b/c", "a/b/d"));
   }
 
   @Test
   public void testCheckAllPathsStartWithButAreNotEqualTo() {
     // Check passes:
     PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a/c"),
-        new PathFragment("a"));
+        PathFragment.create("a"));
 
     // Check trivially passes:
     PathFragment.checkAllPathsAreUnder(ImmutableList.<PathFragment>of(),
-        new PathFragment("a"));
+        PathFragment.create("a"));
 
     // Check fails when some path does not start with startingWithPath:
     try {
       PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "b/c"),
-          new PathFragment("a"));
+          PathFragment.create("a"));
       fail();
     } catch (IllegalArgumentException expected) {
     }
@@ -432,7 +443,7 @@ public class PathFragmentTest {
     // Check fails when some path is equal to startingWithPath:
     try {
       PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a"),
-          new PathFragment("a"));
+          PathFragment.create("a"));
       fail();
     } catch (IllegalArgumentException expected) {
     }
@@ -440,24 +451,24 @@ public class PathFragmentTest {
 
   @Test
   public void testEndsWith() {
-    PathFragment foobar = new PathFragment("/foo/bar");
-    PathFragment foobarRelative = new PathFragment("foo/bar");
+    PathFragment foobar = PathFragment.create("/foo/bar");
+    PathFragment foobarRelative = PathFragment.create("foo/bar");
 
     // (path, suffix) => true
     assertTrue(foobar.endsWith(foobar));
-    assertTrue(foobar.endsWith(new PathFragment("bar")));
-    assertTrue(foobar.endsWith(new PathFragment("foo/bar")));
-    assertTrue(foobar.endsWith(new PathFragment("/foo/bar")));
-    assertFalse(foobar.endsWith(new PathFragment("/bar")));
+    assertTrue(foobar.endsWith(PathFragment.create("bar")));
+    assertTrue(foobar.endsWith(PathFragment.create("foo/bar")));
+    assertTrue(foobar.endsWith(PathFragment.create("/foo/bar")));
+    assertFalse(foobar.endsWith(PathFragment.create("/bar")));
 
     // (prefix, path) => false
-    assertFalse(new PathFragment("/foo").endsWith(foobar));
-    assertFalse(new PathFragment("/").endsWith(foobar));
+    assertFalse(PathFragment.create("/foo").endsWith(foobar));
+    assertFalse(PathFragment.create("/").endsWith(foobar));
 
     // (suffix, path) => false
-    assertFalse(new PathFragment("/bar").endsWith(foobar));
-    assertFalse(new PathFragment("bar").endsWith(foobar));
-    assertFalse(new PathFragment("").endsWith(foobar));
+    assertFalse(PathFragment.create("/bar").endsWith(foobar));
+    assertFalse(PathFragment.create("bar").endsWith(foobar));
+    assertFalse(PathFragment.create("").endsWith(foobar));
 
     // (absolute, relative) => true
     assertTrue(foobar.endsWith(foobarRelative));
@@ -467,18 +478,18 @@ public class PathFragmentTest {
 
     // (relative path, relative prefix) => true
     assertTrue(foobarRelative.endsWith(foobarRelative));
-    assertTrue(foobarRelative.endsWith(new PathFragment("bar")));
-    assertTrue(foobarRelative.endsWith(new PathFragment("")));
+    assertTrue(foobarRelative.endsWith(PathFragment.create("bar")));
+    assertTrue(foobarRelative.endsWith(PathFragment.create("")));
 
     // (path, sibling) => false
-    assertFalse(new PathFragment("/foo/wiz").endsWith(foobar));
-    assertFalse(foobar.endsWith(new PathFragment("/foo/wiz")));
+    assertFalse(PathFragment.create("/foo/wiz").endsWith(foobar));
+    assertFalse(foobar.endsWith(PathFragment.create("/foo/wiz")));
   }
 
   static List<PathFragment> toPaths(List<String> strs) {
     List<PathFragment> paths = Lists.newArrayList();
     for (String s : strs) {
-      paths.add(new PathFragment(s));
+      paths.add(PathFragment.create(s));
     }
     return paths;
   }
@@ -486,7 +497,7 @@ public class PathFragmentTest {
   static ImmutableSet<PathFragment> toPathsSet(String... strs) {
     ImmutableSet.Builder<PathFragment> builder = ImmutableSet.builder();
     for (String str : strs) {
-      builder.add(new PathFragment(str));
+      builder.add(PathFragment.create(str));
     }
     return builder.build();
   }
@@ -528,24 +539,24 @@ public class PathFragmentTest {
 
   @Test
   public void testGetSafePathString() {
-    assertEquals("/", new PathFragment("/").getSafePathString());
-    assertEquals("/abc", new PathFragment("/abc").getSafePathString());
-    assertEquals(".", new PathFragment("").getSafePathString());
+    assertEquals("/", PathFragment.create("/").getSafePathString());
+    assertEquals("/abc", PathFragment.create("/abc").getSafePathString());
+    assertEquals(".", PathFragment.create("").getSafePathString());
     assertEquals(".", PathFragment.EMPTY_FRAGMENT.getSafePathString());
-    assertEquals("abc/def", new PathFragment("abc/def").getSafePathString());
+    assertEquals("abc/def", PathFragment.create("abc/def").getSafePathString());
   }
 
   @Test
   public void testNormalize() {
-    assertEquals(new PathFragment("/a/b"), new PathFragment("/a/b").normalize());
-    assertEquals(new PathFragment("/a/b"), new PathFragment("/a/./b").normalize());
-    assertEquals(new PathFragment("/b"), new PathFragment("/a/../b").normalize());
-    assertEquals(new PathFragment("a/b"), new PathFragment("a/b").normalize());
-    assertEquals(new PathFragment("../b"), new PathFragment("a/../../b").normalize());
-    assertEquals(new PathFragment(".."), new PathFragment("a/../..").normalize());
-    assertEquals(new PathFragment("b"), new PathFragment("a/../b").normalize());
-    assertEquals(new PathFragment("a/b"), new PathFragment("a/b/../b").normalize());
-    assertEquals(new PathFragment("/.."), new PathFragment("/..").normalize());
+    assertEquals(PathFragment.create("/a/b"), PathFragment.create("/a/b").normalize());
+    assertEquals(PathFragment.create("/a/b"), PathFragment.create("/a/./b").normalize());
+    assertEquals(PathFragment.create("/b"), PathFragment.create("/a/../b").normalize());
+    assertEquals(PathFragment.create("a/b"), PathFragment.create("a/b").normalize());
+    assertEquals(PathFragment.create("../b"), PathFragment.create("a/../../b").normalize());
+    assertEquals(PathFragment.create(".."), PathFragment.create("a/../..").normalize());
+    assertEquals(PathFragment.create("b"), PathFragment.create("a/../b").normalize());
+    assertEquals(PathFragment.create("a/b"), PathFragment.create("a/b/../b").normalize());
+    assertEquals(PathFragment.create("/.."), PathFragment.create("/..").normalize());
   }
 
   @Test
@@ -564,7 +575,7 @@ public class PathFragmentTest {
   }
 
   private void checkSerialization(String pathFragmentString, int expectedSize) throws Exception {
-    PathFragment a = new PathFragment(pathFragmentString);
+    PathFragment a = PathFragment.create(pathFragmentString);
     byte[] sa = TestUtils.serializeObject(a);
     assertEquals(expectedSize, sa.length);
 
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 9506202d16..d22080901b 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
@@ -34,47 +34,47 @@ public class PathFragmentWindowsTest {
 
   @Test
   public void testWindowsSeparator() {
-    assertEquals("bar/baz", new PathFragment("bar\\baz").toString());
-    assertEquals("C:/bar/baz", new PathFragment("c:\\bar\\baz").toString());
+    assertEquals("bar/baz", PathFragment.create("bar\\baz").toString());
+    assertEquals("C:/bar/baz", PathFragment.create("c:\\bar\\baz").toString());
   }
 
   @Test
   public void testIsAbsoluteWindows() {
-    assertTrue(new PathFragment("C:/").isAbsolute());
-    assertTrue(new PathFragment("C:/").isAbsolute());
-    assertTrue(new PathFragment("C:/foo").isAbsolute());
-    assertTrue(new PathFragment("d:/foo/bar").isAbsolute());
+    assertTrue(PathFragment.create("C:/").isAbsolute());
+    assertTrue(PathFragment.create("C:/").isAbsolute());
+    assertTrue(PathFragment.create("C:/foo").isAbsolute());
+    assertTrue(PathFragment.create("d:/foo/bar").isAbsolute());
 
-    assertFalse(new PathFragment("*:/").isAbsolute());
+    assertFalse(PathFragment.create("*:/").isAbsolute());
 
     // C: is not an absolute path, it points to the current active directory on drive C:.
-    assertFalse(new PathFragment("C:").isAbsolute());
-    assertFalse(new PathFragment("C:foo").isAbsolute());
+    assertFalse(PathFragment.create("C:").isAbsolute());
+    assertFalse(PathFragment.create("C:foo").isAbsolute());
   }
 
   @Test
   public void testAbsoluteAndAbsoluteLookingPaths() {
-    PathFragment p1 = new PathFragment("/c");
+    PathFragment p1 = PathFragment.create("/c");
     assertThat(p1.isAbsolute()).isTrue();
     assertThat(p1.getDriveLetter()).isEqualTo('\0');
     assertThat(p1.getSegments()).containsExactly("c");
 
-    PathFragment p2 = new PathFragment("/c/");
+    PathFragment p2 = PathFragment.create("/c/");
     assertThat(p2.isAbsolute()).isTrue();
     assertThat(p2.getDriveLetter()).isEqualTo('\0');
     assertThat(p2.getSegments()).containsExactly("c");
 
-    PathFragment p3 = new PathFragment("C:/");
+    PathFragment p3 = PathFragment.create("C:/");
     assertThat(p3.isAbsolute()).isTrue();
     assertThat(p3.getDriveLetter()).isEqualTo('C');
     assertThat(p3.getSegments()).isEmpty();
 
-    PathFragment p4 = new PathFragment("C:");
+    PathFragment p4 = PathFragment.create("C:");
     assertThat(p4.isAbsolute()).isFalse();
     assertThat(p4.getDriveLetter()).isEqualTo('C');
     assertThat(p4.getSegments()).isEmpty();
 
-    PathFragment p5 = new PathFragment("/c:");
+    PathFragment p5 = PathFragment.create("/c:");
     assertThat(p5.isAbsolute()).isTrue();
     assertThat(p5.getDriveLetter()).isEqualTo('\0');
     assertThat(p5.getSegments()).containsExactly("c:");
@@ -90,39 +90,39 @@ public class PathFragmentWindowsTest {
 
   @Test
   public void testIsAbsoluteWindowsBackslash() {
-    assertTrue(new PathFragment(new File("C:\\blah")).isAbsolute());
-    assertTrue(new PathFragment(new File("C:\\")).isAbsolute());
-    assertTrue(new PathFragment(new File("\\blah")).isAbsolute());
-    assertTrue(new PathFragment(new File("\\")).isAbsolute());
+    assertTrue(PathFragment.create(new File("C:\\blah")).isAbsolute());
+    assertTrue(PathFragment.create(new File("C:\\")).isAbsolute());
+    assertTrue(PathFragment.create(new File("\\blah")).isAbsolute());
+    assertTrue(PathFragment.create(new File("\\")).isAbsolute());
   }
 
   @Test
   public void testIsNormalizedWindows() {
-    assertTrue(new PathFragment("C:/").isNormalized());
-    assertTrue(new PathFragment("C:/absolute/path").isNormalized());
-    assertFalse(new PathFragment("C:/absolute/./path").isNormalized());
-    assertFalse(new PathFragment("C:/absolute/../path").isNormalized());
+    assertTrue(PathFragment.create("C:/").isNormalized());
+    assertTrue(PathFragment.create("C:/absolute/path").isNormalized());
+    assertFalse(PathFragment.create("C:/absolute/./path").isNormalized());
+    assertFalse(PathFragment.create("C:/absolute/../path").isNormalized());
   }
 
   @Test
   public void testRootNodeReturnsRootStringWindows() {
-    PathFragment rootFragment = new PathFragment("C:/");
+    PathFragment rootFragment = PathFragment.create("C:/");
     assertEquals("C:/", rootFragment.getPathString());
   }
 
   @Test
   public void testGetRelativeWindows() {
-    assertEquals("C:/a/b", new PathFragment("C:/a").getRelative("b").getPathString());
-    assertEquals("C:/a/b/c/d", new PathFragment("C:/a/b").getRelative("c/d").getPathString());
-    assertEquals("C:/b", new PathFragment("C:/a").getRelative("C:/b").getPathString());
-    assertEquals("C:/c/d", new PathFragment("C:/a/b").getRelative("C:/c/d").getPathString());
-    assertEquals("C:/b", new PathFragment("a").getRelative("C:/b").getPathString());
-    assertEquals("C:/c/d", new PathFragment("a/b").getRelative("C:/c/d").getPathString());
+    assertEquals("C:/a/b", PathFragment.create("C:/a").getRelative("b").getPathString());
+    assertEquals("C:/a/b/c/d", PathFragment.create("C:/a/b").getRelative("c/d").getPathString());
+    assertEquals("C:/b", PathFragment.create("C:/a").getRelative("C:/b").getPathString());
+    assertEquals("C:/c/d", PathFragment.create("C:/a/b").getRelative("C:/c/d").getPathString());
+    assertEquals("C:/b", PathFragment.create("a").getRelative("C:/b").getPathString());
+    assertEquals("C:/c/d", PathFragment.create("a/b").getRelative("C:/c/d").getPathString());
   }
 
   private void assertGetRelative(String path, String relative, PathFragment expected)
       throws Exception {
-    PathFragment actual = new PathFragment(path).getRelative(relative);
+    PathFragment actual = PathFragment.create(path).getRelative(relative);
     assertThat(actual.getPathString()).isEqualTo(expected.getPathString());
     assertThat(actual).isEqualTo(expected);
     assertThat(actual.getDriveLetter()).isEqualTo(expected.getDriveLetter());
@@ -131,8 +131,8 @@ public class PathFragmentWindowsTest {
 
   private void assertRelativeTo(String path, String relativeTo, String... expectedPathSegments)
       throws Exception {
-    PathFragment expected = new PathFragment('\0', false, expectedPathSegments);
-    PathFragment actual = new PathFragment(path).relativeTo(relativeTo);
+    PathFragment expected = PathFragment.createNoClone('\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());
@@ -141,7 +141,7 @@ public class PathFragmentWindowsTest {
 
   private void assertCantComputeRelativeTo(String path, String relativeTo) throws Exception {
     try {
-      new PathFragment(path).relativeTo(relativeTo);
+      PathFragment.create(path).relativeTo(relativeTo);
       Assert.fail("expected failure");
     } catch (Exception e) {
       assertThat(e.getMessage()).contains("is not beneath");
@@ -149,7 +149,7 @@ public class PathFragmentWindowsTest {
   }
 
   private static PathFragment makePath(char drive, boolean absolute, String... segments) {
-    return new PathFragment(drive, absolute, segments);
+    return PathFragment.createNoClone(drive, absolute, segments);
   }
 
   @Test
@@ -193,14 +193,14 @@ public class PathFragmentWindowsTest {
 
   @Test
   public void testGetChildWorks() {
-    PathFragment pf = new PathFragment("../some/path");
-    assertEquals(new PathFragment("../some/path/hi"), pf.getChild("hi"));
+    PathFragment pf = PathFragment.create("../some/path");
+    assertEquals(PathFragment.create("../some/path/hi"), pf.getChild("hi"));
   }
 
   // Tests after here test the canonicalization
   private void assertRegular(String expected, String actual) {
-    PathFragment exp = new PathFragment(expected);
-    PathFragment act = new PathFragment(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);
@@ -233,18 +233,18 @@ public class PathFragmentWindowsTest {
     // information to the path itself.
     assertAllEqual(
         PathFragment.EMPTY_FRAGMENT,
-        new PathFragment("C:"),
-        new PathFragment("D:"),
-        new PathFragment('\0', false, new String[0]),
-        new PathFragment('C', false, new String[0]),
-        new PathFragment('D', false, new String[0]));
-    assertAllEqual(new PathFragment("/c"), new PathFragment("/c/"));
-    assertThat(new PathFragment("C:/")).isNotEqualTo(new PathFragment("/c"));
-    assertThat(new PathFragment("C:/foo")).isNotEqualTo(new PathFragment("/c/foo"));
+        PathFragment.create("C:"),
+        PathFragment.create("D:"),
+        PathFragment.createNoClone('\0', false, new String[0]),
+        PathFragment.createNoClone('C', false, new String[0]),
+        PathFragment.createNoClone('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(new PathFragment("C:/")).isNotEqualTo(new PathFragment("C:"));
-    assertThat(new PathFragment("C:/").getPathString())
-        .isNotEqualTo(new PathFragment("C:").getPathString());
+    assertThat(PathFragment.create("C:/")).isNotEqualTo(PathFragment.create("C:"));
+    assertThat(PathFragment.create("C:/").getPathString())
+        .isNotEqualTo(PathFragment.create("C:").getPathString());
   }
 
   @Test
@@ -271,10 +271,10 @@ public class PathFragmentWindowsTest {
 
   @Test
   public void testGetParentDirectoryWindows() {
-    PathFragment fooBarWizAbs = new PathFragment("C:/foo/bar/wiz");
-    PathFragment fooBarAbs = new PathFragment("C:/foo/bar");
-    PathFragment fooAbs = new PathFragment("C:/foo");
-    PathFragment rootAbs = new PathFragment("C:/");
+    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:/");
     assertEquals(fooBarAbs, fooBarWizAbs.getParentDirectory());
     assertEquals(fooAbs, fooBarAbs.getParentDirectory());
     assertEquals(rootAbs, fooAbs.getParentDirectory());
@@ -282,29 +282,29 @@ public class PathFragmentWindowsTest {
 
     // Note, this is suprising but correct behaviour:
     assertEquals(fooBarAbs,
-                 new PathFragment("C:/foo/bar/..").getParentDirectory());
+                 PathFragment.create("C:/foo/bar/..").getParentDirectory());
   }
 
   @Test
   public void testSegmentsCountWindows() {
-    assertEquals(1, new PathFragment("C:/foo").segmentCount());
-    assertEquals(0, new PathFragment("C:/").segmentCount());
+    assertEquals(1, PathFragment.create("C:/foo").segmentCount());
+    assertEquals(0, PathFragment.create("C:/").segmentCount());
   }
 
   @Test
   public void testGetSegmentWindows() {
-    assertEquals("foo", new PathFragment("C:/foo/bar").getSegment(0));
-    assertEquals("bar", new PathFragment("C:/foo/bar").getSegment(1));
-    assertEquals("foo", new PathFragment("C:/foo/").getSegment(0));
-    assertEquals("foo", new PathFragment("C:/foo").getSegment(0));
+    assertEquals("foo", PathFragment.create("C:/foo/bar").getSegment(0));
+    assertEquals("bar", PathFragment.create("C:/foo/bar").getSegment(1));
+    assertEquals("foo", PathFragment.create("C:/foo/").getSegment(0));
+    assertEquals("foo", PathFragment.create("C:/foo").getSegment(0));
   }
 
   @Test
   public void testBasenameWindows() throws Exception {
-    assertEquals("bar", new PathFragment("C:/foo/bar").getBaseName());
-    assertEquals("foo", new PathFragment("C:/foo").getBaseName());
+    assertEquals("bar", PathFragment.create("C:/foo/bar").getBaseName());
+    assertEquals("foo", PathFragment.create("C:/foo").getBaseName());
     // Never return the drive name as a basename.
-    assertThat(new PathFragment("C:/").getBaseName()).isEmpty();
+    assertThat(PathFragment.create("C:/").getBaseName()).isEmpty();
   }
 
   private static void assertPath(String expected, PathFragment actual) {
@@ -313,43 +313,43 @@ public class PathFragmentWindowsTest {
 
   @Test
   public void testReplaceNameWindows() throws Exception {
-    assertPath("C:/foo/baz", new PathFragment("C:/foo/bar").replaceName("baz"));
-    assertNull(new PathFragment("C:/").replaceName("baz"));
+    assertPath("C:/foo/baz", PathFragment.create("C:/foo/bar").replaceName("baz"));
+    assertNull(PathFragment.create("C:/").replaceName("baz"));
   }
 
   @Test
   public void testStartsWithWindows() {
-    assertTrue(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:/foo")));
-    assertTrue(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:/")));
-    assertTrue(new PathFragment("C:foo/bar").startsWith(new PathFragment("C:")));
-    assertTrue(new PathFragment("C:/").startsWith(new PathFragment("C:/")));
-    assertTrue(new PathFragment("C:").startsWith(new PathFragment("C:")));
+    assertTrue(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:/foo")));
+    assertTrue(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:/")));
+    assertTrue(PathFragment.create("C:foo/bar").startsWith(PathFragment.create("C:")));
+    assertTrue(PathFragment.create("C:/").startsWith(PathFragment.create("C:/")));
+    assertTrue(PathFragment.create("C:").startsWith(PathFragment.create("C:")));
 
     // The first path is absolute, the second is not.
-    assertFalse(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:")));
-    assertFalse(new PathFragment("C:/").startsWith(new PathFragment("C:")));
+    assertFalse(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:")));
+    assertFalse(PathFragment.create("C:/").startsWith(PathFragment.create("C:")));
   }
 
   @Test
   public void testEndsWithWindows() {
-    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("bar")));
-    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("foo/bar")));
-    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("C:/foo/bar")));
-    assertTrue(new PathFragment("C:/").endsWith(new PathFragment("C:/")));
+    assertTrue(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("bar")));
+    assertTrue(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("foo/bar")));
+    assertTrue(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("C:/foo/bar")));
+    assertTrue(PathFragment.create("C:/").endsWith(PathFragment.create("C:/")));
   }
 
   @Test
   public void testGetSafePathStringWindows() {
-    assertEquals("C:/", new PathFragment("C:/").getSafePathString());
-    assertEquals("C:/abc", new PathFragment("C:/abc").getSafePathString());
-    assertEquals("C:/abc/def", new PathFragment("C:/abc/def").getSafePathString());
+    assertEquals("C:/", PathFragment.create("C:/").getSafePathString());
+    assertEquals("C:/abc", PathFragment.create("C:/abc").getSafePathString());
+    assertEquals("C:/abc/def", PathFragment.create("C:/abc/def").getSafePathString());
   }
 
   @Test
   public void testNormalizeWindows() {
-    assertEquals(new PathFragment("C:/a/b"), new PathFragment("C:/a/b").normalize());
-    assertEquals(new PathFragment("C:/a/b"), new PathFragment("C:/a/./b").normalize());
-    assertEquals(new PathFragment("C:/b"), new PathFragment("C:/a/../b").normalize());
-    assertEquals(new PathFragment("C:/../b"), new PathFragment("C:/../b").normalize());
+    assertEquals(PathFragment.create("C:/a/b"), PathFragment.create("C:/a/b").normalize());
+    assertEquals(PathFragment.create("C:/a/b"), PathFragment.create("C:/a/./b").normalize());
+    assertEquals(PathFragment.create("C:/b"), PathFragment.create("C:/a/../b").normalize());
+    assertEquals(PathFragment.create("C:/../b"), PathFragment.create("C:/../b").normalize());
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathGetParentTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathGetParentTest.java
index 5e6224c998..5681ba2ab1 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/PathGetParentTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathGetParentTest.java
@@ -81,6 +81,6 @@ public class PathGetParentTest {
 
     // Under UNIX, inode(/tmp/wiz/..) == inode(/).  However getPath() does not
     // perform I/O, only string operations, so it disagrees:
-    assertEquals(tmp, tmp.getRelative(new PathFragment("wiz/..")));
+    assertEquals(tmp, tmp.getRelative(PathFragment.create("wiz/..")));
   }
 }
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
index 1976f05f8d..de1a47cb4c 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java
@@ -179,11 +179,11 @@ public class PathTest {
   public void testGetRelativeWithFragmentWorks() {
     Path dir = filesystem.getPath("/first/x");
     assertEquals("/first/x/y",
-                 dir.getRelative(new PathFragment("y")).toString());
+                 dir.getRelative(PathFragment.create("y")).toString());
     assertEquals("/first/x/x",
-                 dir.getRelative(new PathFragment("./x")).toString());
+                 dir.getRelative(PathFragment.create("./x")).toString());
     assertEquals("/first/y",
-                 dir.getRelative(new PathFragment("../y")).toString());
+                 dir.getRelative(PathFragment.create("../y")).toString());
 
   }
 
@@ -191,7 +191,7 @@ public class PathTest {
   public void testGetRelativeWithAbsoluteFragmentWorks() {
     Path root = filesystem.getPath("/first/x");
     assertEquals("/x/y",
-                 root.getRelative(new PathFragment("/x/y")).toString());
+                 root.getRelative(PathFragment.create("/x/y")).toString());
   }
 
   @Test
@@ -238,14 +238,14 @@ public class PathTest {
   @Test
   public void testSiblingNonEquivalenceFragment() {
     assertNotSame(
-        root.getRelative(new PathFragment("aSingleSegment")),
-        root.getRelative(new PathFragment("aDifferentSegment")));
+        root.getRelative(PathFragment.create("aSingleSegment")),
+        root.getRelative(PathFragment.create("aDifferentSegment")));
   }
 
   @Test
   public void testHashCodeStableAcrossGarbageCollections() {
     Path parent = filesystem.getPath("/a");
-    PathFragment childFragment = new PathFragment("b");
+    PathFragment childFragment = PathFragment.create("b");
     Path child = parent.getRelative(childFragment);
     WeakReference<Path> childRef = new WeakReference<>(child);
     int childHashCode1 = childRef.get().hashCode();
@@ -315,7 +315,7 @@ public class PathTest {
   }
 
   private void assertAsFragmentWorks(String expected) {
-    assertEquals(new PathFragment(expected), filesystem.getPath(expected).asFragment());
+    assertEquals(PathFragment.create(expected), filesystem.getPath(expected).asFragment());
   }
 
   private void assertGetRelativeWorks(String expected, String relative) {
@@ -324,7 +324,7 @@ public class PathTest {
   }
 
   private void assertRelativeToWorks(String expected, String relative, String original) {
-    assertEquals(new PathFragment(expected),
+    assertEquals(PathFragment.create(expected),
                  filesystem.getPath(relative).relativeTo(filesystem.getPath(original)));
   }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/RootedPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/RootedPathTest.java
index 83a72111b5..7ad65313c0 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/RootedPathTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/RootedPathTest.java
@@ -40,12 +40,14 @@ public class RootedPathTest {
   public void testEqualsAndHashCodeContract() throws Exception {
     Path pkgRoot1 = root.getRelative("pkgroot1");
     Path pkgRoot2 = root.getRelative("pkgroot2");
-    RootedPath rootedPathA1 = RootedPath.toRootedPath(pkgRoot1, new PathFragment("foo/bar"));
-    RootedPath rootedPathA2 = RootedPath.toRootedPath(pkgRoot1, new PathFragment("foo/bar"));
-    RootedPath absolutePath1 = RootedPath.toRootedPath(root, new PathFragment("pkgroot1/foo/bar"));
-    RootedPath rootedPathB1 = RootedPath.toRootedPath(pkgRoot2, new PathFragment("foo/bar"));
-    RootedPath rootedPathB2 = RootedPath.toRootedPath(pkgRoot2, new PathFragment("foo/bar"));
-    RootedPath absolutePath2 = RootedPath.toRootedPath(root, new PathFragment("pkgroot2/foo/bar"));
+    RootedPath rootedPathA1 = RootedPath.toRootedPath(pkgRoot1, PathFragment.create("foo/bar"));
+    RootedPath rootedPathA2 = RootedPath.toRootedPath(pkgRoot1, PathFragment.create("foo/bar"));
+    RootedPath absolutePath1 =
+        RootedPath.toRootedPath(root, PathFragment.create("pkgroot1/foo/bar"));
+    RootedPath rootedPathB1 = RootedPath.toRootedPath(pkgRoot2, PathFragment.create("foo/bar"));
+    RootedPath rootedPathB2 = RootedPath.toRootedPath(pkgRoot2, PathFragment.create("foo/bar"));
+    RootedPath absolutePath2 =
+        RootedPath.toRootedPath(root, PathFragment.create("pkgroot2/foo/bar"));
     new EqualsTester()
       .addEqualityGroup(rootedPathA1, rootedPathA2)
       .addEqualityGroup(rootedPathB1, rootedPathB2)
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/ScopeEscapableFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/ScopeEscapableFileSystemTest.java
index f321ab93e3..cec1523a0e 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/ScopeEscapableFileSystemTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/ScopeEscapableFileSystemTest.java
@@ -129,7 +129,7 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
     }
   }
 
-  protected static final PathFragment SCOPE_ROOT = new PathFragment("/fs/root");
+  protected static final PathFragment SCOPE_ROOT = PathFragment.create("/fs/root");
 
   private Path fileLink;
   private PathFragment fileLinkTarget;
@@ -146,11 +146,11 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
     }
 
     fileLink = testFS.getPath(SCOPE_ROOT.getRelative("link"));
-    fileLinkTarget = new PathFragment("/should/be/delegated/fileLinkTarget");
+    fileLinkTarget = PathFragment.create("/should/be/delegated/fileLinkTarget");
     testFS.createSymbolicLink(fileLink, fileLinkTarget);
 
     dirLink = testFS.getPath(SCOPE_ROOT.getRelative("dirlink"));
-    dirLinkTarget = new PathFragment("/should/be/delegated/dirLinkTarget");
+    dirLinkTarget = PathFragment.create("/should/be/delegated/dirLinkTarget");
     testFS.createSymbolicLink(dirLink, dirLinkTarget);
   }
 
@@ -605,7 +605,7 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
     };
     scopedFS().setDelegator(delegator);
 
-    PathFragment newLinkTarget = new PathFragment("/something/else");
+    PathFragment newLinkTarget = PathFragment.create("/something/else");
     dirLink.getRelative("a").createSymbolicLink(newLinkTarget);
     assertEquals(dirLinkTarget.getRelative("a"), delegator.lastPath());
     assertSame(newLinkTarget, delegator.objectState());
@@ -623,7 +623,7 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
     scopedFS().setDelegator(delegator);
 
     // Since we're not following the link, this shouldn't invoke delegation.
-    delegator.setState(new PathFragment("whatever"));
+    delegator.setState(PathFragment.create("whatever"));
     PathFragment p = fileLink.readSymbolicLink();
     assertNull(delegator.lastPath());
     assertNotSame(delegator.objectState(), p);
@@ -705,7 +705,7 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
    */
   private void assertInScopeLink(String link, String target, TestDelegator d) throws IOException {
     Path l = testFS.getPath(SCOPE_ROOT.getRelative(link));
-    testFS.createSymbolicLink(l, new PathFragment(target));
+    testFS.createSymbolicLink(l, PathFragment.create(target));
     l.exists();
     assertNull(d.lastPath());
   }
@@ -717,7 +717,7 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
   private void assertOutOfScopeLink(String link, String target, String expectedPath,
       TestDelegator d) throws IOException {
     Path l = testFS.getPath(SCOPE_ROOT.getRelative(link));
-    testFS.createSymbolicLink(l, new PathFragment(target));
+    testFS.createSymbolicLink(l, PathFragment.create(target));
     l.exists();
     assertEquals(expectedPath, d.lastPath().getPathString());
   }
@@ -768,7 +768,7 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
 
     // Out-of-scope symlink that's not the final segment in a query.
     Path oDirLink = testFS.getPath(SCOPE_ROOT.getRelative("olinkdir"));
-    testFS.createSymbolicLink(oDirLink, new PathFragment("/some/other/dir"));
+    testFS.createSymbolicLink(oDirLink, PathFragment.create("/some/other/dir"));
     oDirLink.getRelative("file").exists();
     assertEquals("/some/other/dir/file", d.lastPath().getPathString());
   }
@@ -807,13 +807,13 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
 
     // In-scope symlink that's not the final segment in a query.
     Path iDirLink = testFS.getPath(SCOPE_ROOT.getRelative("dir/dir2/ilinkdir"));
-    testFS.createSymbolicLink(iDirLink, new PathFragment("../../dir"));
+    testFS.createSymbolicLink(iDirLink, PathFragment.create("../../dir"));
     iDirLink.getRelative("file").exists();
     assertNull(d.lastPath());
 
     // Out-of-scope symlink that's not the final segment in a query.
     Path oDirLink = testFS.getPath(SCOPE_ROOT.getRelative("dir/dir2/olinkdir"));
-    testFS.createSymbolicLink(oDirLink, new PathFragment("../../../other/dir"));
+    testFS.createSymbolicLink(oDirLink, PathFragment.create("../../../other/dir"));
     oDirLink.getRelative("file").exists();
     assertEquals(chopScopeRoot(1) + "/other/dir/file", d.lastPath().getPathString());
   }
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 9f9480c19b..b048748861 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
@@ -200,7 +200,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
     };
     Path linkPath = absolutize("link");
     for (String linkTarget : linkTargets) {
-      PathFragment relative = new PathFragment(linkTarget);
+      PathFragment relative = PathFragment.create(linkTarget);
       linkPath.delete();
       createSymbolicLink(linkPath, relative);
       if (supportsSymlinks) {
@@ -246,7 +246,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
   @Test
   public void testLinkToFragmentContainingLinkResolvesCorrectly() throws IOException {
     Path link1 = absolutize("link1");
-    PathFragment link1target = new PathFragment("link2/foo");
+    PathFragment link1target = PathFragment.create("link2/foo");
     Path link2 = absolutize("link2");
     Path link2target = xNonEmptyDirectory;
 
@@ -331,7 +331,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
       String prefix = "./";
       while ((ancestor = ancestor.getParentDirectory()) != null) {
         xLinkToFile.delete();
-        createSymbolicLink(xLinkToFile, new PathFragment(prefix + xFile.relativeTo(ancestor)));
+        createSymbolicLink(xLinkToFile, PathFragment.create(prefix + xFile.relativeTo(ancestor)));
         assertEquals(xFile, xLinkToFile.resolveSymbolicLinks());
 
         prefix += "../";
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 50329d6ed0..c1e793562a 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
@@ -64,8 +64,8 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
 
   private UnionFileSystem createDefaultUnionFileSystem(boolean readOnly) {
     return new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
-        new PathFragment("/in"), inDelegate,
-        new PathFragment("/out"), outDelegate),
+        PathFragment.create("/in"), inDelegate,
+        PathFragment.create("/out"), outDelegate),
         defaultDelegate, readOnly);
   }
 
@@ -123,8 +123,8 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
   @Test
   public void testPrefixDelegation() throws Exception {
     unionfs = new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
-              new PathFragment("/foo"), inDelegate,
-              new PathFragment("/foo/bar"), outDelegate), defaultDelegate);
+              PathFragment.create("/foo"), inDelegate,
+              PathFragment.create("/foo/bar"), outDelegate), defaultDelegate);
 
     assertSame(inDelegate, unionfs.getDelegate(unionfs.getPath("/foo/foo.txt")));
     assertSame(outDelegate, unionfs.getDelegate(unionfs.getPath("/foo/bar/foo.txt")));
@@ -220,7 +220,7 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
     outStream.close();
 
     Path outFoo = unionfs.getPath("/out/foo");
-    unionfs.createSymbolicLink(outFoo, new PathFragment("../in/bar.txt"));
+    unionfs.createSymbolicLink(outFoo, PathFragment.create("../in/bar.txt"));
     assertTrue(unionfs.stat(outFoo, false).isSymbolicLink());
 
     try {
@@ -253,8 +253,8 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
   @Test
   public void testWithinDirectoryMapping() throws Exception {
     unionfs = new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
-        new PathFragment("/fruit/a"), inDelegate,
-        new PathFragment("/fruit/b"), outDelegate), defaultDelegate);
+        PathFragment.create("/fruit/a"), inDelegate,
+        PathFragment.create("/fruit/b"), outDelegate), defaultDelegate);
     assertTrue(unionfs.createDirectory(unionfs.getPath("/fruit")));
     assertTrue(defaultDelegate.getPath("/fruit").isDirectory());
     assertTrue(inDelegate.getPath("/fruit").createDirectory());
@@ -309,7 +309,7 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
   @Test
   public void testCreateParentsAcrossMapping() throws Exception {
     unionfs = new UnionFileSystem(ImmutableMap.<PathFragment, FileSystem>of(
-        new PathFragment("/out/dir"), outDelegate), defaultDelegate, false);
+        PathFragment.create("/out/dir"), outDelegate), defaultDelegate, false);
     Path outDir = unionfs.getPath("/out/dir/biz/bang");
     FileSystemUtils.createDirectoryAndParents(outDir);
     assertTrue(outDir.isDirectory());
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystemTest.java
index 65446664d3..ee4dfe937a 100644
--- a/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystemTest.java
+++ b/src/test/java/com/google/devtools/build/lib/vfs/inmemoryfs/InMemoryFileSystemTest.java
@@ -394,8 +394,8 @@ public class InMemoryFileSystemTest extends ScopeEscapableFileSystemTest {
   public void testEloop() throws Exception {
     Path a = testFS.getPath("/a");
     Path b = testFS.getPath("/b");
-    a.createSymbolicLink(new PathFragment("b"));
-    b.createSymbolicLink(new PathFragment("a"));
+    a.createSymbolicLink(PathFragment.create("b"));
+    b.createSymbolicLink(PathFragment.create("a"));
     try {
       a.stat();
     } catch (IOException e) {
@@ -406,7 +406,7 @@ public class InMemoryFileSystemTest extends ScopeEscapableFileSystemTest {
   @Test
   public void testEloopSelf() throws Exception {
     Path a = testFS.getPath("/a");
-    a.createSymbolicLink(new PathFragment("a"));
+    a.createSymbolicLink(PathFragment.create("a"));
     try {
       a.stat();
     } catch (IOException e) {