Implemented a CompilerVersion type to mimic the existing wrapper in swift_build_support and return a more detailed object from ClangVersionType and SwiftVersionType.

Author: Rostepher

utils/build_swift/argparse/__init__.py

@@ -23,8 +23,8 @@
 
 from .actions import Action, Nargs
 from .parser import ArgumentParser
-from .types import (BoolType, ClangVersionType, PathType, RegexType,
-                    ShellSplitType, SwiftVersionType)
+from .types import (BoolType, ClangVersionType, CompilerVersion, PathType,
+                    RegexType, ShellSplitType, SwiftVersionType)
 
 
 __all__ = [
@@ -39,6 +39,7 @@
     'RawDescriptionHelpFormatter',
     'RawTextHelpFormatter',
 
+    'CompilerVersion',
     'BoolType',
     'FileType',
     'PathType',

utils/build_swift/argparse/types.py

@@ -21,6 +21,8 @@
 
 
 __all__ = [
+    'CompilerVersion',
+
     'BoolType',
     'PathType',
     'RegexType',
@@ -32,6 +34,44 @@
 
 # -----------------------------------------------------------------------------
 
+class CompilerVersion(object):
+    """Wrapper type around compiler version strings.
+    """
+
+    def __init__(self, *components):
+        if len(components) == 1:
+            if isinstance(components[0], str):
+                components = components[0].split('.')
+            elif isinstance(components[0], list):
+                components = tuple(components[0])
+            elif isinstance(components[0], tuple):
+                components = components[0]
+
+        if len(components) == 0:
+            raise ValueError('compiler version cannot be empty')
+
+        self.components = tuple(int(part) for part in components)
+
+    def __eq__(self, other):
+        return self.components == other.components
+
+    def __str__(self):
+        return '.'.join([str(part) for part in self.components])
+
+
+# -----------------------------------------------------------------------------
+
+def _repr(cls, args):
+    """Helper function for implementing __repr__ methods on *Type classes.
+    """
+
+    _args = []
+    for key, value in args.viewitems():
+        _args.append('{}={}'.format(key, repr(value)))
+
+    return '{}({})'.format(type(cls).__name__, ', '.join(_args))
+
+
 class BoolType(object):
     """Argument type used to validate an input string as a bool-like type.
     Callers are able to override valid true and false values.
@@ -55,6 +95,12 @@ def __call__(self, value):
         else:
             raise ArgumentTypeError('{} is not a boolean value'.format(value))
 
+    def __repr__(self):
+        return _repr(self, {
+            'true_values': self._true_values,
+            'false_values': self._false_values,
+        })
+
 
 class PathType(object):
     """PathType denotes a valid path-like object. When called paths will be
@@ -63,25 +109,28 @@ class PathType(object):
     """
 
     def __init__(self, assert_exists=False, assert_executable=False):
-        if assert_executable:
-            assert_exists = True
-
-        self.assert_exists = assert_exists
-        self.assert_executable = assert_executable
+        self._assert_exists = assert_exists
+        self._assert_executable = assert_executable
 
     def __call__(self, path):
         path = os.path.expanduser(path)
         path = os.path.abspath(path)
         path = os.path.realpath(path)
 
-        if self.assert_exists and not os.path.exists(path):
+        if self._assert_exists and not os.path.exists(path):
             raise ArgumentTypeError('{} does not exists'.format(path))
 
-        if self.assert_executable and not PathType._is_executable(path):
+        if self._assert_executable and not PathType._is_executable(path):
             raise ArgumentTypeError('{} is not an executable'.format(path))
 
         return path
 
+    def __repr__(self):
+        return _repr(self, {
+            'assert_exists': self._assert_exists,
+            'assert_executable': self._assert_executable,
+        })
+
     @staticmethod
     def _is_executable(path):
         return os.path.isfile(path) and os.access(path, os.X_OK)
@@ -101,7 +150,13 @@ def __call__(self, value):
         if matches is None:
             raise ArgumentTypeError(self._error_message, value)
 
-        return value
+        return matches
+
+    def __repr__(self):
+        return _repr(self, {
+            'regex': self._regex,
+            'error_message': self._error_message,
+        })
 
 
 class ClangVersionType(RegexType):
@@ -118,6 +173,12 @@ def __init__(self):
             ClangVersionType.VERSION_REGEX,
             ClangVersionType.ERROR_MESSAGE)
 
+    def __call__(self, value):
+        matches = super(ClangVersionType, self).__call__(value)
+        components = filter(None, matches.group(1, 2, 3, 5))
+
+        return CompilerVersion(components)
+
 
 class SwiftVersionType(RegexType):
     """Argument type used to validate Swift version strings.
@@ -132,6 +193,12 @@ def __init__(self):
             SwiftVersionType.VERSION_REGEX,
             SwiftVersionType.ERROR_MESSAGE)
 
+    def __call__(self, value):
+        matches = super(SwiftVersionType, self).__call__(value)
+        components = filter(None, matches.group(1, 2, 4))
+
+        return CompilerVersion(components)
+
 
 class ShellSplitType(object):
     """Parse and split shell arguments into a list of strings. Recognizes `,`
@@ -151,3 +218,6 @@ def __call__(self, value):
         lex.whitespace_split = True
         lex.whitespace += ','
         return list(lex)
+
+    def __repr__(self):
+        return _repr(self, {})

utils/build_swift/defaults.py

@@ -6,10 +6,15 @@
 # See http://swift.org/LICENSE.txt for license information
 # See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
+
 """
 Default option value definitions.
 """
 
+
+from .argparse import CompilerVersion
+
+
 __all__ = [
     # Command line configuarable
     'BUILD_VARIANT',
@@ -35,8 +40,8 @@
 CMAKE_GENERATOR = 'Ninja'
 
 COMPILER_VENDOR = 'none'
-SWIFT_USER_VISIBLE_VERSION = '4.1'
-CLANG_USER_VISIBLE_VERSION = '5.0.0'
+SWIFT_USER_VISIBLE_VERSION = CompilerVersion('4.1')
+CLANG_USER_VISIBLE_VERSION = CompilerVersion('5.0.0')
 SWIFT_ANALYZE_CODE_COVERAGE = 'false'
 
 DARWIN_XCRUN_TOOLCHAIN = 'default'

utils/build_swift/tests/argparse/test_types.py

@@ -15,6 +15,66 @@
 
 # -----------------------------------------------------------------------------
 
+class TestCompilerVersion(TestCase):
+
+    def test_init_valid_value(self):
+        version = types.CompilerVersion(1, 0, 0, 1)
+        self.assertEqual(version.components, (1, 0, 0, 1))
+
+    def test_init_list(self):
+        version = types.CompilerVersion([1, 0, 0])
+        self.assertEqual(version.components, (1, 0, 0))
+
+        with self.assertNotRaises(ValueError):
+            types.CompilerVersion([1, 0])
+            types.CompilerVersion([2, 3, 4])
+            types.CompilerVersion([3, 1, 4, 1, 5, 9])
+
+    def test_init_tuple(self):
+        version = types.CompilerVersion((1, 0, 0))
+        self.assertEqual(version.components, (1, 0, 0))
+
+        with self.assertNotRaises(ValueError):
+            types.CompilerVersion((1, 0))
+            types.CompilerVersion((2, 3, 4))
+            types.CompilerVersion((3, 1, 4, 1, 5, 9))
+
+    def test_init_str(self):
+        version = types.CompilerVersion('1.0.0')
+        self.assertEqual(version.components, (1, 0, 0))
+
+        with self.assertNotRaises(ValueError):
+            types.CompilerVersion('1.0')
+            types.CompilerVersion('2.3.4')
+            types.CompilerVersion('3.1.4.1.5.9')
+
+    def test_init_invalid_value(self):
+        with self.assertRaises(ValueError):
+            types.CompilerVersion()
+            types.CompilerVersion([])
+            types.CompilerVersion(())
+            types.CompilerVersion('')
+            types.CompilerVersion(True)
+            types.CompilerVersion('a')
+            types.CompilerVersion(dict())
+
+    def test_eq(self):
+        v1 = types.CompilerVersion('1.0.0')
+        v2 = types.CompilerVersion('1.2.4.8')
+
+        self.assertEqual(v1, v1)
+        self.assertEqual(v2, v2)
+        self.assertNotEqual(v1, v2)
+        self.assertNotEqual(v2, v1)
+
+    def test_str(self):
+        version = types.CompilerVersion('1.0.0')
+        self.assertEqual(str(version), '1.0.0')
+
+        version = types.CompilerVersion('1.0.0.1')
+        self.assertEqual(str(version), '1.0.0.1')
+
+
 class TestBoolType(TestCase):
 
     def test_true_values(self):
@@ -100,8 +160,6 @@ def test_assert_exists(self):
     def test_assert_executable(self):
         path_type = types.PathType(assert_executable=True)
 
-        self.assertTrue(path_type.assert_exists)
-
         bash_path = '/bin/bash'
         if os.path.isfile(bash_path) and os.access(bash_path, os.X_OK):
             with self.assertNotRaises(ArgumentTypeError):
@@ -135,6 +193,14 @@ class TestClangVersionType(TestCase):
     def test_valid_clang_version(self):
         clang_version_type = types.ClangVersionType()
 
+        version = clang_version_type('1.0.0')
+        self.assertIsInstance(version, types.CompilerVersion)
+        self.assertEqual(version.components, (1, 0, 0))
+
+        version = clang_version_type('1.0.0.1')
+        self.assertIsInstance(version, types.CompilerVersion)
+        self.assertEqual(version.components, (1, 0, 0, 1))
+
         with self.assertNotRaises(ArgumentTypeError):
             clang_version_type('1.0.0')
             clang_version_type('3.0.2.1')
@@ -156,6 +222,14 @@ class TestSwiftVersionType(TestCase):
     def test_valid_swift_version(self):
         swift_version_type = types.SwiftVersionType()
 
+        version = swift_version_type('1.0')
+        self.assertIsInstance(version, types.CompilerVersion)
+        self.assertEqual(version.components, (1, 0))
+
+        version = swift_version_type('1.0.1')
+        self.assertIsInstance(version, types.CompilerVersion)
+        self.assertEqual(version.components, (1, 0, 1))
+
         with self.assertNotRaises(ArgumentTypeError):
             swift_version_type('1.0')
             swift_version_type('3.0.2')

utils/swift_build_support/swift_build_support/cmake.py

@@ -114,7 +114,8 @@ def common_options(self):
                    "Debug;Release;MinSizeRel;RelWithDebInfo")
 
         if args.clang_user_visible_version:
-            major, minor, patch, _ = args.clang_user_visible_version.components
+            major, minor, patch = \
+                args.clang_user_visible_version.components[0:3]
             define("LLVM_VERSION_MAJOR:STRING", major)
             define("LLVM_VERSION_MINOR:STRING", minor)
             define("LLVM_VERSION_PATCH:STRING", patch)