fix long-standing linting problems

Author: mattip

mesonbuild/build.py

@@ -1473,7 +1473,6 @@ def link_whole(self, targets: T.List[BuildTargetTypes], promoted: bool = False)
                 msg = f"Can't link non-PIC static library {t.name!r} into shared library {self.name!r}. "
                 msg += "Use the 'pic' option to static_library to build with PIC."
                 raise InvalidArguments(msg)
-
             self.check_can_link_together(t)
             if isinstance(self, StaticLibrary):
                 # When we're a static library and we link_whole: to another static
@@ -1495,29 +1494,11 @@ def get_internal_static_libraries(self) -> OrderedSet[BuildTargetTypes]:
     def get_internal_static_libraries_recurse(self, result: OrderedSet[BuildTargetTypes]) -> None:
         for t in self.link_targets:
             if t.is_internal() and t not in result:
-                self.check_can_extract_objects(t, origin, promoted=True)
                 result.add(t)
-                t.get_internal_static_libraries_recurse(result, origin)
+                t.get_internal_static_libraries_recurse(result)
         for t in self.link_whole_targets:
             if t.is_internal():
-                t.get_internal_static_libraries_recurse(result, origin)
-
-    def check_can_extract_objects(self, t: T.Union[Target, CustomTargetIndex], origin: StaticLibrary, promoted: bool = False) -> None:
-        if isinstance(t, (CustomTarget, CustomTargetIndex)) or t.uses_rust():
-            # To extract objects from a custom target we would have to extract
-            # the archive, WIP implementation can be found in
-            # https://github.com/mesonbuild/meson/pull/9218.
-            # For Rust C ABI we could in theory have access to objects, but there
-            # are several meson issues that need to be fixed:
-            # https://github.com/mesonbuild/meson/issues/10722
-            # https://github.com/mesonbuild/meson/issues/10723
-            # https://github.com/mesonbuild/meson/issues/10724
-            m = (f'Cannot link_whole a custom or Rust target {t.name!r} into a static library {origin.name!r}. '
-                 'Instead, pass individual object files with the "objects:" keyword argument if possible.')
-            if promoted:
-                m += (f' Meson had to promote link to link_whole because {origin.name!r} is installed but not {t.name!r},'
-                      f' and thus has to include objects from {t.name!r} to be usable.')
-            raise InvalidArguments(m)
+                t.get_internal_static_libraries_recurse(result)
 
     def _bundle_static_library(self, t: T.Union[BuildTargetTypes], promoted: bool = False) -> None:
         if self.uses_rust():

mesonbuild/dependencies/__init__.py

@@ -7,7 +7,6 @@
         ExternalLibrary, DependencyException, DependencyMethods,
         BuiltinDependency, SystemDependency, get_leaf_external_dependencies)
 from .detect import find_external_dependency, get_dep_identifier, packages, _packages_accept_language
