Merge lp:~jelmer/brz/3.3-walkdirs into lp:brz/3.3

[Jelmer Vernooij]

Drop the win32 specific walkdirs implementation

Drop the win32 specific walkdirs implementation

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2024-04-01 16:01:47 +0000
+++ .bzrignore	2024-04-02 23:21:37 +0000
@@ -65,7 +65,6 @@
 breezy/bzr/_simple_set_pyx.c
 breezy/bzr/_simple_set_pyx.h
 breezy/bzr/_simple_set_pyx_api.h
-breezy/_walkdirs_win32.c
 # built extension modules
 breezy/_*.dll
 breezy/_*.so

=== removed file 'breezy/_walkdirs_win32.pyx'
--- breezy/_walkdirs_win32.pyx	2023-01-31 01:05:40 +0000
+++ breezy/_walkdirs_win32.pyx	1970-01-01 00:00:00 +0000
@@ -1,303 +0,0 @@
-# Copyright (C) 2008-2012 Canonical Ltd
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-#
-# cython: language_level=3
-
-"""Helper functions for Walkdirs on win32."""
-
-
-cdef extern from "python-compat.h":
-    struct _HANDLE:
-        pass
-    ctypedef _HANDLE *HANDLE
-    ctypedef unsigned long DWORD
-    ctypedef long long __int64
-    ctypedef unsigned short WCHAR
-    struct _FILETIME:
-        DWORD dwHighDateTime
-        DWORD dwLowDateTime
-    ctypedef _FILETIME FILETIME
-
-    struct _WIN32_FIND_DATAW:
-        DWORD dwFileAttributes
-        FILETIME ftCreationTime
-        FILETIME ftLastAccessTime
-        FILETIME ftLastWriteTime
-        DWORD nFileSizeHigh
-        DWORD nFileSizeLow
-        # Some reserved stuff here
-        WCHAR cFileName[260] # MAX_PATH
-        WCHAR cAlternateFilename[14]
-
-    # We have to use the typedef trick, otherwise pyrex uses:
-    #  struct WIN32_FIND_DATAW
-    # which fails due to 'incomplete type'
-    ctypedef _WIN32_FIND_DATAW WIN32_FIND_DATAW
-
-    HANDLE INVALID_HANDLE_VALUE
-    HANDLE FindFirstFileW(WCHAR *path, WIN32_FIND_DATAW *data)
-    int FindNextFileW(HANDLE search, WIN32_FIND_DATAW *data)
-    int FindClose(HANDLE search)
-
-    DWORD FILE_ATTRIBUTE_READONLY
-    DWORD FILE_ATTRIBUTE_DIRECTORY
-    int ERROR_NO_MORE_FILES
-
-    int GetLastError()
-
-    # Wide character functions
-    DWORD wcslen(WCHAR *)
-
-
-cdef extern from "Python.h":
-    WCHAR *PyUnicode_AS_UNICODE(object)
-    Py_ssize_t PyUnicode_GET_SIZE(object)
-    object PyUnicode_FromUnicode(WCHAR *, Py_ssize_t)
-    int PyList_Append(object, object) except -1
-    object PyUnicode_AsUTF8String(object)
-
-
-import operator
-import os
-import stat
-
-from . import _readdir_py
-
-
-cdef object osutils
-osutils = None
-
-
-cdef class _Win32Stat:
-    """Represent a 'stat' result generated from WIN32_FIND_DATA"""
-
-    cdef readonly int st_mode
-    cdef readonly double st_ctime
-    cdef readonly double st_mtime
-    cdef readonly double st_atime
-    # We can't just declare this as 'readonly' because python2.4 doesn't define
-    # T_LONGLONG as a structure member. So instead we just use a property that
-    # will convert it correctly anyway.
-    cdef __int64 _st_size
-
-    property st_size:
-        def __get__(self):
-            return self._st_size
-
-    # os.stat always returns 0, so we hard code it here
-    property st_dev:
-        def __get__(self):
-            return 0
-    property st_ino:
-        def __get__(self):
-            return 0
-    # st_uid and st_gid required for some external tools like bzr-git & dulwich
-    property st_uid:
-        def __get__(self):
-            return 0
-    property st_gid:
-        def __get__(self):
-            return 0
-
-    def __repr__(self):
-        """Repr is the same as a Stat object.
-
-        (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
-        """
-        return repr((self.st_mode, 0, 0, 0, 0, 0, self.st_size, self.st_atime,
-                     self.st_mtime, self.st_ctime))
-
-
-cdef object _get_name(WIN32_FIND_DATAW *data):
-    """Extract the Unicode name for this file/dir."""
-    return PyUnicode_FromUnicode(data.cFileName,
-                                 wcslen(data.cFileName))
-
-
-cdef int _get_mode_bits(WIN32_FIND_DATAW *data): # cannot_raise
-    cdef int mode_bits
-
-    mode_bits = 0100666 # writeable file, the most common
-    if data.dwFileAttributes & FILE_ATTRIBUTE_READONLY == FILE_ATTRIBUTE_READONLY:
-        mode_bits = mode_bits ^ 0222 # remove the write bits
-    if data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY == FILE_ATTRIBUTE_DIRECTORY:
-        # Remove the FILE bit, set the DIR bit, and set the EXEC bits
-        mode_bits = mode_bits ^ 0140111
-    return mode_bits
-
-
-cdef __int64 _get_size(WIN32_FIND_DATAW *data): # cannot_raise
-    # Pyrex casts a DWORD into a PyLong anyway, so it is safe to do << 32
-    # on a DWORD
-    return ((<__int64>data.nFileSizeHigh) << 32) + data.nFileSizeLow
-
-
-cdef double _ftime_to_timestamp(FILETIME *ft): # cannot_raise
-    """Convert from a FILETIME struct into a floating point timestamp.
-
-    The fields of a FILETIME structure are the hi and lo part
-    of a 64-bit value expressed in 100 nanosecond units.
-    1e7 is one second in such units; 1e-7 the inverse.
-    429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
-    It also uses the epoch 1601-01-01 rather than 1970-01-01
-    (taken from posixmodule.c)
-    """
-    cdef __int64 val
-    # NB: This gives slightly different results versus casting to a 64-bit
-    #     integer and doing integer math before casting into a floating
-    #     point number. But the difference is in the sub millisecond range,
-    #     which doesn't seem critical here.
-    # secs between epochs: 11,644,473,600
-    val = ((<__int64>ft.dwHighDateTime) << 32) + ft.dwLowDateTime
-    return (val * 1.0e-7) - 11644473600.0
-
-
-cdef int _should_skip(WIN32_FIND_DATAW *data): # cannot_raise
-    """Is this '.' or '..' so we should skip it?"""
-    if (data.cFileName[0] != c'.'):
-        return 0
-    if data.cFileName[1] == c'\0':
-        return 1
-    if data.cFileName[1] == c'.' and data.cFileName[2] == c'\0':
-        return 1
-    return 0
-
-
-cdef class Win32ReadDir:
-    """Read directories on win32."""
-
-    cdef object _directory_kind
-    cdef object _file_kind
-
-    def __init__(self):
-        self._directory_kind = _readdir_py._directory
-        self._file_kind = _readdir_py._file
-
-    def top_prefix_to_starting_dir(self, top, prefix=""):
-        """See DirReader.top_prefix_to_starting_dir."""
-        global osutils
-        if osutils is None:
-            from . import osutils
-        return (osutils.safe_utf8(prefix), None, None, None,
-                osutils.safe_unicode(top))
-
-    cdef object _get_kind(self, WIN32_FIND_DATAW *data):
-        if data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY:
-            return self._directory_kind
-        return self._file_kind
-
-    cdef _Win32Stat _get_stat_value(self, WIN32_FIND_DATAW *data):
-        """Get the filename and the stat information."""
-        cdef _Win32Stat statvalue
-
-        statvalue = _Win32Stat()
-        statvalue.st_mode = _get_mode_bits(data)
-        statvalue.st_ctime = _ftime_to_timestamp(&data.ftCreationTime)
-        statvalue.st_mtime = _ftime_to_timestamp(&data.ftLastWriteTime)
-        statvalue.st_atime = _ftime_to_timestamp(&data.ftLastAccessTime)
-        statvalue._st_size = _get_size(data)
-        return statvalue
-
-    def read_dir(self, prefix, top):
-        """Win32 implementation of DirReader.read_dir.
-
-        :seealso: DirReader.read_dir
-        """
-        cdef WIN32_FIND_DATAW search_data
-        cdef HANDLE hFindFile
-        cdef int last_err
-        cdef WCHAR *query
-        cdef int result
-
-        if prefix:
-            relprefix = prefix + '/'
-        else:
-            relprefix = ''
-        top_slash = top + '/'
-
-        top_star = top_slash + '*'
-
-        dirblock = []
-
-        query = PyUnicode_AS_UNICODE(top_star)
-        hFindFile = FindFirstFileW(query, &search_data)
-        if hFindFile == INVALID_HANDLE_VALUE:
-            # Raise an exception? This path doesn't seem to exist
-            raise WindowsError(GetLastError(), top_star)
-
-        try:
-            result = 1
-            while result:
-                # Skip '.' and '..'
-                if _should_skip(&search_data):
-                    result = FindNextFileW(hFindFile, &search_data)
-                    continue
-                name_unicode = _get_name(&search_data)
-                name_utf8 = PyUnicode_AsUTF8String(name_unicode)
-                PyList_Append(dirblock,
-                    (relprefix + name_utf8, name_utf8,
-                     self._get_kind(&search_data),
-                     self._get_stat_value(&search_data),
-                     top_slash + name_unicode))
-
-                result = FindNextFileW(hFindFile, &search_data)
-            # FindNextFileW sets GetLastError() == ERROR_NO_MORE_FILES when it
-            # actually finishes. If we have anything else, then we have a
-            # genuine problem
-            last_err = GetLastError()
-            if last_err != ERROR_NO_MORE_FILES:
-                raise WindowsError(last_err)
-        finally:
-            result = FindClose(hFindFile)
-            if result == 0:
-                last_err = GetLastError()
-                # TODO: We should probably raise an exception if FindClose
-                #       returns an error, however, I don't want to supress an
-                #       earlier Exception, so for now, I'm ignoring this
-        dirblock.sort(key=operator.itemgetter(1))
-        return dirblock
-
-
-def lstat(path):
-    """Equivalent to os.lstat, except match Win32ReadDir._get_stat_value.
-    """
-    return wrap_stat(os.lstat(path))
-
-
-def fstat(fd):
-    """Like os.fstat, except match Win32ReadDir._get_stat_value
-
-    :seealso: wrap_stat
-    """
-    return wrap_stat(os.fstat(fd))
-
-
-def wrap_stat(st):
-    """Return a _Win32Stat object, based on the given stat result.
-
-    On Windows, os.fstat(open(fname).fileno()) != os.lstat(fname). This is
-    generally because os.lstat and os.fstat differ in what they put into st_ino
-    and st_dev. What gets set where seems to also be dependent on the python
-    version. So we always set it to 0 to avoid worrying about it.
-    """
-    cdef _Win32Stat statvalue
-    statvalue = _Win32Stat()
-    statvalue.st_mode = st.st_mode
-    statvalue.st_ctime = st.st_ctime
-    statvalue.st_mtime = st.st_mtime
-    statvalue.st_atime = st.st_atime
-    statvalue._st_size = st.st_size
-    return statvalue

