compilers: Remove Environment parameter from Compiler.has_multi_arguments

10 files changed, 26 insertions, 26 deletions

diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py
index 007f44fcd..e1086eb73 100644
--- a/mesonbuild/compilers/compilers.py
+++ b/mesonbuild/compilers/compilers.py
@@ -299,7 +299,7 @@ def get_base_compile_args(target: 'BuildTarget', compiler: 'Compiler', env: 'Env
         # We consider that if there are no sanitizer arguments returned, then
         # the language doesn't support them.
         if sanitize_args:
-            if not compiler.has_multi_arguments(sanitize_args, env)[0]:
+            if not compiler.has_multi_arguments(sanitize_args)[0]:
                 raise MesonException(f'Compiler {compiler.name_string()} does not support sanitizer arguments {sanitize_args}')
             args.extend(sanitize_args)
     except KeyError:
@@ -373,7 +373,7 @@ def get_base_link_args(target: 'BuildTarget',
         # We consider that if there are no sanitizer arguments returned, then
         # the language doesn't support them.
         if sanitizer_args:
-            if not linker.has_multi_link_arguments(sanitizer_args, env)[0]:
+            if not linker.has_multi_link_arguments(sanitizer_args)[0]:
                 raise MesonException(f'Linker {linker.name_string()} does not support sanitizer arguments {sanitizer_args}')
             args.extend(sanitizer_args)
     except KeyError:
@@ -779,7 +779,7 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta):
     def get_program_dirs(self, env: 'Environment') -> 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]:
         """Checks if the compiler has all of the arguments.
 
         :returns:
@@ -790,14 +790,14 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta):
             'Language {} does not support has_multi_arguments.'.format(
                 self.get_display_language()))
 
-    def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+    def has_multi_link_arguments(self, args: T.List[str]) -> T.Tuple[bool, bool]:
         """Checks if the linker has all of the arguments.
 
         :returns:
             A tuple of (bool, bool). The first value is whether the check
             succeeded, and the second is whether it was retrieved from a cache
         """
-        return self.linker.has_multi_arguments(args, env)
+        return self.linker.has_multi_arguments(args)
 
     def _get_compile_output(self, dirname: str, mode: CompileCheckMode) -> str:
         assert mode != CompileCheckMode.PREPROCESS, 'In pre-processor mode, the output is sent to stdout and discarded'
diff --git a/mesonbuild/compilers/cuda.py b/mesonbuild/compilers/cuda.py
index e9dff7757..551b8d690 100644
--- a/mesonbuild/compilers/cuda.py
+++ b/mesonbuild/compilers/cuda.py
@@ -813,11 +813,11 @@ class CudaCompiler(Compiler):
 
         return self.host_compiler.get_assert_args(disable) + cccl_macros
 
-    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]:
         args = self._to_host_flags(args)
         return self.compiles('int main(void) { return 0; }', extra_args=args, mode=CompileCheckMode.COMPILE)
 
-    def has_multi_link_arguments(self, args: T.List[str], env: Environment) -> T.Tuple[bool, bool]:
+    def has_multi_link_arguments(self, args: T.List[str]) -> T.Tuple[bool, bool]:
         args = ['-Xnvlink='+self._shield_nvcc_list_arg(s) for s in self.linker.fatal_warnings()]
         args += self._to_host_flags(args, phase=Phase.LINKER)
         return self.compiles('int main(void) { return 0; }', extra_args=args, mode=CompileCheckMode.LINK)
diff --git a/mesonbuild/compilers/d.py b/mesonbuild/compilers/d.py
index 8d13c1ae6..4e31ded83 100644
--- a/mesonbuild/compilers/d.py
+++ b/mesonbuild/compilers/d.py
@@ -536,7 +536,7 @@ class DCompiler(Compiler):
     def compiler_args(self, args: T.Optional[T.Iterable[str]] = None) -> DCompilerArgs:
         return DCompilerArgs(self, args)
 
-    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]:
         return self.compiles('int i;\n', extra_args=args)
 
     def _get_target_arch_args(self) -> T.List[str]:
diff --git a/mesonbuild/compilers/fortran.py b/mesonbuild/compilers/fortran.py
index d643e4469..fdd452144 100644
--- a/mesonbuild/compilers/fortran.py
+++ b/mesonbuild/compilers/fortran.py
@@ -106,11 +106,11 @@ class FortranCompiler(CLikeCompiler, Compiler):
         code = 'stop; end program'
         return self._find_library_impl(libname, env, extra_dirs, code, libtype, lib_prefix_warning, ignore_system_dirs)
 
-    def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
-        return self._has_multi_arguments(args, env, 'stop; end program')
+    def has_multi_arguments(self, args: T.List[str]) -> T.Tuple[bool, bool]:
+        return self._has_multi_arguments(args, 'stop; end program')
 
-    def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
-        return self._has_multi_link_arguments(args, env, 'stop; end program')
+    def has_multi_link_arguments(self, args: T.List[str]) -> T.Tuple[bool, bool]:
+        return self._has_multi_link_arguments(args, 'stop; end program')
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
diff --git a/mesonbuild/compilers/mixins/clike.py b/mesonbuild/compilers/mixins/clike.py
index 3b91c1d7e..db4d385c6 100644
--- a/mesonbuild/compilers/mixins/clike.py
+++ b/mesonbuild/compilers/mixins/clike.py
@@ -1291,7 +1291,7 @@ class CLikeCompiler(Compiler):
                       mode: CompileCheckMode) -> T.Tuple[bool, bool]:
         return self.compiles(code, extra_args=args, mode=mode)
 
-    def _has_multi_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
+    def _has_multi_arguments(self, args: T.List[str], code: str) -> T.Tuple[bool, bool]:
         new_args: T.List[str] = []
         for arg in args:
             # some compilers, e.g. GCC, don't warn for unsupported warning-disable
@@ -1323,18 +1323,18 @@ class CLikeCompiler(Compiler):
                              'the compiler you are using. has_link_argument or '
                              'other similar method can be used instead.')
             new_args.append(arg)
-        return self.has_arguments(new_args, env, code, mode=CompileCheckMode.COMPILE)
+        return self.has_arguments(new_args, self.environment, code, mode=CompileCheckMode.COMPILE)
 
-    def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
-        return self._has_multi_arguments(args, env, 'extern int i;\nint i;\n')
+    def has_multi_arguments(self, args: T.List[str]) -> T.Tuple[bool, bool]:
+        return self._has_multi_arguments(args, 'extern int i;\nint i;\n')
 
-    def _has_multi_link_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
+    def _has_multi_link_arguments(self, args: T.List[str], code: str) -> T.Tuple[bool, bool]:
         args = self.linker.fatal_warnings() + args
         args = self.linker_to_compiler_args(args)
-        return self.has_arguments(args, env, code, mode=CompileCheckMode.LINK)
+        return self.has_arguments(args, self.environment, code, mode=CompileCheckMode.LINK)
 
-    def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
-        return self._has_multi_link_arguments(args, env, 'int main(void) { return 0; }\n')
+    def has_multi_link_arguments(self, args: T.List[str]) -> T.Tuple[bool, bool]:
+        return self._has_multi_link_arguments(args, 'int main(void) { return 0; }\n')
 
     @staticmethod
     def _concatenate_string_literals(s: str) -> str:
diff --git a/mesonbuild/compilers/mixins/islinker.py b/mesonbuild/compilers/mixins/islinker.py
index 35369ca8e..11560c10c 100644
--- a/mesonbuild/compilers/mixins/islinker.py
+++ b/mesonbuild/compilers/mixins/islinker.py
@@ -63,7 +63,7 @@ class BasicLinkerIsCompilerMixin(Compiler):
     def get_option_link_args(self, target: BuildTarget, env: Environment, subproject: T.Optional[str] = None) -> T.List[str]:
         return []
 
-    def has_multi_link_args(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+    def has_multi_link_args(self, args: T.List[str]) -> T.Tuple[bool, bool]:
         return False, False
 
     def get_link_debugfile_args(self, targetfile: str) -> T.List[str]:
diff --git a/mesonbuild/compilers/rust.py b/mesonbuild/compilers/rust.py
index de2ab8d95..f41eae948 100644
--- a/mesonbuild/compilers/rust.py
+++ b/mesonbuild/compilers/rust.py
@@ -448,10 +448,10 @@ class RustCompiler(Compiler):
 
         return exelist + args
 
-    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]:
         return self.compiles('fn main() { std::process::exit(0) }\n', extra_args=args, mode=CompileCheckMode.COMPILE)
 
-    def has_multi_link_arguments(self, args: T.List[str], env: Environment) -> T.Tuple[bool, bool]:
+    def has_multi_link_arguments(self, args: T.List[str]) -> T.Tuple[bool, bool]:
         args = rustc_link_args(self.linker.fatal_warnings()) + args
         return self.compiles('fn main() { std::process::exit(0) }\n', extra_args=args, mode=CompileCheckMode.LINK)
 
diff --git a/mesonbuild/interpreter/compiler.py b/mesonbuild/interpreter/compiler.py
index 767dd597d..5a7a88422 100644
--- a/mesonbuild/interpreter/compiler.py
+++ b/mesonbuild/interpreter/compiler.py
@@ -741,7 +741,7 @@ class CompilerHolder(ObjectHolder['Compiler']):
             mlog.log(*logargs)
             return False
         test = self.compiler.has_multi_link_arguments if mode is _TestMode.LINKER else self.compiler.has_multi_arguments
-        result, cached = test(arguments, self.environment)
+        result, cached = test(arguments)
         if required and not result:
             logargs += ['not usable']
             raise InterpreterException(*logargs)
diff --git a/mesonbuild/linkers/linkers.py b/mesonbuild/linkers/linkers.py
index 41c686e6d..15b1ea5b0 100644
--- a/mesonbuild/linkers/linkers.py
+++ b/mesonbuild/linkers/linkers.py
@@ -195,7 +195,7 @@ class DynamicLinker(metaclass=abc.ABCMeta):
     def get_option_link_args(self, target: 'BuildTarget', env: 'Environment', subproject: T.Optional[str] = None) -> 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]:
         raise EnvironmentException(f'Language {self.id} does not support has_multi_link_arguments.')
 
     def get_debugfile_name(self, targetfile: str) -> T.Optional[str]:
diff --git a/mesonbuild/modules/simd.py b/mesonbuild/modules/simd.py
index bfdc0c2df..2519d531e 100644
--- a/mesonbuild/modules/simd.py
+++ b/mesonbuild/modules/simd.py
@@ -88,7 +88,7 @@ class SimdModule(ExtensionModule):
                 mlog.log(f'Compiler supports {iset}:', mlog.red('NO'))
                 continue
 
-            if not compiler.has_multi_arguments(compile_args, state.environment)[0]:
+            if not compiler.has_multi_arguments(compile_args)[0]:
                 mlog.log(f'Compiler supports {iset}:', mlog.red('NO'))
                 continue
             mlog.log(f'Compiler supports {iset}:', mlog.green('YES'))