Add Path argument to supportsModifications, supports*LinksNatively.

This works better with UnionFileSystem, as (eg.) different mapped file systems might not agree on whether they are read-only.

No actual code changes have been made that actually uses this argument, so this should be a behaviour no-op.

PiperOrigin-RevId: 172782759

4 files changed, 45 insertions, 46 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 59245d859a..16c504540e 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
@@ -46,8 +46,6 @@ public abstract class FileSystemTest {
 
   private long savedTime;
   protected FileSystem testFS;
-  protected boolean supportsSymlinks;
-  protected boolean supportsHardlinks;
   protected Path workingDir;
 
   // Some useful examples of various kinds of files (mnemonic: "x" = "eXample")
@@ -64,8 +62,6 @@ public abstract class FileSystemTest {
     testFS = getFreshFileSystem();
     workingDir = testFS.getPath(getTestTmpDir());
     cleanUpWorkingDirectory(workingDir);
-    supportsSymlinks = testFS.supportsSymbolicLinksNatively();
-    supportsHardlinks = testFS.supportsHardLinksNatively();
 
     // % ls -lR
     // -rw-rw-r-- xFile
@@ -382,8 +378,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicFileLinkExists() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xFile);
       assertThat(someLink.exists()).isTrue();
       assertThat(someLink.statIfFound()).isNotNull();
@@ -392,8 +388,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicFileLinkIsSymbolicLink() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xFile);
       assertThat(someLink.isSymbolicLink()).isTrue();
     }
@@ -401,8 +397,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicFileLinkIsFile() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xFile);
       assertThat(someLink.isFile()).isTrue();
     }
@@ -410,8 +406,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicFileLinkIsNotDirectory() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xFile);
       assertThat(someLink.isDirectory()).isFalse();
     }
@@ -419,8 +415,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicDirLinkExists() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xEmptyDirectory);
       assertThat(someLink.exists()).isTrue();
       assertThat(someLink.statIfFound()).isNotNull();
@@ -429,8 +425,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicDirLinkIsSymbolicLink() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xEmptyDirectory);
       assertThat(someLink.isSymbolicLink()).isTrue();
     }
@@ -438,8 +434,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicDirLinkIsDirectory() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xEmptyDirectory);
       assertThat(someLink.isDirectory()).isTrue();
     }