=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2024-04-01 18:20:12 +0000
+++ breezy/osutils.py	2024-04-02 23:21:37 +0000
@@ -408,14 +408,6 @@
     normpath = _win32_normpath
     getcwd = _win32_getcwd
     rename = _rename_wrap_exception(_win32_rename)
-    try:
-        from . import _walkdirs_win32
-    except ImportError:
-        pass
-    else:
-        lstat = _walkdirs_win32.lstat
-        fstat = _walkdirs_win32.fstat
-        wrap_stat = _walkdirs_win32.wrap_stat
 
     MIN_ABS_PATHLENGTH = 3
 
@@ -1728,11 +1720,7 @@
         if fs_enc is None:
             fs_enc = sys.getfilesystemencoding()
         if sys.platform == "win32":
-            try:
-                from ._walkdirs_win32 import Win32ReadDir
-                _selected_dir_reader = Win32ReadDir()
-            except ImportError:
-                pass
+            pass
         elif fs_enc in ('utf-8', 'ascii'):
             try:
                 from ._readdir_pyx import UTF8DirReader

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2023-03-31 16:38:48 +0000
+++ breezy/tests/__init__.py	2024-04-02 23:21:37 +0000
@@ -3972,7 +3972,6 @@
         'breezy.tests.per_workingtree',
         'breezy.tests.test__annotator',
         'breezy.tests.test__known_graph',
-        'breezy.tests.test__walkdirs_win32',
         'breezy.tests.test_ancestry',
         'breezy.tests.test_annotate',
         'breezy.tests.test_atomicfile',

=== removed file 'breezy/tests/test__walkdirs_win32.py'
--- breezy/tests/test__walkdirs_win32.py	2023-01-31 01:05:40 +0000
+++ breezy/tests/test__walkdirs_win32.py	1970-01-01 00:00:00 +0000
@@ -1,111 +0,0 @@
-# Copyright (C) 2008, 2009, 2010 Canonical Ltd
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-"""Tests for the win32 walkdir extension."""
-
-import errno
-
-from .. import osutils, tests
-from . import features
-
-win32_readdir_feature = features.ModuleAvailableFeature(
-    'breezy._walkdirs_win32')
-
-
-class TestWin32Finder(tests.TestCaseInTempDir):
-
-    _test_needs_features = [win32_readdir_feature]
-
-    def setUp(self):
-        super().setUp()
-        from ._walkdirs_win32 import Win32ReadDir
-        self.reader = Win32ReadDir()
-
-    def _remove_stat_from_dirblock(self, dirblock):
-        return [info[:3] + info[4:] for info in dirblock]
-
-    def assertWalkdirs(self, expected, top, prefix=''):
-        old_selected_dir_reader = osutils._selected_dir_reader
-        try:
-            osutils._selected_dir_reader = self.reader
-            finder = osutils._walkdirs_utf8(top, prefix=prefix)
-            result = []
-            for dirname, dirblock in finder:
-                dirblock = self._remove_stat_from_dirblock(dirblock)
-                result.append((dirname, dirblock))
-            self.assertEqual(expected, result)
-        finally:
-            osutils._selected_dir_reader = old_selected_dir_reader
-
-    def assertReadDir(self, expected, prefix, top_unicode):
-        result = self._remove_stat_from_dirblock(
-            self.reader.read_dir(prefix, top_unicode))
-        self.assertEqual(expected, result)
-
-    def test_top_prefix_to_starting_dir(self):
-        # preparing an iteration should create a unicode native path.
-        self.assertEqual(
-            ('prefix', None, None, None, '\x12'),
-            self.reader.top_prefix_to_starting_dir(
-                '\x12'.encode(), 'prefix'))
-
-    def test_empty_directory(self):
-        self.assertReadDir([], 'prefix', '.')
-        self.assertWalkdirs([(('', '.'), [])], '.')
-
-    def test_file(self):
-        self.build_tree(['foo'])
-        self.assertReadDir([('foo', 'foo', 'file', './foo')],
-                           '', '.')
-
-    def test_directory(self):
-        self.build_tree(['bar/'])
-        self.assertReadDir([('bar', 'bar', 'directory', './bar')],
-                           '', '.')
-
-    def test_prefix(self):
-        self.build_tree(['bar/', 'baf'])
-        self.assertReadDir([
-            ('xxx/baf', 'baf', 'file', './baf'),
-            ('xxx/bar', 'bar', 'directory', './bar'),
-            ],
-            'xxx', '.')
-
-    def test_missing_dir(self):
-        e = self.assertRaises(WindowsError,
-                              self.reader.read_dir, 'prefix', 'no_such_dir')
-        self.assertEqual(errno.ENOENT, e.errno)
-        self.assertEqual(3, e.winerror)
-        self.assertEqual((3, 'no_such_dir/*'), e.args)
-
-
-class Test_Win32Stat(tests.TestCaseInTempDir):
-
-    _test_needs_features = [win32_readdir_feature]
-
-    def setUp(self):
-        super().setUp()
-        from ._walkdirs_win32 import lstat
-        self.win32_lstat = lstat
-
-    def test_zero_members_present(self):
-        self.build_tree(['foo'])
-        st = self.win32_lstat('foo')
-        # we only want to ensure that some members are present
-        self.assertEqual(0, st.st_dev)
-        self.assertEqual(0, st.st_ino)
-        self.assertEqual(0, st.st_uid)
-        self.assertEqual(0, st.st_gid)

