fix(nix/utils): remove predicates based on symlink heuristic

Due to [nix#6579] the heuristic which allowed us to determine if a
symlink points to a directory is not reliable – if restrict-eval is
enabled it _will_ return wrong results. Until upstream resolves
this (and we backport the patch) it is probably best to not expose this
functionality at all.

[nix#6579]: https://github.com/NixOS/nix/issues/6579

Change-Id: Id847c794bb279be909c5426953c4fe13c2493343
Reviewed-on: https://cl.tvl.fyi/c/depot/+/5761
Tested-by: BuildkiteCI
Autosubmit: sterni <sternenseemann@systemli.org>
Reviewed-by: tazjin <tazjin@tvl.su>

nix/utils/default.nix

@@ -53,13 +53,7 @@ let
      * `regular`: is a regular file, always `true` if returned
      * `directory`: is a directory, always `true` if returned
      * `missing`: path does not exist, always `true` if returned
-     * `symlink`: path is a symlink, value is a string describing the type
+     * `symlink`: path is a symlink, always `true` if returned
-       of its realpath which may be either:
-
-       * `"directory"`: realpath of the symlink is a directory
-       * `"regular-or-missing`": realpath of the symlink is either a regular
-         file or does not exist. Due to limitations of the Nix expression
-         language, we can't tell which.
 
      Type: path(-like) -> tag
 
@@ -73,10 +67,10 @@ let
        => { directory = true; }
 
        pathType ./result
-       => { symlink = "directory"; }
+       => { symlink = true; }
 
        pathType ./link-to-file
-       => { symlink = "regular-or-missing"; }
+       => { symlink = true; }
 
        pathType /does/not/exist
        => { missing = true; }
@@ -90,12 +84,12 @@ let
 
        # Match on the result using //nix/tag
        nix.tag.match (nix.utils.pathType ./result) {
-         symlink = v: "symlink to ${v}";
+         symlink = _: "symlink";
          directory  = _: "directory";
          regular = _: "regular";
          missing = _: "path does not exist";
        }
-       => "symlink to directory"
+       => "symlink"
 
        # Query path type
        nix.tag.tagName (pathType /path)
@@ -122,11 +116,7 @@ let
       isSymlinkDir = builtins.pathExists (path' + "/.");
     in
     {
-      ${thisPathType} =
+      ${thisPathType} = true;
-        /**/
-        if thisPathType != "symlink" then true
-        else if isSymlinkDir then "directory"
-        else "regular-or-missing";
     };
 
   pathType' = path:
@@ -144,21 +134,6 @@ let
   */
   isDirectory = path: pathType' path ? directory;
 
-  /* Checks whether the given path is a directory or
-     a symlink to a directory. Throws if the path in
-     question doesn't exist.
-
-     Warning: Does not throw if the target file or
-     directory doesn't exist, but the symlink does.
-
-     Type: path(-like) -> bool
-  */
-  realPathIsDirectory = path:
-    let
-      pt = pathType' path;
-    in
-    pt ? directory || pt.symlink or null == "directory";
-
   /* Check whether the given path is a regular file.
      Throws if the path in question doesn't exist.
 
@@ -179,7 +154,6 @@ in
     storePathName
     pathType
     isDirectory
-    realPathIsDirectory
     isRegularFile
     isSymlink
     ;

nix/utils/tests/default.nix

@@ -11,7 +11,6 @@ let
 
   inherit (depot.nix.utils)
     isDirectory
-    realPathIsDirectory
     isRegularFile
     isSymlink
     pathType
@@ -34,16 +33,6 @@ let
     (assertUtilsPred "file not isDirectory"
       (isDirectory ./directory/file)
       false)
-    # realPathIsDirectory
-    (assertUtilsPred "directory realPathIsDirectory"
-      (realPathIsDirectory ./directory)
-      true)
-    (assertUtilsPred "symlink to directory realPathIsDirectory"
-      (realPathIsDirectory ./symlink-directory)
-      true)
-    (assertUtilsPred "realPathIsDirectory resolves chained symlinks"
-      (realPathIsDirectory ./symlink-symlink-directory)
-      true)
     # isRegularFile
     (assertUtilsPred "file isRegularFile"
       (isRegularFile ./directory/file)
@@ -76,31 +65,12 @@ let
     # missing files throw
     (assertThrows "isDirectory throws on missing file"
       (isDirectory ./does-not-exist))
-    (assertThrows "realPathIsDirectory throws on missing file"
-      (realPathIsDirectory ./does-not-exist))
     (assertThrows "isRegularFile throws on missing file"
       (isRegularFile ./does-not-exist))
     (assertThrows "isSymlink throws on missing file"
       (isSymlink ./does-not-exist))
   ]);
 
-  symlinkPathTypeTests = it "correctly judges symlinks" [
-    (assertEq "symlinks to directories are detected correcty"
-      ((pathType ./symlink-directory).symlink or null) "directory")
-    (assertEq "symlinks to symlinks to directories are detected correctly"
-      ((pathType ./symlink-symlink-directory).symlink or null) "directory")
-    (assertEq "symlinks to nowhere are not distinguished from files"
-      ((pathType ./missing).symlink or null) "regular-or-missing")
-
-    # These tests are commented out because they no longer work with
-    # restrict-eval turned on.
-
-    # (assertEq "symlinks to files are detected-ish"
-    #   ((pathType ./symlink-file).symlink or null) "regular-or-missing")
-    # (assertEq "symlinks to symlinks to files are detected-ish"
-    #   ((pathType ./symlink-symlink-file).symlink or null) "regular-or-missing")
-  ];
-
   cheddarStorePath =
     builtins.unsafeDiscardStringContext depot.tools.cheddar.outPath;
 
@@ -125,6 +95,5 @@ in
 
 runTestsuite "nix.utils" [
   pathPredicates
-  symlinkPathTypeTests
   storePathNameTests
 ]