Windows: is_executable returns true for a directory named git.exe (exists() should be is_file())

diff --git a/src/lib.rs b/src/lib.rs
index 1aa7767..3559005 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -57,8 +57,10 @@ mod windows {
 
     impl IsExecutable for Path {
         fn is_executable(&self) -> bool {
-            // First, ensure that the file exists
-            if !self.exists() {
+            // First, ensure that the file exists and is a regular file.
+            // `is_file` follows symlinks, so a symlink to an executable still
+            // passes; `exists` would also accept a directory named like one.
+            if !self.is_file() {
                 return false;
             }
 

diff --git a/tests/tests.rs b/tests/tests.rs
index fd0a39a..41abd74 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -46,6 +46,20 @@ mod windows {
     fn non_existent_correct_extension() {
         assert!(!is_executable("./tests/non_existent.exe"));
     }
+
+    #[test]
+    fn not_executable_directory_with_extension() {
+        let dir = std::env::temp_dir().join(format!("is_executable-dir-{}.exe", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let verdict = is_executable(&dir);
+        std::fs::remove_dir(&dir).unwrap();
+        assert!(!verdict, "a directory named *.exe must not be executable");
+    }
+
+    #[test]
+    fn not_executable_directory() {
+        assert!(!is_executable("."));
+    }
 }
 
 #[cfg(any(target_os = "wasi", target_family = "wasm"))]

// Linux harness for the Windows implementation of `is_executable`.
//
// The body of `windows_is_executable` between the markers is NOT written
// here: run.sh splices it in from the crate's own src/lib.rs (the guard and
// the PATHEXT block of `impl IsExecutable for Path`, `self` renamed to
// `path`), so what runs is the crate's text at the checked commit. The only
// thing left out is the `GetBinaryTypeW` fallback after it, which the crate
// reaches only for paths without an extension; the harness returns false
// there. `Path::exists`, `Path::is_file`, `Path::extension` and the string
// code behave the same on every platform.
//
// Exit 0 when the directory case returns true (defect present), 1 otherwise.
use std::fs;
use std::path::Path;

fn windows_is_executable(path: &Path) -> bool {
    // @@CRATE_BODY@@
    false
}

fn main() {
    let dir = std::env::temp_dir().join(format!("is_executable-harness-{}", std::process::id()));
    fs::create_dir_all(&dir).unwrap();
    // A typical Windows value.
    std::env::set_var("PATHEXT", ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.MSC");

    let evil_dir = dir.join("git.exe");
    fs::create_dir(&evil_dir).unwrap();
    let real = dir.join("real-program.exe");
    fs::write(&real, b"MZ").unwrap();
    let link = dir.join("link.exe");
    std::os::unix::fs::symlink(&real, &link).unwrap();
    let text = dir.join("notes.exe");
    fs::write(&text, b"just text").unwrap();
    let missing = dir.join("missing.exe");
    let no_ext = dir.join("noext");
    fs::write(&no_ext, b"MZ").unwrap();

    let cases: [(&str, &Path, bool); 6] = [
        ("directory named git.exe", &evil_dir, false),
        ("regular file real-program.exe", &real, true),
        ("symlink link.exe -> real-program.exe", &link, true),
        ("empty-ish text file notes.exe (extension-only verdict, not fixed here)", &text, true),
        ("missing.exe (does not exist)", &missing, false),
        ("noext (no extension; falls through to the stubbed GetBinaryTypeW)", &no_ext, false),
    ];
    let mut dir_verdict = None;
    for (name, path, expected) in cases.iter() {
        let got = windows_is_executable(path);
        println!("  {:<72} -> {:<5} (expected {})", name, got, expected);
        if *name == "directory named git.exe" {
            dir_verdict = Some(got);
        }
    }
    let _ = fs::remove_dir_all(&dir);
    match dir_verdict {
        Some(true) => println!("REPRODUCED: a directory named git.exe is judged executable by the Windows logic"),
        _ => {
            println!("NOT REPRODUCED: the directory is not judged executable");
            std::process::exit(1);
        }
    }
}

#!/usr/bin/env bash
# splice.sh <lib.rs> <harness.rs.in> <out.rs>
# Extract the Windows guard + PATHEXT block from the crate's src/lib.rs (from
# the "First, ensure that the file exists" comment up to the line before the
# "Check using file properties" comment), rename `self` to `path`, and put it
# at the @@CRATE_BODY@@ marker. Fails if the markers are not found exactly once.
set -euo pipefail
LIB=$1; IN=$2; OUT=$3
START=$(grep -n "// First, ensure that the file exists" "$LIB" | cut -d: -f1)
END=$(grep -n "// Check using file properties" "$LIB" | cut -d: -f1)
[[ $(echo "$START" | wc -l) -eq 1 && $(echo "$END" | wc -l) -eq 1 && -n "$START" && -n "$END" ]] || { echo "splice: markers not found exactly once in $LIB" >&2; exit 2; }
BODY=$(sed -n "$((START)),$((END - 1))p" "$LIB")
python3 - "$IN" "$OUT" "$BODY" <<'PY'
import re
import sys
src, out, body = sys.argv[1], sys.argv[2], sys.argv[3]
# `self.` -> `path.` (done here rather than in sed: `\b` is GNU-only)
body = re.sub(r"\bself\.", "path.", body)
s = open(src).read()
assert s.count("// @@CRATE_BODY@@") == 1
open(out, "w").write(s.replace("    // @@CRATE_BODY@@", body))
PY
echo "spliced lines $START-$((END - 1)) of $LIB into $OUT"