-from .blas_lapack import openblas_factory
 
 
 __all__ = [

mesonbuild/dependencies/blas_lapack.py

@@ -26,14 +26,15 @@
 from ..mesonlib import MachineChoice
 from ..options import OptionKey
 
-from .base import DependencyMethods, SystemDependency
+from .base import DependencyMethods, SystemDependency, DependencyException
 from .cmake import CMakeDependency
 from .detect import packages
 from .factory import DependencyFactory, factory_methods
 from .pkgconfig import PkgConfigDependency
 
 if T.TYPE_CHECKING:
     from ..environment import Environment
+    from . factory import DependencyGenerator
 
 """
 TODO: how to select BLAS interface layer (LP64, ILP64)?
@@ -303,7 +304,7 @@
 """
 
 
-def check_blas_machine_file(self, name: str, props: dict) -> T.Tuple[bool, T.List[str]]:
+def check_blas_machine_file(name: str, props: dict) -> T.Tuple[bool, T.List[str]]:
     # TBD: do we need to support multiple extra dirs?
     incdir = props.get(f'{name}_includedir')
     assert incdir is None or isinstance(incdir, str)
@@ -364,11 +365,11 @@ def check_symbols(self, compile_args, suffix=None, check_cblas=True,
         prototypes = "".join(f"void {symbol}{suffix}();\n" for symbol in symbols)
         calls = "  ".join(f"{symbol}{suffix}();\n" for symbol in symbols)
         code = (f"{prototypes}"
-                 "int main(int argc, const char *argv[])\n"
-                 "{\n"
+                "int main(int argc, const char *argv[])\n"
+                "{\n"
                 f"  {calls}"
-                 "  return 0;\n"
-                 "}"
+                "  return 0;\n"
+                "}"
                 )
         code = '''#ifdef __cplusplus
                extern "C" {
@@ -720,7 +721,6 @@ def detect_lapack_machine_file(self, props: dict) -> None:
             self.detect([libdir], [incdir])
 
 
-
 class AccelerateSystemDependency(BLASLAPACKMixin, SystemDependency):
     """
     Accelerate is always installed on macOS, and not available on other OSes.
@@ -781,7 +781,6 @@ def detect(self, kwargs: T.Dict[str, T.Any]) -> None:
 
         # We won't check symbols here, because Accelerate is built in a consistent fashion
         # with known symbol mangling, unlike OpenBLAS or Netlib BLAS/LAPACK.
-        return None
 
     def get_symbol_suffix(self) -> str:
         return '$NEWLAPACK' if self.interface == 'lp64' else '$NEWLAPACK$ILP64'
@@ -804,7 +803,7 @@ def parse_mkl_options(self, kwargs: T.Dict[str, T.Any]) -> None:
         if not threading_module:
             self.threading = 'iomp'
         elif len(threading_module) > 1:
-            raise mesonlib.MesonException(f'Multiple threading arguments: {threading_modules}')
+            raise mesonlib.MesonException(f'Multiple threading arguments: {threading_module}')
         else:
             # We have a single threading option specified - validate and process it
             opt = threading_module[0]
@@ -818,7 +817,7 @@ def parse_mkl_options(self, kwargs: T.Dict[str, T.Any]) -> None:
         if not sdl_module:
             self.use_sdl = 'auto'
         elif len(sdl_module) > 1:
-            raise mesonlib.MesonException(f'Multiple sdl arguments: {threading_modules}')
+            raise mesonlib.MesonException(f'Multiple sdl arguments: {threading_module}')
         else:
             # We have a single sdl option specified - validate and process it
             opt = sdl_module[0]
@@ -845,8 +844,6 @@ def parse_mkl_options(self, kwargs: T.Dict[str, T.Any]) -> None:
             raise mesonlib.MesonException(f'Linking SDL implies using LP64 and Intel OpenMP, found '
                                           f'conflicting options: {self.interface}, {self.threading}')
 
-        return None
-
 
 class MKLPkgConfigDependency(BLASLAPACKMixin, MKLMixin, PkgConfigDependency):
     """
@@ -896,7 +893,6 @@ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.
 
         if self.use_sdl:
             self.detect_sdl()
-        return None
 
     def detect_sdl(self) -> None:
         # Use MKLROOT in addition to standard libdir(s)
@@ -926,7 +922,7 @@ def detect_sdl(self) -> None:
             self.is_found = True
             self.compile_args += incdir_args
             self.link_args += link_arg
-            if not sys.platform == 'win32':
+            if sys.platform != 'win32':
                 self.link_args += ['-lpthread', '-lm', '-ldl']
 
             # Determine MKL version

mesonbuild/linkers/linkers.py

@@ -1396,9 +1396,6 @@ def rsp_file_syntax(self) -> RSPFileSyntax:
     def get_pie_args(self) -> T.List[str]:
         return []
 
-    def get_pie_args(self) -> T.List[str]:
-        return []
-
 
 class MSVCDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
 

mesonbuild/modules/features/feature.py

@@ -3,7 +3,7 @@
 import re
 from typing import (
     Dict, Set, Tuple, List, Callable, Optional,
-    Union, Any, Iterable, cast, TYPE_CHECKING
+    Union, Any, Iterable, TYPE_CHECKING
 )
 from dataclasses import dataclass, field
 from ...mesonlib import File, MesonException
@@ -18,7 +18,6 @@
     from typing import TypedDict
     from typing_extensions import NotRequired
     from ...interpreterbase import TYPE_var, TYPE_kwargs
-    from ...compilers import Compiler
     from .. import ModuleState
 
 @dataclass(unsafe_hash=True, order=True)
@@ -80,7 +79,7 @@ def __init__(self, func_name: str, opt_name: str, default: Any = None):
         )
 
     @staticmethod
-    def convert(func_name:str, opt_name: str, values: 'IMPLIED_ATTR',
+    def convert(func_name: str, opt_name: str, values: 'IMPLIED_ATTR',
                 ) -> Union[None, List[ConflictAttr]]:
         if values is None:
             return None
@@ -131,6 +130,7 @@ def convert(func_name:str, opt_name: str, values: 'IMPLIED_ATTR',
             Union[str, Dict[str, str]]
         ]
     ]
+
     class FeatureKwArgs(TypedDict):
         #implies: Optional[List['FeatureObject']]
         implies: NotRequired[List[Any]]
@@ -163,7 +163,8 @@ def __init__(self, state: 'ModuleState',
         super().__init__()
 
         @typed_pos_args('features.new', str, int)
-        @typed_kwargs('features.new',
+        @typed_kwargs(
+            'features.new',
             KwargInfo(
                 'implies',
                 (FeatureObject, ContainerTypeInfo(list, FeatureObject)),
@@ -209,7 +210,8 @@ def init_attrs(state: 'ModuleState',
     def update_method(self, state: 'ModuleState', args: List['TYPE_var'],
                       kwargs: 'TYPE_kwargs') -> 'FeatureObject':
         @noPosargs
-        @typed_kwargs('features.FeatureObject.update',
+        @typed_kwargs(
+            'features.FeatureObject.update',
             KwargInfo('name', (NoneType, str)),
             KwargInfo('interest', (NoneType, int)),
             KwargInfo(
@@ -306,7 +308,7 @@ def sort_cb(k: Union[FeatureObject, Iterable[FeatureObject]]) -> int:
             # FIXME: that's not a safe way to increase the rank for
             # multi features this why this function isn't considerd
             # accurate.
-            rank += len(prevalent_features) -1
+            rank += len(prevalent_features) - 1
             return rank
         return sorted(features, reverse=reverse, key=sort_cb)
 

mesonbuild/modules/features/module.py

@@ -20,7 +20,6 @@
     from typing import TypedDict
     from ...interpreterbase import TYPE_var, TYPE_kwargs
     from .. import ModuleState
-    from .feature import FeatureKwArgs
 
     class TestKwArgs(TypedDict):
         compiler: Optional[Compiler]
@@ -109,6 +108,7 @@ def add_target(self, features: Union[FeatureObject, List[FeatureObject]],
 
 class Module(NewExtensionModule):
     INFO = ModuleInfo('features', '0.1.0')
+
     def __init__(self) -> None:
         super().__init__()
         self.methods.update({
@@ -142,7 +142,8 @@ def _set_cache(self, state: 'ModuleState', key: str,
         self._cache_dict(state)[key] = val
 
     @typed_pos_args('features.test', varargs=FeatureObject, min_varargs=1)
-    @typed_kwargs('features.test',
+    @typed_kwargs(
+        'features.test',
         KwargInfo('compiler', (NoneType, Compiler)),
         KwargInfo('anyfet', bool, default = False),
         KwargInfo('cached', bool, default = True),
@@ -255,7 +256,7 @@ def test_any(self, state: 'ModuleState', features: Set[FeatureObject],
         features_any = set()
         for fet in all_features:
             _, test_any_result = self.cached_test(
-                state, features={fet,},
+                state, features={fet, },
                 compiler=compiler,
                 cached=cached,
                 anyfet=False,
@@ -293,7 +294,7 @@ def test(self, state: 'ModuleState', features: Set[FeatureObject],
             # Set the highest interested feature
             prevalent_features = sorted(features)[-1:]
 
-        prevalent_names =  [fet.name for fet in prevalent_features]
+        prevalent_names = [fet.name for fet in prevalent_features]
         # prepare the result dict
         test_result: 'TestResultKwArgs' = {
             'target_name': '__'.join(prevalent_names),
@@ -307,6 +308,7 @@ def test(self, state: 'ModuleState', features: Set[FeatureObject],
             'is_disabled': False,
             'fail_reason': '',
         }
+
         def fail_result(fail_reason: str, is_disabled: bool = False
                         ) -> 'TestResultKwArgs':
             test_result.update({
@@ -337,7 +339,7 @@ def fail_result(fail_reason: str, is_disabled: bool = False
         predecessor_features = implied_features.difference(_caller)
         for fet in sorted(predecessor_features):
             _, pred_result = self.cached_test(
-                state, features={fet,},
+                state, features={fet, },
                 compiler=compiler,
                 cached=cached,
                 anyfet=False,
@@ -431,7 +433,8 @@ def fail_result(fail_reason: str, is_disabled: bool = False
         build.GeneratedList, build.StructuredSources, build.ExtractedObjects,
         build.BuildTarget
     ))
-    @typed_kwargs('features.multi_targets',
+    @typed_kwargs(
+        'features.multi_targets',
         KwargInfo(
             'dispatch', (
                 ContainerTypeInfo(list, (FeatureObject, list)),
@@ -451,8 +454,8 @@ def fail_result(fail_reason: str, is_disabled: bool = False
         allow_unknown=True
     )
     def multi_targets_method(self, state: 'ModuleState',
-                            args: Tuple[str], kwargs: 'TYPE_kwargs'
-                            ) -> TargetsObject:
+                             args: Tuple[str], kwargs: 'TYPE_kwargs'
+                             ) -> TargetsObject:
         config_name = args[0]
         sources = args[1]  # type: ignore
         dispatch: List[Union[FeatureObject, List[FeatureObject]]] = (
@@ -467,7 +470,7 @@ def multi_targets_method(self, state: 'ModuleState',
         if not compiler:
             compiler = get_compiler(state)
 
-        baseline_features : Set[FeatureObject] = set()
+        baseline_features: Set[FeatureObject] = set()
         has_baseline = baseline is not None
         if has_baseline:
             baseline_features = FeatureObject.get_implicit_combine_multi(baseline)
@@ -488,7 +491,7 @@ def multi_targets_method(self, state: 'ModuleState',
         ]] = []
         for d in dispatch:
             if isinstance(d, FeatureObject):
-                target = {d,}
+                target = {d, }
                 is_base_part = d in baseline_features
             else:
                 target = set(d)
@@ -647,7 +650,7 @@ def gen_config(self, state: 'ModuleState', config_name: str,
                 c_detect = '1'
             dispatch_calls.append(
                 f'{prefix}_MTARGETS_EXPAND('
-                    f'EXEC_CB({c_detect}, {test["target_name"]}, __VA_ARGS__)'
+                f'EXEC_CB({c_detect}, {test["target_name"]}, __VA_ARGS__)'
                 ')'
             )
 
@@ -683,7 +686,8 @@ def gen_config(self, state: 'ModuleState', config_name: str,
         return config_path
 
     @typed_pos_args('features.sort', varargs=FeatureObject, min_varargs=1)
-    @typed_kwargs('features.sort',
+    @typed_kwargs(
+        'features.sort',
         KwargInfo('reverse', bool, default = False),
     )
     def sort_method(self, state: 'ModuleState',

mesonbuild/modules/features/utils.py

@@ -33,7 +33,6 @@ def test_code(state: 'ModuleState', compiler: 'Compiler',
 
 def generate_hash(*args: Any) -> str:
     hasher = hashlib.sha1()
-    test: List[bytes] = []
     for a in args:
         hasher.update(bytes(str(a), encoding='utf-8'))
     return hasher.hexdigest()