gh-117841: Add C implementation of ntpath.lexists

Lib/ntpath.py

@@ -910,13 +910,14 @@ def commonpath(paths):
 
 
 try:
-    # The isdir(), isfile(), islink() and exists() implementations in
-    # genericpath use os.stat(). This is overkill on Windows. Use simpler
+    # The isdir(), isfile(), islink(), exists() and lexists() implementations
+    # in genericpath use os.stat(). This is overkill on Windows. Use simpler
     # builtin functions if they are available.
     from nt import _path_isdir as isdir
     from nt import _path_isfile as isfile
     from nt import _path_islink as islink
     from nt import _path_exists as exists
+    from nt import _path_lexists as lexists
 except ImportError:
     # Use genericpath.* as imported above
     pass

Lib/test/test_genericpath.py

@@ -135,6 +135,9 @@ def test_exists(self):
         self.assertIs(self.pathmodule.exists(filename), False)
         self.assertIs(self.pathmodule.exists(bfilename), False)
 
+        self.assertIs(self.pathmodule.lexists(filename), False)
+        self.assertIs(self.pathmodule.lexists(bfilename), False)
+
         create_file(filename)
 
         self.assertIs(self.pathmodule.exists(filename), True)
@@ -145,14 +148,13 @@ def test_exists(self):
         self.assertIs(self.pathmodule.exists(filename + '\x00'), False)
         self.assertIs(self.pathmodule.exists(bfilename + b'\x00'), False)
 
-        if self.pathmodule is not genericpath:
-            self.assertIs(self.pathmodule.lexists(filename), True)
-            self.assertIs(self.pathmodule.lexists(bfilename), True)
+        self.assertIs(self.pathmodule.lexists(filename), True)
+        self.assertIs(self.pathmodule.lexists(bfilename), True)
 
-            self.assertIs(self.pathmodule.lexists(filename + '\udfff'), False)
-            self.assertIs(self.pathmodule.lexists(bfilename + b'\xff'), False)
-            self.assertIs(self.pathmodule.lexists(filename + '\x00'), False)
-            self.assertIs(self.pathmodule.lexists(bfilename + b'\x00'), False)
+        self.assertIs(self.pathmodule.lexists(filename + '\udfff'), False)
+        self.assertIs(self.pathmodule.lexists(bfilename + b'\xff'), False)
+        self.assertIs(self.pathmodule.lexists(filename + '\x00'), False)
+        self.assertIs(self.pathmodule.lexists(bfilename + b'\x00'), False)
 
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     @unittest.skipIf(is_emscripten, "Emscripten pipe fds have no stat")

Lib/test/test_ntpath.py

@@ -1116,6 +1116,8 @@ def test_fast_paths_in_use(self):
         self.assertFalse(inspect.isfunction(os.path.islink))
         self.assertTrue(os.path.exists is nt._path_exists)
         self.assertFalse(inspect.isfunction(os.path.exists))
+        self.assertTrue(os.path.lexists is nt._path_lexists)
+        self.assertFalse(inspect.isfunction(os.path.lexists))
 
     @unittest.skipIf(os.name != 'nt', "Dev Drives only exist on Win32")
     def test_isdevdrive(self):

Misc/NEWS.d/next/Core and Builtins/2024-04-13-11-30-09.gh-issue-117841.eW4w_y.rst

@@ -0,0 +1 @@
+Speedup :func:`os.path.lexists` on Windows with a native implementation.

Modules/posixmodule.c

@@ -5280,25 +5280,13 @@ os__path_isfile_impl(PyObject *module, PyObject *path)
 }
 
 
-/*[clinic input]
-os._path_exists
-
-    path: 'O'
-
-Test whether a path exists.  Returns False for broken symbolic links
-
-[clinic start generated code]*/
-
 static PyObject *
