fix linting problems & make the module compatible with latest version

Author: seiko2plus

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

@@ -10,7 +10,7 @@
 from ...interpreter.type_checking import NoneType
 from ...interpreterbase.decorators import (
     noKwargs, KwargInfo, typed_kwargs, typed_pos_args,
-    ContainerTypeInfo, permittedKwargs
+    ContainerTypeInfo
 )
 from .. import ModuleInfo, NewExtensionModule, ModuleObject
 from .feature import FeatureObject, ConflictAttr
@@ -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]
@@ -104,11 +103,12 @@ def add_target(self, features: Union[FeatureObject, List[FeatureObject]],
             else tuple(sorted(features))
         )
         targets: List[build.StaticLibrary] = self._targets.setdefault(
-            tfeatures, cast(List[build.StaticLibrary], []))  # type: ignore
+            tfeatures, [])
         targets.append(target)
 
 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,
@@ -398,7 +400,7 @@ def fail_result(fail_reason: str, is_disabled: bool = False
         test_args = compiler.has_multi_arguments
         args = test_result['args']
         if args:
-            supported_args, test_cached = test_args(args, state.environment)
+            supported_args, test_cached = test_args(args)
             if not supported_args:
                 return fail_result(
                     f'Arguments "{", ".join(args)}" are not supported'
@@ -423,15 +425,13 @@ def fail_result(fail_reason: str, is_disabled: bool = False
                 test_result[k].append(extra_name)  # type: ignore
         return test_result
 
-    @permittedKwargs(build.known_stlib_kwargs | {
-        'dispatch', 'baseline', 'prefix', 'cached', 'keep_sort'
-    })
     @typed_pos_args('features.multi_targets', str, min_varargs=1, varargs=(
         str, File, build.CustomTarget, build.CustomTargetIndex,
         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 +451,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 +467,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 +488,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 +647,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 +683,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

@@ -2,9 +2,9 @@
 import hashlib
 from typing import Tuple, List, Union, Any, TYPE_CHECKING
 from ...mesonlib import MesonException, MachineChoice
+from ...compilers.compilers import CompileCheckMode, Compiler
 
 if TYPE_CHECKING:
-    from ...compilers import Compiler
     from ...mesonlib import File
     from .. import ModuleState
 
@@ -27,13 +27,12 @@ def test_code(state: 'ModuleState', compiler: 'Compiler',
               ) -> Tuple[bool, bool, str]:
     # TODO: Add option to treat warnings as errors
     with compiler.cached_compile(
-        code, state.environment.coredata, extra_args=args
+        code, extra_args=args, mode=CompileCheckMode.COMPILE
     ) as p:
         return p.cached, p.returncode == 0, p.stderr
 
 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()

unittests/featurestests.py

@@ -1,32 +1,29 @@
 # Copyright (c) 2023, NumPy Developers.
 
 import re
+import os
 import contextlib
+from unittest import mock
 from mesonbuild.interpreter import Interpreter
 from mesonbuild.build import Build
-from mesonbuild.mparser import FunctionNode, ArgumentNode, Token
+from mesonbuild.mparser import IdNode, SymbolNode, Token, FunctionNode, ArgumentNode
 from mesonbuild.modules import ModuleState
 from mesonbuild.modules.features import Module
 from mesonbuild.compilers import Compiler, CompileResult
 from mesonbuild.mesonlib import MachineChoice
 from mesonbuild.envconfig import MachineInfo
 
 from .baseplatformtests import BasePlatformTests
-from run_tests import get_convincing_fake_env_and_cc
+from run_tests import FakeBuild, get_fake_env, get_convincing_fake_env_and_cc
 
 class FakeCompiler(Compiler):
     language = 'c'
 
     def __init__(self, trap_args = '', trap_code=''):
         super().__init__(
             ccache=[], exelist=[], version='0.0',
+            environment=get_fake_env(),
             for_machine=MachineChoice.HOST,
-            info=MachineInfo(
-                system='linux', cpu_family='x86_64',
-                cpu='xeon', endian='little',
-                kernel='linux', subsystem='numpy'
-            ),
-            is_cross=True
         )
         self.trap_args = trap_args
         self.trap_code = trap_code
@@ -40,7 +37,7 @@ def get_optimization_args(self, optimization_level: str) -> 'T.List[str]':
     def get_output_args(self, outputname: str) -> 'T.List[str]':
         return []
 
-    def has_multi_arguments(self, args: 'T.List[str]', env: 'Environment') -> 'T.Tuple[bool, bool]':
+    def has_multi_arguments(self, args: 'T.List[str]') -> 'T.Tuple[bool, bool]':
         if self.trap_args:
             for a in args:
                 if re.match(self.trap_args, a):
@@ -54,7 +51,13 @@ def compile(self, code: 'mesonlib.FileOrString', *args, **kwargs
             rcode = -1
         else:
             rcode = 0
-        result = CompileResult(returncode=rcode)
+        result = CompileResult(
+            stdout='',
+            stderr='',
+            command=[],
+            returncode=rcode,
+            input_name='fake_input.c'
+        )
         yield result
 
     @contextlib.contextmanager
@@ -64,28 +67,51 @@ def cached_compile(self, code: 'mesonlib.FileOrString', *args, **kwargs
             rcode = -1
         else:
             rcode = 0
-        result = CompileResult(returncode=rcode)
+        result = CompileResult(
+            stdout='',
+            stderr='',
+            command=[],
+            returncode=rcode,
+            input_name='fake_input.c'
+        )
         yield result
 
+
+    def _sanity_check_source_code(self) -> str:
+        return 'public static int main() { return 0; }'
+
 class FeaturesTests(BasePlatformTests):
+
+    @mock.patch.dict(os.environ)
+    @mock.patch.object(Interpreter, 'load_root_meson_file', mock.Mock(return_value=None))
+    @mock.patch.object(Interpreter, 'sanity_check_ast', mock.Mock(return_value=None))
+    @mock.patch.object(Interpreter, 'parse_project', mock.Mock(return_value=None))
     def setUp(self):
         super().setUp()
         env, cc = get_convincing_fake_env_and_cc(
             bdir=self.builddir, prefix=self.prefix)
         env.machines.target = env.machines.host
 
+        # Disable unit test specific syntax
+        os.environ.pop('MESON_RUNNING_IN_PROJECT_TESTS', None)
         build = Build(env)
-        interp = Interpreter(build, mock=True)
+        interp = Interpreter(build)
+        # Mock out user_defined_options to bypass the coredata initialization crash
+        interp.user_defined_options = mock.Mock()
+        interp.user_defined_options.cmd_line_options = {}
+
         project = interp.funcs['project']
         filename = 'featurestests.py'
+        dummy_span = (0, 0) # Safe placeholder for bytespan: Tuple[int, int]
+        func_name_token = Token('id', filename, 0, 0, 0, dummy_span, 'FeaturesTests')
+        lpar_token = Token('lpar', filename, 0, 0, 13, dummy_span, '(')
+        arg_token = Token('string', filename, 0, 0, 14, dummy_span, '')
+        rpar_token = Token('rpar', filename, 0, 0, 15, dummy_span, ')')
         node = FunctionNode(
-            filename = filename,
-            lineno = 0,
-            colno = 0,
-            end_lineno = 0,
-            end_colno = 0,
-            func_name = 'FeaturesTests',
-            args = ArgumentNode(Token('string', filename, 0, 0, 0, None, ''))
+            IdNode(func_name_token),
+            SymbolNode(lpar_token),
+            ArgumentNode(arg_token),
+            SymbolNode(rpar_token)
         )
         project(node, ['Test Module Features'], {'version': '0.1'})
         self.cc = cc
@@ -272,7 +298,7 @@ def test_conflict_args(self):
             ),
             (
                 [fet6],
-                'args', {'val':'arch=', 'match': 'arg.*[0-9]|arch=.*', 'mfilter': '([0-9])|arch=(\w+)', 'mjoin': '*'},
+                'args', {'val':'arch=', 'match': 'arg.*[0-9]|arch=.*', 'mfilter': r'([0-9])|arch=(\w+)', 'mjoin': '*'},
                 ['arch=1*2*3*4*5*xx'],
             ),
             (