=== modified file 'breezy/tests/test_osutils.py'
--- breezy/tests/test_osutils.py	2023-01-31 01:05:40 +0000
+++ breezy/tests/test_osutils.py	2024-04-02 23:21:37 +0000
@@ -26,7 +26,7 @@
 from io import BytesIO
 
 from .. import errors, osutils, tests, trace, win32utils
-from . import features, file_utils, test__walkdirs_win32
+from . import features, file_utils
 from .scenarios import load_tests_apply_scenarios
 
 
@@ -73,15 +73,6 @@
                           dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
                                _native_to_unicode=_utf8_to_unicode)))
 
-    if test__walkdirs_win32.win32_readdir_feature.available():
-        try:
-            from .. import _walkdirs_win32
-            scenarios.append(
-                ('win32',
-                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
-                      _native_to_unicode=_already_unicode)))
-        except ModuleNotFoundError:
-            pass
     return scenarios
 
 
@@ -235,10 +226,7 @@
         # 'st_ino' and 'st_dev' fields. So we force them to be '0' in our
         # custom implementation.
         if sys.platform == 'win32':
-            # We only have special lstat/fstat if we have the extension.
-            # Without it, we may end up re-reading content when we don't have
-            # to, but otherwise it doesn't effect correctness.
-            self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
+            self.skipTest('lstat and fstat do not match on Windows')
         with open('test-file.txt', 'wb') as f:
             f.write(b'some content\n')
             f.flush()