-os__path_exists_impl(PyObject *module, PyObject *path)
-/*[clinic end generated code: output=f508c3b35e13a249 input=380f77cdfa0f7ae8]*/
+nt_exists(PyObject *path, int follow_symlinks)
 {
-    HANDLE hfile;
-    BOOL close_file = TRUE;
     path_t _path = PATH_T_INITIALIZE("exists", "path", 0, 1);
-    int result;
-    BOOL slow_path = TRUE;
-    FILE_STAT_BASIC_INFORMATION statInfo;
+    HANDLE hfile;
+    BOOL traverse = follow_symlinks;
+    int result = 0;
 
     if (!path_converter(path, &_path)) {
         path_cleanup(&_path);
@@ -5310,49 +5298,95 @@ os__path_exists_impl(PyObject *module, PyObject *path)
     }
 
     Py_BEGIN_ALLOW_THREADS
-    if (_path.wide) {
+    if (_path.fd != -1) {
+        hfile = _Py_get_osfhandle_noraise(_path.fd);
+        if (hfile != INVALID_HANDLE_VALUE) {
+            result = 1;
+        }
+    }
+    else if (_path.wide) {
+        BOOL slow_path = TRUE;
+        FILE_STAT_BASIC_INFORMATION statInfo;
         if (_Py_GetFileInformationByName(_path.wide, FileStatBasicByNameInfo,
-                                         &statInfo, sizeof(statInfo))) {
-            if (!(statInfo.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
+                &statInfo, sizeof(statInfo)))
+        {
+            if (!(statInfo.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) ||
+                !follow_symlinks &&
+                IsReparseTagNameSurrogate(statInfo.ReparseTag))
+            {
                 slow_path = FALSE;
                 result = 1;
             }
-        } else if (_Py_GetFileInformationByName_ErrorIsTrustworthy(GetLastError())) {
-                    slow_path = FALSE;
-                    result = 0;
-        }
-    }
-    if (slow_path) {
-        if (_path.fd != -1) {
-            hfile = _Py_get_osfhandle_noraise(_path.fd);
-            close_file = FALSE;
-        }
-        else {
-            hfile = CreateFileW(_path.wide, FILE_READ_ATTRIBUTES, 0, NULL,
-                                OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
-        }
-        if (hfile != INVALID_HANDLE_VALUE) {
-            result = 1;
-            if (close_file) {
-                CloseHandle(hfile);
+            else {
+                // reparse point but not name-surrogate
+                traverse = TRUE;
             }
         }
-        else {
-            STRUCT_STAT st;
-            switch (GetLastError()) {
-            case ERROR_ACCESS_DENIED:
-            case ERROR_SHARING_VIOLATION:
-            case ERROR_CANT_ACCESS_FILE:
-            case ERROR_INVALID_PARAMETER:
-                if (STAT(_path.wide, &st)) {
-                    result = 0;
+        else if (_Py_GetFileInformationByName_ErrorIsTrustworthy(
+                        GetLastError()))
+        {
+            slow_path = FALSE;
+        }
+        if (slow_path) {
+            BOOL traverse = follow_symlinks;
+            if (!traverse) {
+                hfile = CreateFileW(_path.wide, FILE_READ_ATTRIBUTES, 0, NULL,
+                            OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT |
+                            FILE_FLAG_BACKUP_SEMANTICS, NULL);
+                if (hfile != INVALID_HANDLE_VALUE) {
+                    FILE_ATTRIBUTE_TAG_INFO info;
+                    if (GetFileInformationByHandleEx(hfile,
+                            FileAttributeTagInfo, &info, sizeof(info)))
+                    {
+                        if (!(info.FileAttributes &
+                                FILE_ATTRIBUTE_REPARSE_POINT) ||
+                            IsReparseTagNameSurrogate(info.ReparseTag))
+                        {
+                            result = 1;
+                        }
+                        else {
+                            // reparse point but not name-surrogate
+                            traverse = TRUE;
+                        }
+                    }
+                    else {
+                        // device or legacy filesystem
+                        result = 1;
+                    }
+                    CloseHandle(hfile);
                 }
                 else {
+                    STRUCT_STAT st;
+                    switch (GetLastError()) {
+                    case ERROR_ACCESS_DENIED:
+                    case ERROR_SHARING_VIOLATION:
+                    case ERROR_CANT_ACCESS_FILE:
+                    case ERROR_INVALID_PARAMETER:
+                        if (!LSTAT(_path.wide, &st)) {
+                            result = 1;
+                        }
+                    }
+                }
+            }
+            if (traverse) {
+                hfile = CreateFileW(_path.wide, FILE_READ_ATTRIBUTES, 0, NULL,
+                            OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+                if (hfile != INVALID_HANDLE_VALUE) {
+                    CloseHandle(hfile);
                     result = 1;
                 }
-                break;
-            default:
-                result = 0;
+                else {
+                    STRUCT_STAT st;
+                    switch (GetLastError()) {
+                    case ERROR_ACCESS_DENIED:
+                    case ERROR_SHARING_VIOLATION:
+                    case ERROR_CANT_ACCESS_FILE:
+                    case ERROR_INVALID_PARAMETER:
+                        if (!STAT(_path.wide, &st)) {
+                            result = 1;
+                        }
+                    }
+                }
             }
         }
     }
@@ -5366,6 +5400,42 @@ os__path_exists_impl(PyObject *module, PyObject *path)
 }
 
 
+/*[clinic input]
+os._path_exists
+
+    path: object
+    /
+
+Test whether a path exists.  Returns False for broken symbolic links.
+
+[clinic start generated code]*/
+
+static PyObject *
+os__path_exists(PyObject *module, PyObject *path)
+/*[clinic end generated code: output=617b7575ba0644bc input=242708cabb67c407]*/
+{
+    return nt_exists(path, 1);
+}
+
+
+/*[clinic input]
+os._path_lexists
+
+    path: object
+    /
+
+Test whether a path exists.  Returns True for broken symbolic links.
+
+[clinic start generated code]*/
+
+static PyObject *
+os__path_lexists(PyObject *module, PyObject *path)
+/*[clinic end generated code: output=c7c89aa6d6e341df input=536ed4b0a7d4f723]*/
+{
+    return nt_exists(path, 0);
+}
+
+
 /*[clinic input]
 os._path_islink
 
@@ -16887,6 +16957,7 @@ static PyMethodDef posix_methods[] = {
     OS__PATH_ISFILE_METHODDEF
     OS__PATH_ISLINK_METHODDEF
     OS__PATH_EXISTS_METHODDEF
+    OS__PATH_LEXISTS_METHODDEF
 
     OS__SUPPORTS_VIRTUAL_TERMINAL_METHODDEF
     {NULL,              NULL}            /* Sentinel */