dependencies: stop passing "language" as a keyword argument

It's allowed in the `DependencyKeywordArguments` TypeDict already, so we
now have two sources of truth. Additionally, it's often populated by
reading from that dict, so we're just doing useless work.

20 files changed, 125 insertions, 125 deletions

diff --git a/mesonbuild/dependencies/base.py b/mesonbuild/dependencies/base.py
index eadd8afb8..293f772a8 100644
--- a/mesonbuild/dependencies/base.py
+++ b/mesonbuild/dependencies/base.py
@@ -137,7 +137,7 @@ class Dependency(HoldableObject):
         self._id = uuid.uuid4().int
         self.name = f'dep{self._id}'
         self.version:  T.Optional[str] = None
-        self.language: T.Optional[str] = None # None means C-like
+        self.language: T.Optional[str] = kwargs.get('language') # None means C-like
         self.is_found = False
         self.compile_args: T.List[str] = []
         self.link_args:    T.List[str] = []
@@ -416,12 +416,11 @@ class InternalDependency(Dependency):
         return new_dep
 
 class ExternalDependency(Dependency):
-    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None):
+    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs):
         Dependency.__init__(self, kwargs)
         self.env = environment
         self.name = name
         self.is_found = False
-        self.language = language
         self.version_reqs = kwargs.get('version', [])
         self.required = kwargs.get('required', True)
         self.silent = kwargs.get('silent', False)
@@ -526,8 +525,7 @@ class ExternalLibrary(ExternalDependency):
 
     def __init__(self, name: str, link_args: T.List[str], environment: 'Environment',
                  language: str, silent: bool = False) -> None:
-        super().__init__(name, environment, {}, language=language)
-        self.language = language
+        super().__init__(name, environment, {'language': language})
         self.is_found = False
         if link_args:
             self.is_found = True
diff --git a/mesonbuild/dependencies/boost.py b/mesonbuild/dependencies/boost.py
index b4d7ba740..171c49455 100644
--- a/mesonbuild/dependencies/boost.py
+++ b/mesonbuild/dependencies/boost.py
@@ -341,7 +341,8 @@ class BoostLibraryFile():
 
 class BoostDependency(SystemDependency):
     def __init__(self, name: str, environment: Environment, kwargs: DependencyObjectKWs) -> None:
-        super().__init__(name, environment, kwargs, language='cpp')
+        kwargs['language'] = 'cpp'
+        super().__init__(name, environment, kwargs)
         buildtype = environment.coredata.optstore.get_value_for(OptionKey('buildtype'))
         assert isinstance(buildtype, str)
         self.debug = buildtype.startswith('debug')
@@ -361,7 +362,7 @@ class BoostDependency(SystemDependency):
 
         # Do we need threads?
         if 'thread' in self.modules:
-            if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
+            if not self._add_sub_dependency(threads_factory(environment, {'native': self.for_machine})):
                 self.is_found = False
                 return
 
diff --git a/mesonbuild/dependencies/cmake.py b/mesonbuild/dependencies/cmake.py
index 591c68ea0..e8881cda2 100644
--- a/mesonbuild/dependencies/cmake.py
+++ b/mesonbuild/dependencies/cmake.py
@@ -72,9 +72,10 @@ class CMakeDependency(ExternalDependency):
         # one module
         return module
 
-    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None, force_use_global_compilers: bool = False) -> None:
+    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, force_use_global_compilers: bool = False) -> None:
         # Gather a list of all languages to support
         self.language_list: T.List[str] = []
+        language = kwargs.get('language')
         if language is None or force_use_global_compilers:
             for_machine = kwargs.get('native', MachineChoice.HOST)
             compilers = environment.coredata.compilers[for_machine]
@@ -90,7 +91,7 @@ class CMakeDependency(ExternalDependency):
         # Ensure that the list is unique
         self.language_list = list(set(self.language_list))
 
-        super().__init__(name, environment, kwargs, language=language)
+        super().__init__(name, environment, kwargs)
         self.is_libtool = False
 
         # Where all CMake "build dirs" are located
@@ -650,10 +651,10 @@ class CMakeDependencyFactory:
         self.name = name
         self.modules = modules
 
-    def __call__(self, name: str, env: Environment, kwargs: DependencyObjectKWs, language: T.Optional[str] = None, force_use_global_compilers: bool = False) -> CMakeDependency:
+    def __call__(self, name: str, env: Environment, kwargs: DependencyObjectKWs, force_use_global_compilers: bool = False) -> CMakeDependency:
         if self.modules:
             kwargs['modules'] = self.modules
-        return CMakeDependency(self.name or name, env, kwargs, language, force_use_global_compilers)
+        return CMakeDependency(self.name or name, env, kwargs, force_use_global_compilers)
 
     @staticmethod
     def log_tried() -> str:
diff --git a/mesonbuild/dependencies/coarrays.py b/mesonbuild/dependencies/coarrays.py
index 0c8750ced..d75eb5857 100644
--- a/mesonbuild/dependencies/coarrays.py
+++ b/mesonbuild/dependencies/coarrays.py
@@ -6,6 +6,7 @@ from __future__ import annotations
 import functools
 import typing as T
 
+from ..mesonlib import MachineChoice
 from .base import DependencyMethods, detect_compiler, SystemDependency
 from .cmake import CMakeDependency
 from .detect import packages
@@ -15,15 +16,15 @@ from .factory import factory_methods
 if T.TYPE_CHECKING:
     from . factory import DependencyGenerator
     from ..environment import Environment