@@ -1242,13 +1230,6 @@
         self._save_platform_info()
         self.assertDirReaderIs(osutils.UnicodeDirReader, ".", fs_enc='iso-8859-1')
 
-    def test_force_walkdirs_utf8_nt(self):
-        # Disabled because the thunk of the whole walkdirs api is disabled.
-        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
-        self._save_platform_info()
-        from .._walkdirs_win32 import Win32ReadDir
-        self.assertDirReaderIs(Win32ReadDir, ".")
-
     def test_unicode_walkdirs(self):
         """Walkdirs should always return unicode paths."""
         self.requireFeature(features.UnicodeFilenameFeature)
@@ -1400,52 +1381,6 @@
         self._filter_out_stat(result)
         self.assertEqual(expected_dirblocks, result)
 
-    def test__walkdirs_utf8_win32readdir(self):
-        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
-        self.requireFeature(features.UnicodeFilenameFeature)
-        from .._walkdirs_win32 import Win32ReadDir
-        self._save_platform_info()
-        osutils._selected_dir_reader = Win32ReadDir()
-        name0u = '0file-\xb6'
-        name1u = '1dir-\u062c\u0648'
-        name2u = '2file-\u0633'
-        tree = [
-            name0u,
-            name1u + '/',
-            name1u + '/' + name0u,
-            name1u + '/' + name1u + '/',
-            name2u,
-            ]
-        self.build_tree(tree)
-        name0 = name0u.encode('utf8')
-        name1 = name1u.encode('utf8')
-        name2 = name2u.encode('utf8')
-
-        # All of the abspaths should be in unicode, all of the relative paths
-        # should be in utf8
-        expected_dirblocks = [
-            (('', '.'),
-             [(name0, name0, 'file', './' + name0u),
-              (name1, name1, 'directory', './' + name1u),
-              (name2, name2, 'file', './' + name2u),
-              ]
-             ),
-            ((name1, './' + name1u),
-             [(name1 + '/' + name0, name0, 'file', './' + name1u
-               + '/' + name0u),
-              (name1 + '/' + name1, name1, 'directory', './' + name1u
-               + '/' + name1u),
-              ]
-             ),
-            ((name1 + '/' + name1, './' + name1u + '/' + name1u),
-             [
-                ]
-             ),
-            ]
-        result = list(osutils._walkdirs_utf8('.'))
-        self._filter_out_stat(result)
-        self.assertEqual(expected_dirblocks, result)
-
     def assertStatIsCorrect(self, path, win32stat):
         os_stat = os.stat(path)
         self.assertEqual(os_stat.st_size, win32stat.st_size)
