Update Sys.isexecutable() to use new jl_fs_access() API call

`jl_fs_access()` makes use of the `uv_fs_access()` call from LibUV,
which is newly-able to interrogate Win32 ACLs, determining whether a
file is truly executable or not on Windows.

Also update `chmod()` to note that on windows, recursive is effectively
always true.

Author: staticfloat

base/file.jl

@@ -989,6 +989,11 @@ Change the permissions mode of `path` to `mode`. Only integer `mode`s (e.g. `0o7
 currently supported. If `recursive=true` and the path is a directory all permissions in
 that directory will be recursively changed.
 Return `path`.
+
+!!! note
+     Prior to Julia 1.5, this did not correctly manipulate filesystem ACLs
+     on Windows, therefore it would only set read-only bits on files.  It
+     now is able to manipulate ACLs.
 """
 function chmod(path::AbstractString, mode::Integer; recursive::Bool=false)
     err = ccall(:jl_fs_chmod, Int32, (Cstring, Cint), path, mode)

base/sysinfo.jl

@@ -438,16 +438,18 @@ const WINDOWS_VISTA_VER = v"6.0"
     Sys.isexecutable(path::String)
 
 Return `true` if the given `path` has executable permissions.
+
+!!! note
+    Prior to Julia 1.5, this did not correctly interrogate filesystem
+    ACLs on Windows, therefore it would return `true` for any
+    file.  From Julia 1.5 on, it correctly determines whether the
+    file is marked as executable or not.
 """
 function isexecutable(path::String)
-    if iswindows()
-        return isfile(path)
-    else
-        # We use `access()` and `X_OK` to determine if a given path is
-        # executable by the current user.  `X_OK` comes from `unistd.h`.
-        X_OK = 0x01
-        ccall(:access, Cint, (Ptr{UInt8}, Cint), path, X_OK) == 0
-    end
+    # We use `access()` and `X_OK` to determine if a given path is
+    # executable by the current user.  `X_OK` comes from `unistd.h`.
+    X_OK = 0x01
+    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, X_OK) == 0
 end
 isexecutable(path::AbstractString) = isexecutable(String(path))
 

src/jl_uv.c

@@ -392,6 +392,14 @@ JL_DLLEXPORT int jl_fs_chown(char *path, int uid, int gid)
     return ret;
 }
 
+JL_DLLEXPORT int jl_fs_access(char *path, int mode)
+{
+    uv_fs_t req;
+    int ret = uv_fs_access(unused_uv_loop_arg, &req, path, mode, NULL);
+    uv_fs_req_cleanup(&req);
+    return ret;
+}
+
 JL_DLLEXPORT int jl_fs_write(uv_os_fd_t handle, const char *data, size_t len,
                              int64_t offset) JL_NOTSAFEPOINT
 {

test/file.jl

@@ -1510,3 +1510,27 @@ end
         end
     end
 end
+
+@testset "chmod/isexecutable" begin
+    mktempdir() do dir
+        mkdir(joinpath(dir, "subdir"))
+        fpath = joinpath(dir, "subdir", "foo")
+
+        # Test that we can actually set the executable bit on all platforms.
+        touch(fpath)
+        chmod(fpath, 0o644)
+        @test !Sys.isexecutable(fpath)
+        chmod(fpath, 0o755)
+        @test Sys.isexecutable(fpath)
+
+        # Ensure that, on Windows, where inheritance is default,
+        # chmod still behaves as we expect.
+        if Sys.iswindows()
+            chmod(joinpath(dir, "subdir"), 0o666)
+            @test Sys.isexecutable(fpath)
+        end
+
+        # Reset permissions to all at the end, so it can be deleted properly.
+        chmod(dir, 0o777; recursive=true)
+    end
+end