-    from ..mesonlib import MachineChoice
     from .base import DependencyObjectKWs
 
 
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE, DependencyMethods.SYSTEM})
 def coarray_factory(env: 'Environment',
-                    for_machine: 'MachineChoice',
                     kwargs: DependencyObjectKWs,
                     methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+    kwargs['language'] = 'fortran'
+    for_machine = kwargs.get('native', MachineChoice.HOST)
     fcid = detect_compiler('coarray', env, for_machine, 'fortran').get_id()
     candidates: T.List['DependencyGenerator'] = []
 
@@ -32,13 +33,13 @@ def coarray_factory(env: 'Environment',
         if DependencyMethods.PKGCONFIG in methods:
             for pkg in ['caf-openmpi', 'caf']:
                 candidates.append(functools.partial(
-                    PkgConfigDependency, pkg, env, kwargs, language='fortran'))
+                    PkgConfigDependency, pkg, env, kwargs))
 
         if DependencyMethods.CMAKE in methods:
             if not kwargs.get('modules'):
                 kwargs['modules'] = ['OpenCoarrays::caf_mpi']
             candidates.append(functools.partial(
-                CMakeDependency, 'OpenCoarrays', env, kwargs, language='fortran'))
+                CMakeDependency, 'OpenCoarrays', env, kwargs))
 
     if DependencyMethods.SYSTEM in methods:
         candidates.append(functools.partial(CoarrayDependency, 'coarray', env, kwargs))
@@ -57,7 +58,8 @@ class CoarrayDependency(SystemDependency):
     low-level MPI calls.
     """
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
-        super().__init__(name, environment, kwargs, language='fortran')
+        kwargs['language'] = 'fortran'
+        super().__init__(name, environment, kwargs)
         kwargs['required'] = False
         kwargs['silent'] = True
 
diff --git a/mesonbuild/dependencies/configtool.py b/mesonbuild/dependencies/configtool.py
index a87062114..024bf9430 100644
--- a/mesonbuild/dependencies/configtool.py
+++ b/mesonbuild/dependencies/configtool.py
@@ -38,8 +38,8 @@ class ConfigToolDependency(ExternalDependency):
     __strip_version = re.compile(r'^[0-9][0-9.]+')
     type_name = DependencyTypeName('config-tool')
 
-    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None, exclude_paths: T.Optional[T.List[str]] = None):
-        super().__init__(name, environment, kwargs, language=language)
+    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, exclude_paths: T.Optional[T.List[str]] = None):
+        super().__init__(name, environment, kwargs)
         # You may want to overwrite the class version in some cases
         self.tools = listify(kwargs.get('tools', self.tools))
         if not self.tool_name:
diff --git a/mesonbuild/dependencies/cuda.py b/mesonbuild/dependencies/cuda.py
index 276b886f1..75f6cb9e5 100644
--- a/mesonbuild/dependencies/cuda.py
+++ b/mesonbuild/dependencies/cuda.py
@@ -32,12 +32,13 @@ class CudaDependency(SystemDependency):
         for_machine = kwargs.get('native', mesonlib.MachineChoice.HOST)
         compilers = environment.coredata.compilers[for_machine]
         machine = environment.machines[for_machine]
-        language = self._detect_language(compilers)
+        if not kwargs.get('language'):
+            kwargs['language'] = self._detect_language(compilers)
 
-        if language not in self.supported_languages:
-            raise DependencyException(f'Language \'{language}\' is not supported by the CUDA Toolkit. Supported languages are {self.supported_languages}.')
+        if kwargs['language'] not in self.supported_languages:
+            raise DependencyException(f'Language \'{kwargs["language"]}\' is not supported by the CUDA Toolkit. Supported languages are {self.supported_languages}.')
 
-        super().__init__(name, environment, kwargs, language=language)
+        super().__init__(name, environment, kwargs)
         self.lib_modules: T.Dict[str, T.List[str]] = {}
         self.requested_modules = kwargs.get('modules', [])
         if not any(runtime in self.requested_modules for runtime in ['cudart', 'cudart_static']):
diff --git a/mesonbuild/dependencies/detect.py b/mesonbuild/dependencies/detect.py
index 8682e6727..0681913a1 100644
--- a/mesonbuild/dependencies/detect.py
+++ b/mesonbuild/dependencies/detect.py
@@ -107,7 +107,7 @@ def find_external_dependency(name: str, env: 'Environment', kwargs: DependencyOb
 
     # build a list of dependency methods to try
     if candidates is None:
-        candidates = _build_external_dependency_list(name, env, for_machine, kwargs)
+        candidates = _build_external_dependency_list(name, env, kwargs)
 
     pkg_exc: T.List[DependencyException] = []
     pkgdep:  T.List[ExternalDependency] = []
@@ -173,8 +173,8 @@ def find_external_dependency(name: str, env: 'Environment', kwargs: DependencyOb
     return NotFoundDependency(name, env)
 
 
-def _build_external_dependency_list(name: str, env: 'Environment', for_machine: MachineChoice,
-                                    kwargs: DependencyObjectKWs) -> T.List['DependencyGenerator']:
+def _build_external_dependency_list(name: str, env: 'Environment', kwargs: DependencyObjectKWs
+                                    ) -> T.List['DependencyGenerator']:
     # Is there a specific dependency detector for this dependency?
     lname = name.lower()
     if lname in packages:
@@ -188,7 +188,7 @@ def _build_external_dependency_list(name: str, env: 'Environment', for_machine:
                 dep = [func]
         else:
             entry2 = T.cast('T.Union[DependencyFactory, WrappedFactoryFunc]', packages[lname])
-            dep = entry2(env, for_machine, kwargs)
+            dep = entry2(env, kwargs)
         return dep
 
     candidates: T.List['DependencyGenerator'] = []
@@ -213,6 +213,7 @@ def _build_external_dependency_list(name: str, env: 'Environment', for_machine:
 
     # On OSX only, try framework dependency detector.
     if DependencyMethods.EXTRAFRAMEWORK in methods:
+        for_machine = kwargs.get('native', MachineChoice.HOST)
         if env.machines[for_machine].is_darwin():
             from .framework import ExtraFrameworkDependency
             candidates.append(functools.partial(ExtraFrameworkDependency, name, env, kwargs))
diff --git a/mesonbuild/dependencies/dev.py b/mesonbuild/dependencies/dev.py
index c63aa8e0f..dd21b910f 100644
--- a/mesonbuild/dependencies/dev.py
+++ b/mesonbuild/dependencies/dev.py
@@ -48,12 +48,13 @@ def get_shared_library_suffix(environment: 'Environment', for_machine: MachineCh
 
 class GTestDependencySystem(SystemDependency):
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
-        super().__init__(name, environment, kwargs, language='cpp')
+        kwargs['language'] = 'cpp'
+        super().__init__(name, environment, kwargs)
         self.main = kwargs.get('main', False)
 
         sysroot = environment.properties[self.for_machine].get_sys_root() or ''
         self.src_dirs = [sysroot + '/usr/src/gtest/src', sysroot + '/usr/src/googletest/googletest/src']
-        if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
+        if not self._add_sub_dependency(threads_factory(environment, {'native': self.for_machine})):
             self.is_found = False
             return
         self.detect()
@@ -113,22 +114,24 @@ class GTestDependencyPC(PkgConfigDependency):
 
 class GMockDependencySystem(SystemDependency):
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
-        super().__init__(name, environment, kwargs, language='cpp')
+        kwargs['language'] = 'cpp'
+        super().__init__(name, environment, kwargs)
         self.main = kwargs.get('main', False)
-        if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
+        if not self._add_sub_dependency(threads_factory(environment, {'native': self.for_machine})):
             self.is_found = False
             return
 
         # If we are getting main() from GMock, we definitely
         # want to avoid linking in main() from GTest
         gtest_kwargs = kwargs.copy()
+        gtest_kwargs['native'] = self.for_machine
         if self.main:
             gtest_kwargs['main'] = False
 
         # GMock without GTest is pretty much useless
         # this also mimics the structure given in WrapDB,
         # where GMock always pulls in GTest
-        found = self._add_sub_dependency(gtest_factory(environment, self.for_machine, gtest_kwargs))
+        found = self._add_sub_dependency(gtest_factory(environment, gtest_kwargs))
         if not found:
             self.is_found = False
             return
@@ -188,6 +191,7 @@ class LLVMDependencyConfigTool(ConfigToolDependency):
     __cpp_blacklist = {'-DNDEBUG'}
 
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs):
+        kwargs['language'] = 'cpp'
         self.tools = get_llvm_tool_names('llvm-config')
 
         # Fedora starting with Fedora 30 adds a suffix of the number
@@ -201,7 +205,7 @@ class LLVMDependencyConfigTool(ConfigToolDependency):
 
         # It's necessary for LLVM <= 3.8 to use the C++ linker. For 3.9 and 4.0
         # the C linker works fine if only using the C API.
-        super().__init__(name, environment, kwargs, language='cpp')
+        super().__init__(name, environment, kwargs)
         self.provided_modules: T.List[str] = []
         self.required_modules: mesonlib.OrderedSet[str] = mesonlib.OrderedSet()
         self.module_details:   T.List[str] = []
@@ -224,7 +228,7 @@ class LLVMDependencyConfigTool(ConfigToolDependency):
             self._set_old_link_args()
         self.link_args = strip_system_libdirs(environment, self.for_machine, self.link_args)
         self.link_args = self.__fix_bogus_link_args(self.link_args)
-        if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
+        if not self._add_sub_dependency(threads_factory(environment, {'native': self.for_machine})):
             self.is_found = False
             return
 
@@ -383,6 +387,7 @@ class LLVMDependencyConfigTool(ConfigToolDependency):
 
 class LLVMDependencyCMake(CMakeDependency):
     def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs) -> None:
+        kwargs['language'] = 'cpp'
         self.llvm_modules = kwargs.get('modules', [])
         self.llvm_opt_modules = kwargs.get('optional_modules', [])
 
@@ -421,7 +426,7 @@ class LLVMDependencyCMake(CMakeDependency):
             )
             return
 
-        super().__init__(name, env, kwargs, language='cpp', force_use_global_compilers=True)
+        super().__init__(name, env, kwargs, force_use_global_compilers=True)
 
         if not self.cmakebin.found():
             return
@@ -443,7 +448,7 @@ class LLVMDependencyCMake(CMakeDependency):
         temp = ['-I' + x for x in inc_dirs] + defs
         self.compile_args += [x for x in temp if x not in self.compile_args]
         self.compile_args = strip_system_includedirs(env, self.for_machine, self.compile_args)
-        if not self._add_sub_dependency(threads_factory(env, self.for_machine, {})):
+        if not self._add_sub_dependency(threads_factory(env, {'native': self.for_machine})):
             self.is_found = False
             return
 
diff --git a/mesonbuild/dependencies/dub.py b/mesonbuild/dependencies/dub.py
index a10a86c5e..cfd04ee00 100644
--- a/mesonbuild/dependencies/dub.py
+++ b/mesonbuild/dependencies/dub.py
@@ -78,7 +78,8 @@ class DubDependency(ExternalDependency):
     }
 
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs):
-        super().__init__(name, environment, kwargs, language='d')
+        kwargs['language'] = 'd'
+        super().__init__(name, environment, kwargs)
         from ..compilers.d import DCompiler, d_feature_args
 
         _temp_comp = super().get_compiler()
diff --git a/mesonbuild/dependencies/factory.py b/mesonbuild/dependencies/factory.py
index 0c4ca8174..2afe28847 100644
--- a/mesonbuild/dependencies/factory.py
+++ b/mesonbuild/dependencies/factory.py
@@ -7,6 +7,7 @@ from __future__ import annotations
 import functools
 import typing as T
 
+from ..mesonlib import MachineChoice
 from .base import DependencyException, DependencyMethods
 from .base import process_method_kw
 from .base import BuiltinDependency, SystemDependency
@@ -18,13 +19,11 @@ if T.TYPE_CHECKING:
     from .base import DependencyObjectKWs, ExternalDependency
     from .configtool import ConfigToolDependency
     from ..environment import Environment
-    from ..mesonlib import MachineChoice
 
     DependencyGenerator = T.Callable[[], ExternalDependency]
     FactoryFunc = T.Callable[
         [
             'Environment',
-            MachineChoice,
             DependencyObjectKWs,
             T.List[DependencyMethods]
         ],
@@ -34,7 +33,6 @@ if T.TYPE_CHECKING:
     WrappedFactoryFunc = T.Callable[
         [
             'Environment',
-            MachineChoice,
             DependencyObjectKWs,
         ],
         T.List[DependencyGenerator]
@@ -115,13 +113,14 @@ class DependencyFactory:
             return False
         return True
 
-    def __call__(self, env: 'Environment', for_machine: MachineChoice,
-                 kwargs: DependencyObjectKWs) -> T.List['DependencyGenerator']:
+    def __call__(self, env: 'Environment', kwargs: DependencyObjectKWs) -> T.List['DependencyGenerator']:
         """Return a list of Dependencies with the arguments already attached."""
         methods = process_method_kw(self.methods, kwargs)
         nwargs = self.extra_kwargs.copy()
         nwargs.update(kwargs)
 
+        for_machine = kwargs.get('native', MachineChoice.HOST)
+
         return [functools.partial(self.classes[m], env, nwargs) for m in methods
                 if self._process_method(m, env, for_machine)]
 
@@ -138,8 +137,8 @@ def factory_methods(methods: T.Set[DependencyMethods]) -> T.Callable[['FactoryFu
     def inner(func: 'FactoryFunc') -> 'WrappedFactoryFunc':
 
         @functools.wraps(func)
-        def wrapped(env: 'Environment', for_machine: MachineChoice, kwargs: DependencyObjectKWs) -> T.List['DependencyGenerator']:
-            return func(env, for_machine, kwargs, process_method_kw(methods, kwargs))
+        def wrapped(env: 'Environment', kwargs: DependencyObjectKWs) -> T.List['DependencyGenerator']:
+            return func(env, kwargs, process_method_kw(methods, kwargs))
 
         return wrapped
 
diff --git a/mesonbuild/dependencies/framework.py b/mesonbuild/dependencies/framework.py
index 627e43b52..15c4ce2ff 100644
--- a/mesonbuild/dependencies/framework.py
+++ b/mesonbuild/dependencies/framework.py
@@ -18,9 +18,9 @@ class ExtraFrameworkDependency(ExternalDependency):
 
     type_name = DependencyTypeName('extraframeworks')
 
-    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None) -> None:
+    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs) -> None:
         paths = kwargs.get('paths', [])
-        super().__init__(name, env, kwargs, language=language)
+        super().__init__(name, env, kwargs)
         # Full path to framework directory
         self.framework_path: T.Optional[str] = None
         if not self.clib_compiler:
diff --git a/mesonbuild/dependencies/hdf5.py b/mesonbuild/dependencies/hdf5.py
index 5894cfb46..75331f254 100644
--- a/mesonbuild/dependencies/hdf5.py
+++ b/mesonbuild/dependencies/hdf5.py
@@ -27,12 +27,12 @@ class HDF5PkgConfigDependency(PkgConfigDependency):
 
     """Handle brokenness in the HDF5 pkg-config files."""
 
-    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None) -> None:
-        language = language or 'c'
+    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
+        language = kwargs.get('language') or 'c'
         if language not in {'c', 'cpp', 'fortran'}:
             raise DependencyException(f'Language {language} is not supported with HDF5.')
 
-        super().__init__(name, environment, kwargs, language)
+        super().__init__(name, environment, kwargs)
         if not self.is_found:
             return
 
@@ -78,8 +78,8 @@ class HDF5ConfigToolDependency(ConfigToolDependency):
 
     version_arg = '-showconfig'
 
-    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None) -> None:
-        language = language or 'c'
+    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
+        language = kwargs.get('language') or 'c'
         if language not in {'c', 'cpp', 'fortran'}:
             raise DependencyException(f'Language {language} is not supported with HDF5.')
 
@@ -111,7 +111,7 @@ class HDF5ConfigToolDependency(ConfigToolDependency):
         try:
             os.environ[f'HDF5_{cenv}'] = join_args(compiler.get_exelist())
             os.environ[f'HDF5_{lenv}LINKER'] = join_args(compiler.get_linker_exelist())
-            super().__init__(name, environment, nkwargs, language)
+            super().__init__(name, environment, nkwargs)
         finally:
             del os.environ[f'HDF5_{cenv}']
             del os.environ[f'HDF5_{lenv}LINKER']
@@ -143,10 +143,10 @@ class HDF5ConfigToolDependency(ConfigToolDependency):
 
 
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL})
-def hdf5_factory(env: 'Environment', for_machine: 'MachineChoice',
-                 kwargs: DependencyObjectKWs, methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
-    language = kwargs.get('language')
+def hdf5_factory(env: 'Environment', kwargs: DependencyObjectKWs,
+                 methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
     candidates: T.List['DependencyGenerator'] = []
+    for_machine = kwargs.get('native', MachineChoice.HOST)
 
     if DependencyMethods.PKGCONFIG in methods:
         # Use an ordered set so that these remain the first tried pkg-config files
@@ -162,10 +162,10 @@ def hdf5_factory(env: 'Environment', for_machine: 'MachineChoice',
                 # use just the standard files if pkg-config --list-all fails
                 pass
         for mod in pkgconfig_files:
-            candidates.append(functools.partial(HDF5PkgConfigDependency, mod, env, kwargs, language))
+            candidates.append(functools.partial(HDF5PkgConfigDependency, mod, env, kwargs))
 
     if DependencyMethods.CONFIG_TOOL in methods:
-        candidates.append(functools.partial(HDF5ConfigToolDependency, 'hdf5', env, kwargs, language))
+        candidates.append(functools.partial(HDF5ConfigToolDependency, 'hdf5', env, kwargs))
 
     return candidates
 
diff --git a/mesonbuild/dependencies/misc.py b/mesonbuild/dependencies/misc.py
index 9c9475574..b5c3f54de 100644
--- a/mesonbuild/dependencies/misc.py
+++ b/mesonbuild/dependencies/misc.py
@@ -27,7 +27,6 @@ if T.TYPE_CHECKING:
 
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE})
 def netcdf_factory(env: 'Environment',
-                   for_machine: 'mesonlib.MachineChoice',
                    kwargs: DependencyObjectKWs,
                    methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
     language = kwargs.get('language')
@@ -44,10 +43,10 @@ def netcdf_factory(env: 'Environment',
         else:
             pkg = 'netcdf'
 
-        candidates.append(functools.partial(PkgConfigDependency, pkg, env, kwargs, language=language))
+        candidates.append(functools.partial(PkgConfigDependency, pkg, env, kwargs))
 
     if DependencyMethods.CMAKE in methods:
-        candidates.append(functools.partial(CMakeDependency, 'NetCDF', env, kwargs, language=language))
+        candidates.append(functools.partial(CMakeDependency, 'NetCDF', env, kwargs))
 
     return candidates
 
@@ -114,8 +113,7 @@ class OpenMPDependency(SystemDependency):
     }
 
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
-        language = kwargs.get('language')
-        super().__init__(name, environment, kwargs, language=language)
+        super().__init__(name, environment, kwargs)
         self.is_found = False
         if self.clib_compiler.get_id() == 'nagfor':
             # No macro defined for OpenMP, but OpenMP 3.1 is supported.
@@ -336,7 +334,7 @@ class CursesConfigToolDependency(ConfigToolDependency):
     # ncurses5.4-config is for macOS Catalina
     tools = ['ncursesw6-config', 'ncursesw5-config', 'ncurses6-config', 'ncurses5-config', 'ncurses5.4-config']
 
-    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None):
+    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs):
         exclude_paths = None
         # macOS mistakenly ships /usr/bin/ncurses5.4-config and a man page for
         # it, but none of the headers or libraries. Ignore /usr/bin because it
@@ -344,7 +342,7 @@ class CursesConfigToolDependency(ConfigToolDependency):
         # Homebrew is /usr/local or /opt/homebrew.
         if env.machines.build and env.machines.build.system == 'darwin':
             exclude_paths = ['/usr/bin']
-        super().__init__(name, env, kwargs, language, exclude_paths=exclude_paths)
+        super().__init__(name, env, kwargs, exclude_paths=exclude_paths)
         if not self.is_found:
             return
         self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
@@ -450,7 +448,7 @@ class IntlSystemDependency(SystemDependency):
             self.is_found = True
 
             if self.static:
-                if not self._add_sub_dependency(iconv_factory(env, self.for_machine, {'static': True})):
+                if not self._add_sub_dependency(iconv_factory(env, {'static': True, 'native': self.for_machine})):
                     self.is_found = False
 
 
@@ -461,6 +459,7 @@ class OpensslSystemDependency(SystemDependency):
         dependency_kwargs: DependencyObjectKWs = {
             'method': DependencyMethods.SYSTEM,
             'static': self.static,
+            'native': kwargs.get('native'),
         }
         if not self.clib_compiler.has_header('openssl/ssl.h', '')[0]:
             return
@@ -478,8 +477,8 @@ class OpensslSystemDependency(SystemDependency):
             self.version = '.'.join(str(i) for i in version_ints[:3]) + chr(ord('a') + version_ints[3] - 1)
 
         if name == 'openssl':
-            if self._add_sub_dependency(libssl_factory(env, self.for_machine, dependency_kwargs)) and \
-                    self._add_sub_dependency(libcrypto_factory(env, self.for_machine, dependency_kwargs)):
+            if self._add_sub_dependency(libssl_factory(env, dependency_kwargs)) and \
+                    self._add_sub_dependency(libcrypto_factory(env, dependency_kwargs)):
                 self.is_found = True
             return
         else:
@@ -491,11 +490,11 @@ class OpensslSystemDependency(SystemDependency):
             self.is_found = True
         else:
             if name == 'libssl':
-                if self._add_sub_dependency(libcrypto_factory(env, self.for_machine, dependency_kwargs)):
+                if self._add_sub_dependency(libcrypto_factory(env, dependency_kwargs)):
                     self.is_found = True
             elif name == 'libcrypto':
                 use_threads = self.clib_compiler.has_header_symbol('openssl/opensslconf.h', 'OPENSSL_THREADS', '', dependencies=[self])[0]
-                if not use_threads or self._add_sub_dependency(threads_factory(env, self.for_machine, {})):
+                if not use_threads or self._add_sub_dependency(threads_factory(env, {'native': self.for_machine})):
                     self.is_found = True
                 # only relevant on platforms where it is distributed with the libc, in which case it always succeeds
                 sublib = self.clib_compiler.find_library('dl', [], self.libtype)
@@ -529,10 +528,10 @@ class ObjFWDependency(ConfigToolDependency):
 
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.SYSTEM})
 def curses_factory(env: 'Environment',
-                   for_machine: 'mesonlib.MachineChoice',
                    kwargs: DependencyObjectKWs,
                    methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
     candidates: T.List['DependencyGenerator'] = []
+    for_machine = kwargs.get('native', mesonlib.MachineChoice.HOST)
 
     if DependencyMethods.PKGCONFIG in methods:
         pkgconfig_files = ['pdcurses', 'ncursesw', 'ncurses', 'curses']
@@ -555,7 +554,6 @@ packages['curses'] = curses_factory
 
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM})
 def shaderc_factory(env: 'Environment',
-                    for_machine: 'mesonlib.MachineChoice',
                     kwargs: DependencyObjectKWs,
                     methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
     """Custom DependencyFactory for ShaderC.
diff --git a/mesonbuild/dependencies/mpi.py b/mesonbuild/dependencies/mpi.py
index 8a0ac0a9c..60e4c5828 100644
--- a/mesonbuild/dependencies/mpi.py
+++ b/mesonbuild/dependencies/mpi.py
@@ -8,6 +8,7 @@ import typing as T
 import os
 import re
 
+from ..mesonlib import MachineChoice
 from ..envconfig import detect_cpu_family
 from ..mesonlib import Popen_safe
 from .base import DependencyException, DependencyMethods, detect_compiler, SystemDependency
@@ -19,22 +20,20 @@ from .pkgconfig import PkgConfigDependency
 if T.TYPE_CHECKING:
     from .factory import DependencyGenerator
     from ..environment import Environment
-    from ..mesonlib import MachineChoice
     from .base import DependencyObjectKWs
 
 
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.SYSTEM})
 def mpi_factory(env: 'Environment',
-                for_machine: 'MachineChoice',
                 kwargs: DependencyObjectKWs,
                 methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
-    language = kwargs.get('language')
-    if language is None:
-        language = 'c'
+    language = kwargs.get('language') or 'c'
     if language not in {'c', 'cpp', 'fortran'}:
         # OpenMPI doesn't work without any other languages
         return []
 
+    for_machine = kwargs.get('native', MachineChoice.HOST)
+
     candidates: T.List['DependencyGenerator'] = []
     compiler = detect_compiler('mpi', env, for_machine, language)
     if not compiler:
@@ -78,13 +77,13 @@ def mpi_factory(env: 'Environment',
 
         nwargs['tools'] = tool_names
         candidates.append(functools.partial(
-            MPIConfigToolDependency, tool_names[0], env, nwargs, language=language))
+            MPIConfigToolDependency, tool_names[0], env, nwargs))
 
     if DependencyMethods.SYSTEM in methods and env.machines[for_machine].is_windows():
         candidates.append(functools.partial(
-            MSMPIDependency, 'msmpi', env, kwargs, language=language))
+            MSMPIDependency, 'msmpi', env, kwargs))
         candidates.append(functools.partial(
-            IMPIDependency, 'impi', env, kwargs, language=language))
+            IMPIDependency, 'impi', env, kwargs))
 
     # Only OpenMPI has pkg-config, and it doesn't work with the intel compilers
     # for MPI, environment variables and commands like mpicc should have priority
@@ -97,7 +96,7 @@ def mpi_factory(env: 'Environment',
         elif language == 'fortran':
             pkg_name = 'ompi-fort'
         candidates.append(functools.partial(
-            PkgConfigDependency, pkg_name, env, kwargs, language=language))
+            PkgConfigDependency, pkg_name, env, kwargs))
 
     return candidates
 
@@ -107,9 +106,8 @@ packages['mpi'] = mpi_factory
 class MPIConfigToolDependency(ConfigToolDependency):
     """Wrapper around mpicc, Intel's mpiicc and friends."""
 
-    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs,
-                 language: T.Optional[str] = None):
-        super().__init__(name, env, kwargs, language=language)
+    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs):
+        super().__init__(name, env, kwargs)
         if not self.is_found:
             return
 
@@ -217,11 +215,10 @@ class MSMPIDependency(SystemDependency):
 
     """The Microsoft MPI."""
 
-    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs,
-                 language: T.Optional[str] = None):
-        super().__init__(name, env, kwargs, language=language)
+    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs):
+        super().__init__(name, env, kwargs)
         # MSMPI only supports the C API
-        if language not in {'c', 'fortran', None}:
+        if self.language not in {'c', 'fortran', None}:
             self.is_found = False
             return
         # MSMPI is only for windows, obviously
@@ -253,9 +250,8 @@ class IMPIDependency(SystemDependency):
 
     """Intel(R) MPI for Windows."""
 
-    def __init__(self, name: str, env: Environment, kwargs: DependencyObjectKWs,
-                 language: T.Optional[str] = None):
-        super().__init__(name, env, kwargs, language=language)
+    def __init__(self, name: str, env: Environment, kwargs: DependencyObjectKWs):
+        super().__init__(name, env, kwargs)
         # only for windows
         if not self.env.machines[self.for_machine].is_windows():
             return
diff --git a/mesonbuild/dependencies/pkgconfig.py b/mesonbuild/dependencies/pkgconfig.py
index c27841eea..938c77da4 100644
--- a/mesonbuild/dependencies/pkgconfig.py
+++ b/mesonbuild/dependencies/pkgconfig.py
@@ -309,9 +309,8 @@ class PkgConfigDependency(ExternalDependency):
     type_name = DependencyTypeName('pkgconfig')
 
     def __init__(self, name: str, environment: Environment, kwargs: DependencyObjectKWs,
-                 language: T.Optional[str] = None,
                  extra_paths: T.Optional[T.List[str]] = None) -> None:
-        super().__init__(name, environment, kwargs, language=language)
+        super().__init__(name, environment, kwargs)
         self.is_libtool = False
         self.extra_paths = extra_paths or []
         pkgconfig = PkgConfigInterface.instance(self.env, self.for_machine, self.silent, self.extra_paths)
diff --git a/mesonbuild/dependencies/python.py b/mesonbuild/dependencies/python.py
index f979e705e..ad9262981 100644
--- a/mesonbuild/dependencies/python.py
+++ b/mesonbuild/dependencies/python.py
@@ -15,6 +15,7 @@ from .factory import DependencyFactory
 from .framework import ExtraFrameworkDependency
 from .pkgconfig import PkgConfigDependency
 from ..envconfig import detect_cpu_family
+from ..mesonlib import MachineChoice
 from ..programs import ExternalProgram
 from ..options import OptionKey
 
@@ -23,7 +24,6 @@ if T.TYPE_CHECKING:
 
     from .factory import DependencyGenerator
     from ..environment import Environment
-    from ..mesonlib import MachineChoice
     from .base import DependencyObjectKWs
 
     class PythonIntrospectionDict(TypedDict):
@@ -248,9 +248,9 @@ class BasicPythonExternalProgram(ExternalProgram):
 
 class _PythonDependencyBase(_Base):
 
-    def __init__(self, python_holder: 'BasicPythonExternalProgram', embed: bool,
-                 for_machine: 'MachineChoice'):
-        self.for_machine = for_machine
+    for_machine: MachineChoice
+
+    def __init__(self, python_holder: 'BasicPythonExternalProgram', embed: bool):
         self.embed = embed
         self.build_config = python_holder.build_config
 
@@ -459,8 +459,8 @@ class PythonPkgConfigDependency(PkgConfigDependency, _PythonDependencyBase):
 
     # name is needed for polymorphism
     def __init__(self, name: str, environment: Environment, kwargs: DependencyObjectKWs,
-                 installation: 'BasicPythonExternalProgram', embed: bool,
-                 for_machine: 'MachineChoice'):
+                 installation: 'BasicPythonExternalProgram'):
+        embed = kwargs.get('embed', False)
         pkg_embed = '-embed' if embed and mesonlib.version_compare(installation.info['version'], '>=3.8') else ''
         pkg_name = f'python-{installation.version}{pkg_embed}'
 
@@ -478,6 +478,7 @@ class PythonPkgConfigDependency(PkgConfigDependency, _PythonDependencyBase):
             self.is_found = False
             return
 
+        for_machine = kwargs.get('native', MachineChoice.HOST)
         sysroot = environment.properties[for_machine].get_sys_root() or ''
         pkg_libdir = sysroot + pkg_libdir
 
@@ -485,7 +486,7 @@ class PythonPkgConfigDependency(PkgConfigDependency, _PythonDependencyBase):
         pkgconfig_paths = [pkg_libdir] if pkg_libdir else []
 
         PkgConfigDependency.__init__(self, pkg_name, environment, kwargs, extra_paths=pkgconfig_paths)
-        _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False), for_machine)
+        _PythonDependencyBase.__init__(self, installation, embed)
 
         if pkg_libdir and not self.is_found:
             mlog.debug(f'{pkg_name!r} could not be found in {pkg_libdir_origin}, '
@@ -510,19 +511,17 @@ class PythonPkgConfigDependency(PkgConfigDependency, _PythonDependencyBase):
 class PythonFrameworkDependency(ExtraFrameworkDependency, _PythonDependencyBase):
 
     def __init__(self, name: str, environment: 'Environment',
-                 kwargs: DependencyObjectKWs, installation: 'BasicPythonExternalProgram',
-                 for_machine: 'MachineChoice'):
+                 kwargs: DependencyObjectKWs, installation: 'BasicPythonExternalProgram'):
         ExtraFrameworkDependency.__init__(self, name, environment, kwargs)
-        _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False), for_machine)
+        _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
 
 
 class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
 
     def __init__(self, name: str, environment: 'Environment',
-                 kwargs: DependencyObjectKWs, installation: 'BasicPythonExternalProgram',
-                 for_machine: 'MachineChoice'):
+                 kwargs: DependencyObjectKWs, installation: 'BasicPythonExternalProgram'):
         SystemDependency.__init__(self, name, environment, kwargs)
-        _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False), for_machine)
+        _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
 
         # For most platforms, match pkg-config behavior. iOS is a special case;
         # check for that first, so that check takes priority over
@@ -542,7 +541,7 @@ class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
 
         # compile args
         if self.build_config:
-            sysroot = environment.properties[for_machine].get_sys_root() or ''
+            sysroot = environment.properties[self.for_machine].get_sys_root() or ''
             inc_paths = mesonlib.OrderedSet([sysroot + self.build_config['c_api']['headers']])
         else:
             inc_paths = mesonlib.OrderedSet([
@@ -564,13 +563,11 @@ class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
     def log_tried() -> str:
         return 'sysconfig'
 
-def python_factory(env: 'Environment', for_machine: 'MachineChoice',
-                   kwargs: DependencyObjectKWs,
+def python_factory(env: 'Environment', kwargs: DependencyObjectKWs,
                    installation: T.Optional['BasicPythonExternalProgram'] = None) -> T.List['DependencyGenerator']:
     # We can't use the factory_methods decorator here, as we need to pass the
     # extra installation argument
     methods = process_method_kw({DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM}, kwargs)
-    embed = kwargs.get('embed', False)
     candidates: T.List['DependencyGenerator'] = []
     from_installation = installation is not None
     # When not invoked through the python module, default installation.
@@ -580,12 +577,12 @@ def python_factory(env: 'Environment', for_machine: 'MachineChoice',
 
     if DependencyMethods.PKGCONFIG in methods:
         if from_installation:
-            candidates.append(functools.partial(PythonPkgConfigDependency, 'python3', env, kwargs, installation, embed, for_machine))
+            candidates.append(functools.partial(PythonPkgConfigDependency, 'python3', env, kwargs, installation))
         else:
             candidates.append(functools.partial(PkgConfigDependency, 'python3', env, kwargs))
 
     if DependencyMethods.SYSTEM in methods:
-        candidates.append(functools.partial(PythonSystemDependency, 'python', env, kwargs, installation, for_machine))
+        candidates.append(functools.partial(PythonSystemDependency, 'python', env, kwargs, installation))
 
     if DependencyMethods.EXTRAFRAMEWORK in methods:
         nkwargs = kwargs.copy()
@@ -593,7 +590,7 @@ def python_factory(env: 'Environment', for_machine: 'MachineChoice',
             # There is a python in /System/Library/Frameworks, but that's python 2.x,
             # Python 3 will always be in /Library
             nkwargs['paths'] = ['/Library/Frameworks']
-        candidates.append(functools.partial(PythonFrameworkDependency, 'Python', env, nkwargs, installation, for_machine))
+        candidates.append(functools.partial(PythonFrameworkDependency, 'Python', env, nkwargs, installation))
 
     return candidates
 
diff --git a/mesonbuild/dependencies/qt.py b/mesonbuild/dependencies/qt.py
index c245e5c8c..63ba9071b 100644
--- a/mesonbuild/dependencies/qt.py
+++ b/mesonbuild/dependencies/qt.py
@@ -97,8 +97,8 @@ def _get_modules_lib_suffix(version: str, info: 'MachineInfo', is_debug: bool) -
 
 
 class QtExtraFrameworkDependency(ExtraFrameworkDependency):
-    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs, qvars: T.Dict[str, str], language: T.Optional[str] = None):
-        super().__init__(name, env, kwargs, language=language)
+    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs, qvars: T.Dict[str, str]):
+        super().__init__(name, env, kwargs)
         self.mod_name = name[2:]
         self.qt_extra_include_directory = qvars['QT_INSTALL_HEADERS']
 
@@ -185,7 +185,7 @@ class QtPkgConfigDependency(_QtBase, PkgConfigDependency, metaclass=abc.ABCMeta)
             self.link_args = []
 
         for m in self.requested_modules:
-            mod = PkgConfigDependency(self.qtpkgname + m, self.env, kwargs, language=self.language)
+            mod = PkgConfigDependency(self.qtpkgname + m, self.env, kwargs)
             if not mod.found():
                 self.is_found = False
                 return
@@ -357,11 +357,12 @@ class QmakeQtDependency(_QtBase, ConfigToolDependency, metaclass=abc.ABCMeta):
         fw_kwargs = kwargs.copy()
         fw_kwargs.pop('method')
         fw_kwargs['paths'] = [libdir]
+        fw_kwargs['language'] = self.language
 
         for m in modules:
             fname = 'Qt' + m
             mlog.debug('Looking for qt framework ' + fname)
-            fwdep = QtExtraFrameworkDependency(fname, self.env, fw_kwargs, qvars, language=self.language)
+            fwdep = QtExtraFrameworkDependency(fname, self.env, fw_kwargs, qvars)
             if fwdep.found():
                 self.compile_args.append('-F' + libdir)
                 self.compile_args += fwdep.get_compile_args(with_private_headers=self.private_headers,
diff --git a/mesonbuild/dependencies/scalapack.py b/mesonbuild/dependencies/scalapack.py
index 26a6e3904..18bc5fce6 100644
--- a/mesonbuild/dependencies/scalapack.py
+++ b/mesonbuild/dependencies/scalapack.py
@@ -17,13 +17,12 @@ from .factory import factory_methods
 
 if T.TYPE_CHECKING:
     from ..environment import Environment
-    from ..mesonlib import MachineChoice
     from .factory import DependencyGenerator
     from .base import DependencyObjectKWs
 
 
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE})
-def scalapack_factory(env: 'Environment', for_machine: 'MachineChoice',
+def scalapack_factory(env: 'Environment',
                       kwargs: DependencyObjectKWs,
                       methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
     candidates: T.List['DependencyGenerator'] = []
@@ -55,15 +54,14 @@ class MKLPkgConfigDependency(PkgConfigDependency):
     bunch of fixups to make it work correctly.
     """
 
-    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs,
-                 language: T.Optional[str] = None):
+    def __init__(self, name: str, env: 'Environment', kwargs: DependencyObjectKWs):
         _m = os.environ.get('MKLROOT')
         self.__mklroot = Path(_m).resolve() if _m else None
 
         # We need to call down into the normal super() method even if we don't
         # find mklroot, otherwise we won't have all of the instance variables
         # initialized that meson expects.
-        super().__init__(name, env, kwargs, language=language)
+        super().__init__(name, env, kwargs)
 
         # Doesn't work with gcc on windows, but does on Linux
         if env.machines[self.for_machine].is_windows() and self.clib_compiler.id == 'gcc':
diff --git a/mesonbuild/dependencies/ui.py b/mesonbuild/dependencies/ui.py
index fb6fbcfaa..74405fd20 100644
--- a/mesonbuild/dependencies/ui.py
+++ b/mesonbuild/dependencies/ui.py
@@ -57,7 +57,8 @@ class GnuStepDependency(ConfigToolDependency):
     tool_name = 'gnustep-config'
 
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
-        super().__init__(name, environment, kwargs, language='objc')
+        kwargs['language'] = 'objc'
+        super().__init__(name, environment, kwargs)
         if not self.is_found:
             return
         self.modules = kwargs.get('modules', [])
@@ -151,7 +152,8 @@ class WxDependency(ConfigToolDependency):
     # name is intentionally ignored to maintain existing capitalization,
     # but is needed for polymorphism
     def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs):
-        super().__init__('WxWidgets', environment, kwargs, language='cpp')
+        kwargs['language'] = 'cpp'
+        super().__init__('WxWidgets', environment, kwargs)
         if not self.is_found:
             return
         self.requested_modules = kwargs.get('modules', [])
@@ -176,8 +178,8 @@ packages['wxwidgets'] = WxDependency
 
 class VulkanDependencySystem(SystemDependency):
 
-    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs, language: T.Optional[str] = None) -> None:
-        super().__init__(name, environment, kwargs, language=language)
+    def __init__(self, name: str, environment: 'Environment', kwargs: DependencyObjectKWs) -> None:
+        super().__init__(name, environment, kwargs)
 
         self.vulkan_sdk = os.environ.get('VULKAN_SDK', os.environ.get('VK_SDK_PATH'))
         if self.vulkan_sdk and not os.path.isabs(self.vulkan_sdk):
diff --git a/mesonbuild/modules/python.py b/mesonbuild/modules/python.py
index 78798e5c0..96ba1e0f0 100644
--- a/mesonbuild/modules/python.py
+++ b/mesonbuild/modules/python.py
@@ -272,7 +272,7 @@ class PythonInstallation(_ExternalProgramHolder['PythonExternalProgram']):
         new_kwargs['required'] = False
         if build_config:
             new_kwargs['build_config'] = build_config
-        candidates = python_factory(self.interpreter.environment, for_machine, new_kwargs, self.held_object)
+        candidates = python_factory(self.interpreter.environment, new_kwargs, self.held_object)
         dep = find_external_dependency('python', self.interpreter.environment, new_kwargs, candidates)
 
         self.interpreter.coredata.deps[for_machine].put(identifier, dep)