@@ -1456,42 +1391,6 @@
         self.assertEqual(os_stat.st_ino, win32stat.st_ino)
         self.assertEqual(os_stat.st_mode, win32stat.st_mode)
 
-    def test__walkdirs_utf_win32_find_file_stat_file(self):
-        """make sure our Stat values are valid"""
-        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
-        self.requireFeature(features.UnicodeFilenameFeature)
-        from .._walkdirs_win32 import Win32ReadDir
-        name0u = '0file-\xb6'
-        name0 = name0u.encode('utf8')
-        self.build_tree([name0u])
-        # I hate to sleep() here, but I'm trying to make the ctime different
-        # from the mtime
-        time.sleep(2)
-        with open(name0u, 'ab') as f:
-            f.write(b'just a small update')
-
-        result = Win32ReadDir().read_dir('', '.')
-        entry = result[0]
-        self.assertEqual((name0, name0, 'file'), entry[:3])
-        self.assertEqual('./' + name0u, entry[4])
-        self.assertStatIsCorrect(entry[4], entry[3])
-        self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
-
-    def test__walkdirs_utf_win32_find_file_stat_directory(self):
-        """make sure our Stat values are valid"""
-        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
-        self.requireFeature(features.UnicodeFilenameFeature)
-        from .._walkdirs_win32 import Win32ReadDir
-        name0u = '0dir-\u062c\u0648'
-        name0 = name0u.encode('utf8')
-        self.build_tree([name0u + '/'])
-
-        result = Win32ReadDir().read_dir('', '.')
-        entry = result[0]
-        self.assertEqual((name0, name0, 'directory'), entry[:3])
-        self.assertEqual('./' + name0u, entry[4])
-        self.assertStatIsCorrect(entry[4], entry[3])
-
     def assertPathCompare(self, path_less, path_greater):
         """check that path_less and path_greater compare correctly."""
         self.assertEqual(0, osutils.compare_paths_prefix_order(

=== modified file 'setup.py'
--- setup.py	2023-09-04 11:06:40 +0000
+++ setup.py	2024-04-02 23:21:37 +0000
@@ -172,7 +172,6 @@
 if sys.platform == 'win32':
     add_cython_extension('breezy.bzr._dirstate_helpers_pyx',
                          libraries=['Ws2_32'])
-    add_cython_extension('breezy._walkdirs_win32')
 else:
     add_cython_extension('breezy.bzr._dirstate_helpers_pyx')
     add_cython_extension('breezy._readdir_pyx')