@@ -447,8 +443,8 @@ public abstract class FileSystemTest {
 
   @Test
   public void testSymbolicDirLinkIsNotFile() throws Exception {
-    if (supportsSymlinks) {
-      Path someLink = absolutize("some-link");
+    Path someLink = absolutize("some-link");
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       someLink.createSymbolicLink(xEmptyDirectory);
       assertThat(someLink.isFile()).isFalse();
     }
@@ -1291,7 +1287,7 @@ public abstract class FileSystemTest {
     Path xNonEmptyDirectoryBar = xNonEmptyDirectory.getChild("bar");
     xNonEmptyDirectory.setWritable(false);
 
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xNonEmptyDirectoryBar)) {
       try {
         createSymbolicLink(xNonEmptyDirectoryBar, xNonEmptyDirectoryFoo);
         fail("No exception thrown.");
@@ -1339,7 +1335,7 @@ public abstract class FileSystemTest {
 
   @Test
   public void testResolveSymlinks() throws Exception {
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xLink)) {
       createSymbolicLink(xLink, xFile);
       FileSystemUtils.createEmptyFile(xFile);
       assertThat(testFS.resolveOneLink(xLink)).isEqualTo(xFile.asFragment());
@@ -1349,7 +1345,7 @@ public abstract class FileSystemTest {
 
   @Test
   public void testResolveDanglingSymlinks() throws Exception {
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xLink)) {
       createSymbolicLink(xLink, xNothing);
       assertThat(testFS.resolveOneLink(xLink)).isEqualTo(xNothing.asFragment());
       try {
@@ -1362,7 +1358,7 @@ public abstract class FileSystemTest {
 
   @Test
   public void testResolveNonSymlinks() throws Exception {
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xFile)) {
       assertThat(testFS.resolveOneLink(xFile)).isNull();
       assertThat(xFile.resolveSymbolicLinks()).isEqualTo(xFile);
     }
@@ -1370,7 +1366,7 @@ public abstract class FileSystemTest {
 
   @Test
   public void testCreateHardLink_Success() throws Exception {
-    if (!supportsHardlinks) {
+    if (!testFS.supportsHardLinksNatively(xFile)) {
       return;
     }
     xFile.createHardLink(xLink);
@@ -1383,7 +1379,7 @@ public abstract class FileSystemTest {
 
   @Test
   public void testCreateHardLink_NeitherOriginalNorLinkExists() throws Exception {
-    if (!supportsHardlinks) {
+    if (!testFS.supportsHardLinksNatively(xFile)) {
       return;
     }
 
@@ -1402,7 +1398,7 @@ public abstract class FileSystemTest {
   @Test
   public void testCreateHardLink_OriginalDoesNotExistAndLinkExists() throws Exception {
 
-    if (!supportsHardlinks) {
+    if (!testFS.supportsHardLinksNatively(xFile)) {
       return;
     }
 
@@ -1423,7 +1419,7 @@ public abstract class FileSystemTest {
   @Test
   public void testCreateHardLink_BothOriginalAndLinkExist() throws Exception {
 
-    if (!supportsHardlinks) {
+    if (!testFS.supportsHardLinksNatively(xFile)) {
       return;
     }
     /* Both original file and link file exist */
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 1474756b94..9fd98b0f6d 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
@@ -67,15 +67,18 @@ public abstract class ScopeEscapableFileSystemTest extends SymlinkAwareFileSyste
       return ans != null ? ans.asFragment() : null;
     }
 
-    @Override public boolean supportsModifications() {
+    @Override
+    public boolean supportsModifications(Path path) {
       return true;
     }
 
-    @Override public boolean supportsSymbolicLinksNatively() {
+    @Override
+    public boolean supportsSymbolicLinksNatively(Path path) {
       return true;
     }
 
-    @Override public boolean supportsHardLinksNatively() {
+    @Override
+    public boolean supportsHardLinksNatively(Path path) {
       return true;
     }
 
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 82f8d727aa..d62bc66406 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
@@ -78,7 +78,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
     assertThat(linkPath.isDirectory(Symlinks.NOFOLLOW)).isFalse();
     assertThat(linkPath.isDirectory(Symlinks.FOLLOW)).isFalse();
 
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(linkPath)) {
       assertThat(linkPath.getFileSize(Symlinks.NOFOLLOW)).isEqualTo(newPath.toString().length());
       assertThat(linkPath.getFileSize()).isEqualTo(newPath.getFileSize(Symlinks.NOFOLLOW));
     }
@@ -196,7 +196,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
       PathFragment relative = PathFragment.create(linkTarget);
       linkPath.delete();
       createSymbolicLink(linkPath, relative);
-      if (supportsSymlinks) {
+      if (testFS.supportsSymbolicLinksNatively(linkPath)) {
         assertThat(linkPath.getFileSize(Symlinks.NOFOLLOW)).isEqualTo(linkTarget.length());
         assertThat(linkPath.readSymbolicLink()).isEqualTo(relative);
       }
@@ -258,7 +258,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
     Path link = absolutize("recursive-link");
     createSymbolicLink(link, link);
 
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(link)) {
       try {
         link.resolveSymbolicLinks();
         fail();
@@ -275,7 +275,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
     createSymbolicLink(link2, link1);
     createSymbolicLink(link1, link2);
 
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(link1)) {
       try {
         link1.resolveSymbolicLinks();
         fail();
@@ -287,7 +287,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
 
   @Test
   public void testResolveSymbolicLinksENOENT() {
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xDanglingLink)) {
       try {
         xDanglingLink.resolveSymbolicLinks();
         fail();
@@ -299,9 +299,9 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
 
   @Test
   public void testResolveSymbolicLinksENOTDIR() throws IOException {
-    if (supportsSymlinks) {
-      Path badLinkTarget = xFile.getChild("bad"); // parent is not a directory!
-      Path badLink = absolutize("badLink");
+    Path badLinkTarget = xFile.getChild("bad"); // parent is not a directory!
+    Path badLink = absolutize("badLink");
+    if (testFS.supportsSymbolicLinksNatively(badLink)) {
       createSymbolicLink(badLink, badLinkTarget);
       try {
         badLink.resolveSymbolicLinks();
@@ -316,7 +316,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
 
   @Test
   public void testResolveSymbolicLinksWithUplevelRefs() throws IOException {
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xLinkToFile)) {
       // Create a series of links that refer to xFile as ./xFile,
       // ./../foo/xFile, ./../../bar/foo/xFile, etc.  They should all resolve
       // to xFile.
@@ -334,7 +334,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
 
   @Test
   public void testReadSymbolicLink() throws IOException {
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xDanglingLink)) {
       assertThat(xDanglingLink.readSymbolicLink().toString()).isEqualTo(xNothing.toString());
     }
 
@@ -363,7 +363,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
       throws IOException {
     xEmptyDirectory.setWritable(false);
     Path xChildOfReadonlyDir = xEmptyDirectory.getChild("x");
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xChildOfReadonlyDir)) {
       try {
         xChildOfReadonlyDir.createSymbolicLink(xNothing);
         fail();
@@ -385,7 +385,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
     assertThat(someLink.isSymbolicLink()).isTrue();
     assertThat(someLink.exists(Symlinks.NOFOLLOW)).isTrue(); // the link itself exists
     assertThat(someLink.exists()).isFalse(); // ...but the referent doesn't
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(someLink)) {
       try {
         someLink.resolveSymbolicLinks();
       } catch (FileNotFoundException e) {
@@ -397,7 +397,7 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest {
   @Test
   public void testCannotCreateSymbolicLinkWithoutParent() throws IOException {
     Path xChildOfMissingDir = xNothing.getChild("x");
-    if (supportsSymlinks) {
+    if (testFS.supportsSymbolicLinksNatively(xChildOfMissingDir)) {
       try {
         xChildOfMissingDir.createSymbolicLink(xFile);
         fail();
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 780a529e87..0c8cf77360 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
@@ -136,8 +136,8 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
   // read-only, even if the delegate filesystems are read/write.
   @Test
   public void testModificationFlag() throws Exception {
-    assertThat(unionfs.supportsModifications()).isTrue();
     Path outPath = unionfs.getPath("/out/foo.txt");
+    assertThat(unionfs.supportsModifications(outPath)).isTrue();
     assertThat(unionfs.createDirectory(outPath.getParentDirectory())).isTrue();
     OutputStream outFile = unionfs.getOutputStream(outPath);
     outFile.write('b');
@@ -148,7 +148,7 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest {
     // Note that this does not destroy the underlying filesystems;
     // UnionFileSystem is just a view.
     unionfs = createDefaultUnionFileSystem(true);
-    assertThat(unionfs.supportsModifications()).isFalse();
+    assertThat(unionfs.supportsModifications(outPath)).isFalse();
 
     InputStream outFileInput = unionfs.getInputStream(outPath);
     int outFileByte = outFileInput.read();