<DRAFT DO NOT COMMIT>

[DavidSpickett]

Summary

TODO: This would require packaging (https://github.com/pypa/packaging)

to be added as a third party module, it is not part of the base python.

[lldb] Use packaging.version instead of distutils Strict/LooseVersion

distutils is deprecated (https://peps.python.org/pep-0632/) and
packaging is the recommended replacement.

Although LegacyVersion is itself deprecated within packaging,
we have our own copy of the package so that's not a risk until it
needs updating.

[DavidSpickett]

For https://github.com/llvm/llvm-project/issues/54337.

lldb/packages/Python/lldbsuite/test/decorators.py

 from __future__ import absolute_import
 
 # System modules
-from distutils.version import LooseVersion
 from functools import wraps
 import ctypes
 import locale
 import os
 import platform
 import re
 import sys
 import tempfile
 import subprocess
 
 # Third-party modules
+from packaging.version import LegacyVersion
 import six
 import unittest2
 
 # LLDB modules
 import lldb
 from . import configuration
 from . import test_categories
 from . import lldbtest_config
op_lookup = {
         "<": fn_less,
         ">=": fn_geq,
         "<=": fn_leq
     }
     expected_str = '.'.join([str(x) for x in expected])
     actual_str = '.'.join([str(x) for x in actual])
 
     return op_lookup[comparison](
-        LooseVersion(actual_str),
-        LooseVersion(expected_str))
+        LegacyVersion(actual_str),
+        LegacyVersion(expected_str))
 
 
 _re_pattern_type = type(re.compile(''))
 def _match_decorator_property(expected, actual):
     if expected is None:
         return True
 
     if actual is None :

lldb/packages/Python/lldbsuite/test/lldbtest.py

 $
 """
 
 from __future__ import absolute_import
 from __future__ import print_function
 
 # System modules
 import abc
-from distutils.version import LooseVersion
 from functools import wraps
 import gc
 import glob
 import io
 import os.path
 import re
 import shutil
 import signal
 from subprocess import *
 import sys
 import time
 import traceback
 
 # Third-party modules
+from packaging.version import LegacyVersion
 import unittest2
 from six import add_metaclass
 from six import StringIO as SixStringIO
 import six
 
 # LLDB modules
 import lldb
 from . import configuration
def expectedCompilerVersion(self, compiler_version):
             return True
 
         test_compiler_version = self.getCompilerVersion()
         if test_compiler_version == 'unknown':
             # Assume the compiler version is at or near the top of trunk.
             return operator in ['>', '>=', '!', '!=', 'not']
 
         if operator == '>':
-            return LooseVersion(test_compiler_version) > LooseVersion(version)
+            return LegacyVersion(test_compiler_version) > LegacyVersion(version)
         if operator == '>=' or operator == '=>':
-            return LooseVersion(test_compiler_version) >= LooseVersion(version)
+            return LegacyVersion(test_compiler_version) >= LegacyVersion(version)
         if operator == '<':
-            return LooseVersion(test_compiler_version) < LooseVersion(version)
+            return LegacyVersion(test_compiler_version) < LegacyVersion(version)
         if operator == '<=' or operator == '=<':
-            return LooseVersion(test_compiler_version) <= LooseVersion(version)
+            return LegacyVersion(test_compiler_version) <= LegacyVersion(version)
         if operator == '!=' or operator == '!' or operator == 'not':
             return str(version) not in str(test_compiler_version)
         return str(version) in str(test_compiler_version)
 
     def expectedCompiler(self, compilers):
         """Returns True iff any element of compilers is a sub-string of the current compiler."""
         if (compilers is None):
             return True

lldb/test/API/tools/lldb-server/TestAppleSimulatorOSType.py

def check_simulator_ostype(self, sdk, platform_name, arch=platform.machine()):
 
         exe_name = 'test_simulator_platform_{}'.format(platform_name)
         sdkroot = lldbutil.get_xcode_sdk_root(sdk)
         vers = lldbutil.get_xcode_sdk_version(sdk)
         clang = lldbutil.get_xcode_clang(sdk)
 
         # Older versions of watchOS (<7.0) only support i386
         if platform_name == 'watchos':
-            from distutils.version import LooseVersion
-            if LooseVersion(vers) < LooseVersion("7.0"):
+            from packaging.version import LegacyVersion
+            if LegacyVersion(vers) < LegacyVersion("7.0"):
                 arch = 'i386'
 
         triple = '-'.join([arch, 'apple', platform_name + vers, 'simulator'])
         version_min = '-m{}-simulator-version-min={}'.format(platform_name, vers)
         self.build(
             dictionary={
                 'EXE': exe_name,
                 'CC': clang,

lldb/test/Shell/helper/build.py

def _get_vctools_version(self):
             return ver
 
         vcinstalldir = self._get_vc_install_dir()
         vcinstalldir = os.path.join(vcinstalldir, 'Tools', 'MSVC')
         subdirs = next(os.walk(vcinstalldir))[1]
         if not subdirs:
             return None
 
-        from distutils.version import StrictVersion
-        subdirs.sort(key=lambda x : StrictVersion(x))
+        from packaging.version import Version
+        subdirs.sort(key=lambda x : Version(x))
 
         if self.verbose:
             full_path = os.path.join(vcinstalldir, subdirs[-1])
             print('Using VC tools version directory {0} found by directory walk.'.format(full_path))
         return subdirs[-1]
 
     def _get_vctools_install_dir(self):
         dir = os.getenv('VCToolsInstallDir', None)
def _find_windows_sdk_in_registry_view(self, view):
                     sdk_versions.append(ver_key)
                     index = index + 1
                 except WindowsError:
                     break
             if not sdk_versions:
                 return (None, None)
 
             # Windows SDK version numbers consist of 4 dotted components, so we
-            # have to use LooseVersion, as StrictVersion supports 3 or fewer.
-            from distutils.version import LooseVersion
-            sdk_versions.sort(key=lambda x : LooseVersion(x), reverse=True)
+            # have to use LegacyVersion, as Version expects 3 or fewer.
+            from packaging.version import LegacyVersion
+            sdk_versions.sort(key=lambda x : LegacyVersion(x), reverse=True)
             option_value_name = 'OptionId.DesktopCPP' + self.msvc_arch_str
             for v in sdk_versions:
                 try:
                     version_subkey = v + r'\Installed Options'
                     key = winreg.OpenKey(roots_key, version_subkey)
                     installed_options_keys.append(key)
                     (value, value_type) = winreg.QueryValueEx(key, option_value_name)
                     if value == 1: