Dependencies: Make use of the DependencyCandidate class

This makes the type checking more reasonable (including fixing an issue
that newer mypy is pointing out to us), consolidating special cases, and
improving code readability.

12 files changed, 185 insertions, 173 deletions

diff --git a/mesonbuild/dependencies/cmake.py b/mesonbuild/dependencies/cmake.py
index 07855ef4a..768797962 100644
--- a/mesonbuild/dependencies/cmake.py
+++ b/mesonbuild/dependencies/cmake.py
@@ -645,22 +645,6 @@ class CMakeDependency(ExternalDependency):
         raise DependencyException(f'Could not get cmake variable and no default provided for {self!r}')
 
 
-class CMakeDependencyFactory:
-
-    def __init__(self, name: T.Optional[str] = None, modules: T.Optional[T.List[str]] = None):
-        self.name = name
-        self.modules = modules
-
-    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, force_use_global_compilers)
-
-    @staticmethod
-    def log_tried() -> str:
-        return CMakeDependency.log_tried()
-
-
 def sort_link_args(args: T.List[str]) -> T.List[str]:
     itr = iter(args)
     result: T.Set[T.Union[T.Tuple[str], T.Tuple[str, str]]] = set()
diff --git a/mesonbuild/dependencies/coarrays.py b/mesonbuild/dependencies/coarrays.py
index e261f2209..dda4286d6 100644
--- a/mesonbuild/dependencies/coarrays.py
+++ b/mesonbuild/dependencies/coarrays.py
@@ -3,10 +3,9 @@
 
 from __future__ import annotations
 
-import functools
 import typing as T
 
-from .base import DependencyMethods, detect_compiler, SystemDependency
+from .base import DependencyCandidate, DependencyMethods, detect_compiler, SystemDependency
 from .cmake import CMakeDependency
 from .detect import packages
 from .pkgconfig import PkgConfigDependency
@@ -31,19 +30,24 @@ def coarray_factory(env: 'Environment',
         # OpenCoarrays is the most commonly used method for Fortran Coarray with GCC
         if DependencyMethods.PKGCONFIG in methods:
             for pkg in ['caf-openmpi', 'caf']:
-                candidates.append(functools.partial(
-                    PkgConfigDependency, pkg, env, kwargs))
+                candidates.append(DependencyCandidate.from_dependency(
+                    pkg, PkgConfigDependency, (env, kwargs)))
 
         if DependencyMethods.CMAKE in methods:
+            nkwargs = kwargs
             if not kwargs.get('modules'):
-                kwargs['modules'] = ['OpenCoarrays::caf_mpi']
-            candidates.append(functools.partial(
-                CMakeDependency, 'OpenCoarrays', env, kwargs))
+                nkwargs = kwargs.copy()
+                nkwargs['modules'] = ['OpenCoarrays::caf_mpi']
+            candidates.append(DependencyCandidate.from_dependency(
+                'OpenCoarrays', CMakeDependency, (env, nkwargs)))
 
     if DependencyMethods.SYSTEM in methods:
-        candidates.append(functools.partial(CoarrayDependency, 'coarray', env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            'coarray', CoarrayDependency, (env, kwargs)))
 
     return candidates
+
+
 packages['coarray'] = coarray_factory
 
 
diff --git a/mesonbuild/dependencies/detect.py b/mesonbuild/dependencies/detect.py
index 206742d1b..295689db2 100644
--- a/mesonbuild/dependencies/detect.py
+++ b/mesonbuild/dependencies/detect.py
@@ -3,23 +3,23 @@
 
 from __future__ import annotations
 
-import collections, functools, importlib
+import collections, importlib
 import enum
 import typing as T
 
-from .base import ExternalDependency, DependencyException, DependencyMethods, NotFoundDependency
+from .base import DependencyCandidate, ExternalDependency, DependencyException, DependencyMethods, NotFoundDependency
 
-from ..mesonlib import listify, PerMachine
+from ..mesonlib import listify, PerMachine, MesonBugException
 from .. import mlog
 
 if T.TYPE_CHECKING:
     from ..environment import Environment
-    from .factory import DependencyFactory, WrappedFactoryFunc, DependencyGenerator
+    from .factory import DependencyFactory, DependencyGenerator, WrappedFactoryFunc
     from .base import DependencyObjectKWs
 
     TV_DepIDEntry = T.Union[str, bool, int, None, T.Tuple[str, ...]]
     TV_DepID = T.Tuple[T.Tuple[str, TV_DepIDEntry], ...]
-    PackageTypes = T.Union[T.Type[ExternalDependency], DependencyFactory, WrappedFactoryFunc]
+    PackageTypes = T.Union[T.Type[ExternalDependency], DependencyFactory, DependencyCandidate, WrappedFactoryFunc]
     # Workaround for older python
     DependencyPackagesType = collections.UserDict[str, PackageTypes]
 else:
@@ -120,8 +120,7 @@ def find_external_dependency(name: str, env: 'Environment', kwargs: DependencyOb
             d._check_version()
             pkgdep.append(d)
         except DependencyException as e:
-            assert isinstance(c, functools.partial), 'for mypy'
-            bettermsg = f'Dependency lookup for {name} with method {c.func.log_tried()!r} failed: {e}'
+            bettermsg = f'Dependency lookup for {name} with method {c.method!r} failed: {e}'
             mlog.debug(bettermsg)
             e.args = (bettermsg,)
             pkg_exc.append(e)
@@ -178,17 +177,17 @@ def _build_external_dependency_list(name: str, env: 'Environment', kwargs: Depen
     # Is there a specific dependency detector for this dependency?
     lname = name.lower()
     if lname in packages:
-        # Create the list of dependency object constructors using a factory
-        # class method, if one exists, otherwise the list just consists of the
-        # constructor
-        if isinstance(packages[lname], type):
-            entry1 = T.cast('T.Type[ExternalDependency]', packages[lname])  # mypy doesn't understand isinstance(..., type)
-            if issubclass(entry1, ExternalDependency):
-                func: T.Callable[[], 'ExternalDependency'] = functools.partial(entry1, env, kwargs)
-                dep = [func]
+        entry = packages[lname]
+        if isinstance(entry, type):
+            if issubclass(entry, ExternalDependency):
+                dep = [DependencyCandidate.from_dependency(name, entry, (env, kwargs))]
+            else:
+                raise MesonBugException(f'Got an invalid type in the dependency list: {entry!r}')
+        elif isinstance(entry, DependencyCandidate):
+            entry.arguments = (env, kwargs)
+            dep = [entry]
         else:
-            entry2 = T.cast('T.Union[DependencyFactory, WrappedFactoryFunc]', packages[lname])
-            dep = entry2(env, kwargs)
+            dep = entry(env, kwargs)
         return dep
 
     candidates: T.List['DependencyGenerator'] = []
@@ -204,24 +203,24 @@ def _build_external_dependency_list(name: str, env: 'Environment', kwargs: Depen
     # Exclusive to when it is explicitly requested
     if DependencyMethods.DUB in methods:
         from .dub import DubDependency
-        candidates.append(functools.partial(DubDependency, name, env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(name, DubDependency, (env, kwargs)))
 
     # Preferred first candidate for auto.
     if DependencyMethods.PKGCONFIG in methods:
         from .pkgconfig import PkgConfigDependency
-        candidates.append(functools.partial(PkgConfigDependency, name, env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(name, PkgConfigDependency, (env, kwargs)))
 
     # On OSX only, try framework dependency detector.
     if DependencyMethods.EXTRAFRAMEWORK in methods:
         if env.machines[kwargs['native']].is_darwin():
             from .framework import ExtraFrameworkDependency
-            candidates.append(functools.partial(ExtraFrameworkDependency, name, env, kwargs))
+            candidates.append(DependencyCandidate.from_dependency(name, ExtraFrameworkDependency, (env, kwargs)))
 
     # Only use CMake:
     # - if it's explicitly requested
     # - as a last resort, since it might not work 100% (see #6113)
     if DependencyMethods.CMAKE in methods:
         from .cmake import CMakeDependency
-        candidates.append(functools.partial(CMakeDependency, name, env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(name, CMakeDependency, (env, kwargs)))
 
     return candidates
diff --git a/mesonbuild/dependencies/dev.py b/mesonbuild/dependencies/dev.py
index 6e24251cd..4b043a07e 100644
--- a/mesonbuild/dependencies/dev.py
+++ b/mesonbuild/dependencies/dev.py
@@ -17,7 +17,7 @@ from mesonbuild.interpreterbase.decorators import FeatureDeprecated
 from .. import mesonlib, mlog
 from ..tooldetect import get_llvm_tool_names
 from ..mesonlib import version_compare, version_compare_many, search_version
-from .base import DependencyException, DependencyMethods, detect_compiler, strip_system_includedirs, strip_system_libdirs, SystemDependency, ExternalDependency
+from .base import DependencyException, DependencyMethods, detect_compiler, strip_system_includedirs, strip_system_libdirs, SystemDependency, ExternalDependency, DependencyCandidate
 from .cmake import CMakeDependency
 from .configtool import ConfigToolDependency
 from .detect import packages
@@ -802,27 +802,27 @@ packages['diasdk'] = DiaSDKSystemDependency
 packages['llvm'] = llvm_factory = DependencyFactory(
     'LLVM',
     [DependencyMethods.CMAKE, DependencyMethods.CONFIG_TOOL],
-    cmake_class=LLVMDependencyCMake,
-    configtool_class=LLVMDependencyConfigTool,
+    cmake=LLVMDependencyCMake,
+    configtool=LLVMDependencyConfigTool,
 )
 
 packages['gtest'] = gtest_factory = DependencyFactory(
     'gtest',
     [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
-    pkgconfig_class=GTestDependencyPC,
-    system_class=GTestDependencySystem,
+    pkgconfig=GTestDependencyPC,
+    system=GTestDependencySystem,
 )
 
 packages['gmock'] = gmock_factory = DependencyFactory(
     'gmock',
     [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
-    pkgconfig_class=GMockDependencyPC,
-    system_class=GMockDependencySystem,
+    pkgconfig=GMockDependencyPC,
+    system=GMockDependencySystem,
 )
 
 packages['zlib'] = zlib_factory = DependencyFactory(
     'zlib',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE, DependencyMethods.SYSTEM],
-    cmake_name='ZLIB',
-    system_class=ZlibSystemDependency,
+    cmake=DependencyCandidate.from_dependency('ZLIB', CMakeDependency),
+    system=ZlibSystemDependency,
 )
diff --git a/mesonbuild/dependencies/factory.py b/mesonbuild/dependencies/factory.py
index e89adcbb5..02652e5e7 100644
--- a/mesonbuild/dependencies/factory.py
+++ b/mesonbuild/dependencies/factory.py
@@ -8,7 +8,7 @@ import functools
 import typing as T
 
 from ..mesonlib import MachineChoice
-from .base import DependencyException, DependencyMethods
+from .base import DependencyCandidate, DependencyException, DependencyMethods
 from .base import process_method_kw
 from .base import BuiltinDependency, SystemDependency
 from .cmake import CMakeDependency
@@ -16,11 +16,14 @@ from .framework import ExtraFrameworkDependency
 from .pkgconfig import PkgConfigDependency
 
 if T.TYPE_CHECKING:
-    from .base import DependencyObjectKWs, ExternalDependency
+    from typing_extensions import TypeAlias
+
+    from .base import DependencyObjectKWs, ExternalDependency, DepType
     from .configtool import ConfigToolDependency
     from ..environment import Environment
 
-    DependencyGenerator = T.Callable[[], ExternalDependency]
+    # TODO: remove this?
+    DependencyGenerator: TypeAlias = DependencyCandidate[ExternalDependency]
     FactoryFunc = T.Callable[
         [
             'Environment',
@@ -38,10 +41,6 @@ if T.TYPE_CHECKING:
         T.List[DependencyGenerator]
     ]
 
-    # This should be str, Environment, T.Dict[str, T.Any], T.Optional[str]
-    # But if you try that, you get error: Cannot infer type of lambda
-    CmakeDependencyFunc = T.Callable[..., CMakeDependency]
-
 class DependencyFactory:
 
     """Factory to get dependencies from multiple sources.
@@ -50,53 +49,61 @@ class DependencyFactory:
     for various kinds of dependencies. When the initialized object is called
     it returns a list of callables return Dependency objects to try in order.
 
-    :name: The name of the dependency. This will be passed as the name
+    :param name: The name of the dependency. This will be passed as the name
         parameter of the each dependency unless it is overridden on a per
         type basis.
-    :methods: An ordered list of DependencyMethods. This is the order
+    :param methods: An ordered list of DependencyMethods. This is the order
         dependencies will be returned in unless they are removed by the
         _process_method function
-    :*_name: This will overwrite the name passed to the corresponding class.
-        For example, if the name is 'zlib', but cmake calls the dependency
-        'Z', then using `cmake_name='Z'` will pass the name as 'Z' to cmake.
-    :*_class: A *type* or callable that creates a class, and has the
-        signature of an ExternalDependency
-    :system_class: If you pass DependencyMethods.SYSTEM in methods, you must
-        set this argument.
+    :param extra_kwargs: Additional keyword arguments to add when creating the
+        DependencyCandidate
+    :param pkgconfig: A custom PackageConfig lookup to use
+    :param cmake: A custom CMake lookup to use
+    :param framework: A custom AppleFramework lookup to use
+    :param configtool: A custom ConfigTool lookup to use. If
+        DependencyMethods.CONFIG_TOOL is in the `:param:methods` argument,
+        this must be set.
+    :param builtin: A custom Builtin lookup to use. If
+        DependencyMethods.BUILTIN is in the `:param:methods` argument,
+        this must be set.
+    :param system: A custom System lookup to use. If
+        DependencyMethods.SYSTEM is in the `:param:methods` argument,
+        this must be set.
     """
 
     def __init__(self, name: str, methods: T.List[DependencyMethods], *,
                  extra_kwargs: T.Optional[DependencyObjectKWs] = None,
-                 pkgconfig_name: T.Optional[str] = None,
-                 pkgconfig_class: 'T.Type[PkgConfigDependency]' = PkgConfigDependency,
-                 cmake_name: T.Optional[str] = None,
-                 cmake_class: 'T.Union[T.Type[CMakeDependency], CmakeDependencyFunc]' = CMakeDependency,
-                 configtool_class: 'T.Optional[T.Type[ConfigToolDependency]]' = None,
-                 framework_name: T.Optional[str] = None,
-                 framework_class: 'T.Type[ExtraFrameworkDependency]' = ExtraFrameworkDependency,
-                 builtin_class: 'T.Type[BuiltinDependency]' = BuiltinDependency,
-                 system_class: 'T.Type[SystemDependency]' = SystemDependency):
-
-        if DependencyMethods.CONFIG_TOOL in methods and not configtool_class:
-            raise DependencyException('A configtool must have a custom class')
+                 pkgconfig: T.Union[DependencyCandidate[PkgConfigDependency], T.Type[PkgConfigDependency], None] = PkgConfigDependency,
+                 cmake: T.Union[DependencyCandidate[CMakeDependency], T.Type[CMakeDependency], None] = CMakeDependency,
+                 framework: T.Union[DependencyCandidate[ExtraFrameworkDependency], T.Type[ExtraFrameworkDependency], None] = ExtraFrameworkDependency,
+                 configtool: T.Union[DependencyCandidate[ConfigToolDependency], T.Type[ConfigToolDependency], None] = None,
+                 builtin: T.Union[DependencyCandidate[BuiltinDependency], T.Type[BuiltinDependency], None] = None,
+                 system: T.Union[DependencyCandidate[SystemDependency], T.Type[SystemDependency], None] = None):
+
+        if DependencyMethods.CONFIG_TOOL in methods and not configtool:
+            raise DependencyException('A configtool dependency must have a custom class')
+        if DependencyMethods.BUILTIN in methods and not builtin:
+            raise DependencyException('A builtin dependency must have a custom class')
+        if DependencyMethods.SYSTEM in methods and not system:
+            raise DependencyException('A system dependency must have a custom class')
+
+        def make(arg: T.Union[DependencyCandidate[DepType], T.Type[DepType], None]) -> T.Optional[DependencyCandidate[DepType]]:
+            if arg is None or isinstance(arg, DependencyCandidate):
+                return arg
+            return DependencyCandidate.from_dependency(name, arg)
 
         self.extra_kwargs = extra_kwargs
         self.methods = methods
-        self.classes: T.Dict[
-            DependencyMethods,
-            T.Callable[['Environment', DependencyObjectKWs], ExternalDependency]
-        ] = {
+        self.classes: T.Mapping[DependencyMethods, T.Optional[DependencyCandidate[ExternalDependency]]] = {
             # Just attach the correct name right now, either the generic name
             # or the method specific name.
-            DependencyMethods.EXTRAFRAMEWORK: functools.partial(framework_class, framework_name or name),
-            DependencyMethods.PKGCONFIG: functools.partial(pkgconfig_class, pkgconfig_name or name),
-            DependencyMethods.CMAKE: functools.partial(cmake_class, cmake_name or name),
-            DependencyMethods.SYSTEM: functools.partial(system_class, name),
-            DependencyMethods.BUILTIN: functools.partial(builtin_class, name),
-            DependencyMethods.CONFIG_TOOL: None,
+            DependencyMethods.EXTRAFRAMEWORK: make(framework),
+            DependencyMethods.PKGCONFIG: make(pkgconfig),
+            DependencyMethods.CMAKE: make(cmake),
+            DependencyMethods.SYSTEM: make(system),
+            DependencyMethods.BUILTIN: make(builtin),
+            DependencyMethods.CONFIG_TOOL: make(configtool),
         }
-        if configtool_class is not None:
-            self.classes[DependencyMethods.CONFIG_TOOL] = functools.partial(configtool_class, name)
 
     @staticmethod
     def _process_method(method: DependencyMethods, env: 'Environment', for_machine: MachineChoice) -> bool:
@@ -122,9 +129,15 @@ class DependencyFactory:
         else:
             nwargs = kwargs.copy()
 
-        for_machine = kwargs['native']
-        return [functools.partial(self.classes[m], env, nwargs) for m in methods
-                if self._process_method(m, env, for_machine)]
+        ret: T.List[DependencyGenerator] = []
+        for m in methods:
+            if self._process_method(m, env, kwargs['native']):
+                c = self.classes[m]
+                if c is None:
+                    continue
+                c.arguments = (env, nwargs)
+                ret.append(c)
+        return ret
 
 
 def factory_methods(methods: T.Set[DependencyMethods]) -> T.Callable[['FactoryFunc'], 'WrappedFactoryFunc']:
diff --git a/mesonbuild/dependencies/hdf5.py b/mesonbuild/dependencies/hdf5.py
index 4effc6ce8..2c020669a 100644
--- a/mesonbuild/dependencies/hdf5.py
+++ b/mesonbuild/dependencies/hdf5.py
@@ -4,13 +4,12 @@
 # This file contains the detection logic for miscellaneous external dependencies.
 from __future__ import annotations
 
-import functools
 import os
 import re
 from pathlib import Path
 
 from ..mesonlib import OrderedSet, join_args
-from .base import DependencyException, DependencyMethods
+from .base import DependencyCandidate, DependencyException, DependencyMethods
 from .configtool import ConfigToolDependency
 from .detect import packages
 from .pkgconfig import PkgConfigDependency, PkgConfigInterface
@@ -161,10 +160,12 @@ def hdf5_factory(env: 'Environment', kwargs: DependencyObjectKWs,
                 # 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))
+            candidates.append(DependencyCandidate.from_dependency(
+                mod, HDF5PkgConfigDependency, (env, kwargs)))
 
     if DependencyMethods.CONFIG_TOOL in methods:
-        candidates.append(functools.partial(HDF5ConfigToolDependency, 'hdf5', env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            'hd5f', HDF5ConfigToolDependency, (env, kwargs)))
 
     return candidates
 
diff --git a/mesonbuild/dependencies/misc.py b/mesonbuild/dependencies/misc.py
index 586930d34..1f9f06e97 100644
--- a/mesonbuild/dependencies/misc.py
+++ b/mesonbuild/dependencies/misc.py
@@ -4,15 +4,14 @@
 # This file contains the detection logic for miscellaneous external dependencies.
 from __future__ import annotations
 
-import functools
 import re
 import typing as T
 
 from .. import mesonlib
 from .. import mlog
-from .base import DependencyException, DependencyMethods
+from .base import DependencyCandidate, DependencyException, DependencyMethods
 from .base import BuiltinDependency, SystemDependency
-from .cmake import CMakeDependency, CMakeDependencyFactory
+from .cmake import CMakeDependency
 from .configtool import ConfigToolDependency
 from .detect import packages
 from .factory import DependencyFactory, factory_methods
@@ -43,10 +42,12 @@ def netcdf_factory(env: 'Environment',
         else:
             pkg = 'netcdf'
 
-        candidates.append(functools.partial(PkgConfigDependency, pkg, env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            pkg, PkgConfigDependency, (env, kwargs)))
 
     if DependencyMethods.CMAKE in methods:
-        candidates.append(functools.partial(CMakeDependency, 'NetCDF', env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            'NetCDF', CMakeDependency, (env, kwargs)))
 
     return candidates
 
@@ -536,17 +537,20 @@ def curses_factory(env: 'Environment',
     if DependencyMethods.PKGCONFIG in methods:
         pkgconfig_files = ['pdcurses', 'ncursesw', 'ncurses', 'curses']
         for pkg in pkgconfig_files:
-            candidates.append(functools.partial(PkgConfigDependency, pkg, env, kwargs))
+            candidates.append(DependencyCandidate.from_dependency(
+                pkg, PkgConfigDependency, (env, kwargs)))
 
     # There are path handling problems with these methods on msys, and they
     # don't apply to windows otherwise (cygwin is handled separately from
     # windows)
     if not env.machines[for_machine].is_windows():
         if DependencyMethods.CONFIG_TOOL in methods:
-            candidates.append(functools.partial(CursesConfigToolDependency, 'curses', env, kwargs))
+            candidates.append(DependencyCandidate.from_dependency(
+                'curses', CursesConfigToolDependency, (env, kwargs)))
 
         if DependencyMethods.SYSTEM in methods:
-            candidates.append(functools.partial(CursesSystemDependency, 'curses', env, kwargs))
+            candidates.append(DependencyCandidate.from_dependency(
+                'curses', CursesSystemDependency, (env, kwargs)))
 
     return candidates
 packages['curses'] = curses_factory
@@ -576,15 +580,16 @@ def shaderc_factory(env: 'Environment',
         if static is None:
             static = T.cast('bool', env.coredata.optstore.get_value_for(OptionKey('prefer_static')))
         if static:
-            c = [functools.partial(PkgConfigDependency, name, env, kwargs)
+            c = [DependencyCandidate.from_dependency(name, PkgConfigDependency, (env, kwargs))
                  for name in static_libs + shared_libs]
         else:
-            c = [functools.partial(PkgConfigDependency, name, env, kwargs)
+            c = [DependencyCandidate.from_dependency(name, PkgConfigDependency, (env, kwargs))
                  for name in shared_libs + static_libs]
         candidates.extend(c)
 
     if DependencyMethods.SYSTEM in methods:
-        candidates.append(functools.partial(ShadercDependency, 'shaderc', env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            'shaderc', ShadercDependency, (env, kwargs)))
 
     return candidates
 packages['shaderc'] = shaderc_factory
@@ -593,89 +598,89 @@ packages['shaderc'] = shaderc_factory
 packages['atomic'] = atomic_factory = DependencyFactory(
     'atomic',
     [DependencyMethods.SYSTEM, DependencyMethods.BUILTIN],
-    system_class=AtomicSystemDependency,
-    builtin_class=AtomicBuiltinDependency,
+    system=AtomicSystemDependency,
+    builtin=AtomicBuiltinDependency,
 )
 
 packages['cups'] = cups_factory = DependencyFactory(
     'cups',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK, DependencyMethods.CMAKE],
-    configtool_class=CupsDependencyConfigTool,
-    cmake_name='Cups',
+    configtool=CupsDependencyConfigTool,
+    cmake=DependencyCandidate.from_dependency('Cups', CMakeDependency),
 )
 
 packages['dl'] = dl_factory = DependencyFactory(
     'dl',
     [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM],
-    builtin_class=DlBuiltinDependency,
-    system_class=DlSystemDependency,
+    builtin=DlBuiltinDependency,
+    system=DlSystemDependency,
 )
 
 packages['gpgme'] = gpgme_factory = DependencyFactory(
     'gpgme',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    configtool_class=GpgmeDependencyConfigTool,
+    configtool=GpgmeDependencyConfigTool,
 )
 
 packages['libgcrypt'] = libgcrypt_factory = DependencyFactory(
     'libgcrypt',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    configtool_class=LibGCryptDependencyConfigTool,
+    configtool=LibGCryptDependencyConfigTool,
 )
 
 packages['libwmf'] = libwmf_factory = DependencyFactory(
     'libwmf',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    configtool_class=LibWmfDependencyConfigTool,
+    configtool=LibWmfDependencyConfigTool,
 )
 
 packages['pcap'] = pcap_factory = DependencyFactory(
     'pcap',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    configtool_class=PcapDependencyConfigTool,
-    pkgconfig_name='libpcap',
+    configtool=PcapDependencyConfigTool,
+    pkgconfig=DependencyCandidate.from_dependency('libpcap', PkgConfigDependency),
 )
 
 packages['threads'] = threads_factory = DependencyFactory(
     'threads',
     [DependencyMethods.SYSTEM, DependencyMethods.CMAKE],
-    cmake_name='Threads',
-    system_class=ThreadDependency,
+    cmake=DependencyCandidate.from_dependency('Threads', CMakeDependency),
+    system=ThreadDependency,
 )
 
 packages['iconv'] = iconv_factory = DependencyFactory(
     'iconv',
     [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM],
-    builtin_class=IconvBuiltinDependency,
-    system_class=IconvSystemDependency,
+    builtin=IconvBuiltinDependency,
+    system=IconvSystemDependency,
 )
 
 packages['intl'] = intl_factory = DependencyFactory(
     'intl',
     [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM],
-    builtin_class=IntlBuiltinDependency,
-    system_class=IntlSystemDependency,
+    builtin=IntlBuiltinDependency,
+    system=IntlSystemDependency,
 )
 
 packages['openssl'] = openssl_factory = DependencyFactory(
     'openssl',
     [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.CMAKE],
-    system_class=OpensslSystemDependency,
-    cmake_class=CMakeDependencyFactory('OpenSSL', modules=['OpenSSL::Crypto', 'OpenSSL::SSL']),
+    system=OpensslSystemDependency,
+    cmake=DependencyCandidate.from_dependency('OpenSSL', CMakeDependency, modules=['OpenSSL::Crypto', 'OpenSSL::SSL']),
 )
 
 packages['libcrypto'] = libcrypto_factory = DependencyFactory(
     'libcrypto',
     [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.CMAKE],
-    system_class=OpensslSystemDependency,
-    cmake_class=CMakeDependencyFactory('OpenSSL', modules=['OpenSSL::Crypto']),
+    system=OpensslSystemDependency,
+    cmake=DependencyCandidate.from_dependency('OpenSSL', CMakeDependency, modules=['OpenSSL::Crypto']),
 )
 
 packages['libssl'] = libssl_factory = DependencyFactory(
     'libssl',
     [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.CMAKE],
-    system_class=OpensslSystemDependency,
-    cmake_class=CMakeDependencyFactory('OpenSSL', modules=['OpenSSL::SSL']),
+    system=OpensslSystemDependency,
+    cmake=DependencyCandidate.from_dependency('OpenSSL', CMakeDependency, modules=['OpenSSL::SSL']),
 )
 
 packages['objfw'] = ObjFWDependency
diff --git a/mesonbuild/dependencies/mpi.py b/mesonbuild/dependencies/mpi.py
index 78d793dbc..3f61d0730 100644
--- a/mesonbuild/dependencies/mpi.py
+++ b/mesonbuild/dependencies/mpi.py
@@ -3,14 +3,13 @@
 
 from __future__ import annotations
 
-import functools
 import typing as T
 import os
 import re
 
 from ..envconfig import detect_cpu_family
 from ..mesonlib import Popen_safe
-from .base import DependencyException, DependencyMethods, detect_compiler, SystemDependency
+from .base import DependencyCandidate, DependencyException, DependencyMethods, detect_compiler, SystemDependency
 from .configtool import ConfigToolDependency
 from .detect import packages
 from .factory import factory_methods
@@ -75,14 +74,14 @@ def mpi_factory(env: 'Environment',
             tool_names.extend(['mpifort', 'mpif90', 'mpif77'])
 
         nwargs['tools'] = tool_names
-        candidates.append(functools.partial(
-            MPIConfigToolDependency, tool_names[0], env, nwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            tool_names[0], MPIConfigToolDependency, (env, nwargs)))
 
     if DependencyMethods.SYSTEM in methods and env.machines[for_machine].is_windows():
-        candidates.append(functools.partial(
-            MSMPIDependency, 'msmpi', env, kwargs))
-        candidates.append(functools.partial(
-            IMPIDependency, 'impi', env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            'msmpi', MSMPIDependency, (env, kwargs)))
+        candidates.append(DependencyCandidate.from_dependency(
+            'impi', IMPIDependency, (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
@@ -94,8 +93,8 @@ def mpi_factory(env: 'Environment',
             pkg_name = 'ompi-cxx'
         elif language == 'fortran':
             pkg_name = 'ompi-fort'
-        candidates.append(functools.partial(
-            PkgConfigDependency, pkg_name, env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            pkg_name, PkgConfigDependency, (env, kwargs)))
 
     return candidates
 
diff --git a/mesonbuild/dependencies/python.py b/mesonbuild/dependencies/python.py
index 146f41d4d..9614196d9 100644
--- a/mesonbuild/dependencies/python.py
+++ b/mesonbuild/dependencies/python.py
@@ -8,7 +8,7 @@ from pathlib import Path
 import typing as T
 
 from .. import mesonlib, mlog
-from .base import process_method_kw, DependencyException, DependencyMethods, ExternalDependency, SystemDependency
+from .base import process_method_kw, DependencyCandidate, DependencyException, DependencyMethods, ExternalDependency, SystemDependency
 from .configtool import ConfigToolDependency
 from .detect import packages
 from .factory import DependencyFactory
@@ -519,7 +519,7 @@ class PythonFrameworkDependency(ExtraFrameworkDependency, _PythonDependencyBase)
 class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
 
     def __init__(self, name: str, environment: 'Environment',
-                 kwargs: DependencyObjectKWs, installation: 'BasicPythonExternalProgram'):
+                 kwargs: DependencyObjectKWs, installation: BasicPythonExternalProgram):
         SystemDependency.__init__(self, name, environment, kwargs)
         _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
 
@@ -563,7 +563,7 @@ class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
     def log_tried() -> str:
         return 'sysconfig'
 
-def python_factory(env: 'Environment', 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
@@ -577,12 +577,17 @@ def python_factory(env: 'Environment', kwargs: DependencyObjectKWs,
 
     if DependencyMethods.PKGCONFIG in methods:
         if from_installation:
-            candidates.append(functools.partial(PythonPkgConfigDependency, 'python3', env, kwargs, installation))
+            candidates.append(DependencyCandidate(
+                functools.partial(PythonPkgConfigDependency, installation=installation),
+                'python3', PythonPkgConfigDependency.log_tried(), arguments=(env, kwargs)))
         else:
-            candidates.append(functools.partial(PkgConfigDependency, 'python3', env, kwargs))
+            candidates.append(DependencyCandidate.from_dependency(
+                'python3', PkgConfigDependency, (env, kwargs)))
 
     if DependencyMethods.SYSTEM in methods:
-        candidates.append(functools.partial(PythonSystemDependency, 'python', env, kwargs, installation))
+        candidates.append(DependencyCandidate(
+            functools.partial(PythonSystemDependency, installation=installation),
+            'python', PythonSystemDependency.log_tried(), arguments=(env, kwargs)))
 
     if DependencyMethods.EXTRAFRAMEWORK in methods:
         nkwargs = kwargs.copy()
@@ -590,7 +595,9 @@ def python_factory(env: 'Environment', kwargs: DependencyObjectKWs,
             # 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))
+        candidates.append(DependencyCandidate(
+            functools.partial(PythonFrameworkDependency, installation=installation),
+            'python', PythonFrameworkDependency.log_tried(), arguments=(env, nkwargs)))
 
     return candidates
 
@@ -599,11 +606,11 @@ packages['python3'] = python_factory
 packages['pybind11'] = pybind11_factory = DependencyFactory(
     'pybind11',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.CMAKE],
-    configtool_class=Pybind11ConfigToolDependency,
+    configtool=Pybind11ConfigToolDependency,
 )
 
 packages['numpy'] = numpy_factory = DependencyFactory(
     'numpy',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    configtool_class=NumPyConfigToolDependency,
+    configtool=NumPyConfigToolDependency,
 )
diff --git a/mesonbuild/dependencies/qt.py b/mesonbuild/dependencies/qt.py
index 63ba9071b..57cdd5ec6 100644
--- a/mesonbuild/dependencies/qt.py
+++ b/mesonbuild/dependencies/qt.py
@@ -468,20 +468,20 @@ class Qt6PkgConfigDependency(Qt6WinMainMixin, QtPkgConfigDependency):
 packages['qt4'] = qt4_factory = DependencyFactory(
     'qt4',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    pkgconfig_class=Qt4PkgConfigDependency,
-    configtool_class=Qt4ConfigToolDependency,
+    pkgconfig=Qt4PkgConfigDependency,
+    configtool=Qt4ConfigToolDependency,
 )
 
 packages['qt5'] = qt5_factory = DependencyFactory(
     'qt5',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    pkgconfig_class=Qt5PkgConfigDependency,
-    configtool_class=Qt5ConfigToolDependency,
+    pkgconfig=Qt5PkgConfigDependency,
+    configtool=Qt5ConfigToolDependency,
 )
 
 packages['qt6'] = qt6_factory = DependencyFactory(
     'qt6',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
-    pkgconfig_class=Qt6PkgConfigDependency,
-    configtool_class=Qt6ConfigToolDependency,
+    pkgconfig=Qt6PkgConfigDependency,
+    configtool=Qt6ConfigToolDependency,
 )
diff --git a/mesonbuild/dependencies/scalapack.py b/mesonbuild/dependencies/scalapack.py
index 18bc5fce6..92276ce68 100644
--- a/mesonbuild/dependencies/scalapack.py
+++ b/mesonbuild/dependencies/scalapack.py
@@ -4,12 +4,11 @@
 from __future__ import annotations
 
 from pathlib import Path
-import functools
 import os
 import typing as T
 
 from ..options import OptionKey
-from .base import DependencyException, DependencyMethods
+from .base import DependencyCandidate, DependencyException, DependencyMethods
 from .cmake import CMakeDependency
 from .detect import packages
 from .pkgconfig import PkgConfigDependency
@@ -30,16 +29,16 @@ def scalapack_factory(env: 'Environment',
     if DependencyMethods.PKGCONFIG in methods:
         static_opt = kwargs['static'] if kwargs.get('static') is not None else env.coredata.optstore.get_value_for(OptionKey('prefer_static'))
         mkl = 'mkl-static-lp64-iomp' if static_opt else 'mkl-dynamic-lp64-iomp'
-        candidates.append(functools.partial(
-            MKLPkgConfigDependency, mkl, env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            mkl, MKLPkgConfigDependency, (env, kwargs)))
 
         for pkg in ['scalapack-openmpi', 'scalapack']:
-            candidates.append(functools.partial(
-                PkgConfigDependency, pkg, env, kwargs))
+            candidates.append(DependencyCandidate.from_dependency(
+                pkg, PkgConfigDependency, (env, kwargs)))
 
     if DependencyMethods.CMAKE in methods:
-        candidates.append(functools.partial(
-            CMakeDependency, 'Scalapack', env, kwargs))
+        candidates.append(DependencyCandidate.from_dependency(
+            'Scalapack', CMakeDependency, (env, kwargs)))
 
     return candidates
 
diff --git a/mesonbuild/dependencies/ui.py b/mesonbuild/dependencies/ui.py
index 74405fd20..0a1901b46 100644
--- a/mesonbuild/dependencies/ui.py
+++ b/mesonbuild/dependencies/ui.py
@@ -16,7 +16,8 @@ from ..mesonlib import (
     Popen_safe, version_compare_many
 )
 
-from .base import DependencyException, DependencyMethods, DependencyTypeName, SystemDependency
+from .base import DependencyCandidate, DependencyException, DependencyMethods, DependencyTypeName, SystemDependency
+from .cmake import CMakeDependency
 from .configtool import ConfigToolDependency
 from .detect import packages
 from .factory import DependencyFactory
@@ -274,18 +275,18 @@ class VulkanDependencySystem(SystemDependency):
 packages['gl'] = gl_factory = DependencyFactory(
     'gl',
     [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
-    system_class=GLDependencySystem,
+    system=GLDependencySystem,
 )
 
 packages['sdl2'] = sdl2_factory = DependencyFactory(
     'sdl2',
     [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK, DependencyMethods.CMAKE],
-    configtool_class=SDL2DependencyConfigTool,
-    cmake_name='SDL2',
+    configtool=SDL2DependencyConfigTool,
+    cmake=DependencyCandidate.from_dependency('SDL2', CMakeDependency),
 )
 
 packages['vulkan'] = vulkan_factory = DependencyFactory(
     'vulkan',
     [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
-    system_class=VulkanDependencySystem,
+    system=VulkanDependencySystem,
 )