python: move pkg-config discovery introspection logic to PythonPkgConfigDependency

Signed-off-by: Filipe Laíns <[email protected]>

Author: FFY00

mesonbuild/dependencies/pkgconfig.py

@@ -41,12 +41,13 @@ def set_program_override(pkg_bin: ExternalProgram, for_machine: MachineChoice) -
         PkgConfigInterface.pkg_bin_per_machine[for_machine] = pkg_bin
 
     @staticmethod
-    def instance(env: Environment, for_machine: MachineChoice, silent: bool) -> T.Optional[PkgConfigInterface]:
+    def instance(env: Environment, for_machine: MachineChoice, silent: bool,
+                 extra_paths: T.Optional[T.List[str]] = None) -> T.Optional[PkgConfigInterface]:
         '''Return a pkg-config implementation singleton'''
         for_machine = for_machine if env.is_cross_build() else MachineChoice.HOST
         impl = PkgConfigInterface.class_impl[for_machine]
         if impl is False:
-            impl = PkgConfigCLI(env, for_machine, silent, PkgConfigInterface.pkg_bin_per_machine[for_machine])
+            impl = PkgConfigCLI(env, for_machine, silent, PkgConfigInterface.pkg_bin_per_machine[for_machine], extra_paths)
             if not impl.found():
                 impl = None
             if not impl and not silent:
@@ -55,7 +56,9 @@ def instance(env: Environment, for_machine: MachineChoice, silent: bool) -> T.Op
         return impl
 
     @staticmethod
-    def _cli(env: Environment, for_machine: MachineChoice, silent: bool = False) -> T.Optional[PkgConfigCLI]:
+    def _cli(env: Environment, for_machine: MachineChoice,
+             extra_paths: T.Optional[T.List[str]] = None,
+             silent: bool = False) -> T.Optional[PkgConfigCLI]:
         '''Return the CLI pkg-config implementation singleton
         Even when we use another implementation internally, external tools might
         still need the CLI implementation.
@@ -66,15 +69,16 @@ def _cli(env: Environment, for_machine: MachineChoice, silent: bool = False) ->
         if impl and not isinstance(impl, PkgConfigCLI):
             impl = PkgConfigInterface.class_cli_impl[for_machine]
             if impl is False:
-                impl = PkgConfigCLI(env, for_machine, silent, PkgConfigInterface.pkg_bin_per_machine[for_machine])
+                impl = PkgConfigCLI(env, for_machine, silent, PkgConfigInterface.pkg_bin_per_machine[for_machine], extra_paths)
                 if not impl.found():
                     impl = None
                 PkgConfigInterface.class_cli_impl[for_machine] = impl
         return T.cast('T.Optional[PkgConfigCLI]', impl) # Trust me, mypy
 
     @staticmethod
-    def get_env(env: Environment, for_machine: MachineChoice, uninstalled: bool = False) -> EnvironmentVariables:
-        cli = PkgConfigInterface._cli(env, for_machine)
+    def get_env(env: Environment, for_machine: MachineChoice, uninstalled: bool = False,
+                extra_paths: T.Optional[T.List[str]] = None) -> EnvironmentVariables:
+        cli = PkgConfigInterface._cli(env, for_machine, extra_paths)
         return cli._get_env(uninstalled) if cli else EnvironmentVariables()
 
     @staticmethod
@@ -123,11 +127,13 @@ class PkgConfigCLI(PkgConfigInterface):
     '''pkg-config CLI implementation'''
 
     def __init__(self, env: Environment, for_machine: MachineChoice, silent: bool,
-                 pkgbin: T.Optional[ExternalProgram] = None) -> None:
+                 pkgbin: T.Optional[ExternalProgram] = None,
+                 extra_paths: T.Optional[T.List[str]] = None) -> None:
         super().__init__(env, for_machine)
         self._detect_pkgbin(pkgbin)
         if self.pkgbin and not silent:
             mlog.log('Found pkg-config:', mlog.green('YES'), mlog.bold(f'({self.pkgbin.get_path()})'), mlog.blue(self.pkgbin_version))
+        self.extra_paths = extra_paths or []
 
     def found(self) -> bool:
         return bool(self.pkgbin)
@@ -256,7 +262,7 @@ def _check_pkgconfig(self, pkgbin: ExternalProgram) -> T.Optional[str]:
     def _get_env(self, uninstalled: bool = False) -> EnvironmentVariables:
         env = EnvironmentVariables()
         key = OptionKey('pkg_config_path', machine=self.for_machine)
-        extra_paths: T.List[str] = self.env.coredata.optstore.get_value(key)[:]
+        extra_paths: T.List[str] = self.env.coredata.optstore.get_value(key)[:] + self.extra_paths
         if uninstalled:
             bpath = self.env.get_build_dir()
             if bpath is not None:
@@ -295,11 +301,13 @@ def _call_pkgbin(self, args: T.List[str], env: T.Optional[EnvironOrDict] = None)
 class PkgConfigDependency(ExternalDependency):
 
     def __init__(self, name: str, environment: Environment, kwargs: T.Dict[str, T.Any],
-                 language: T.Optional[str] = None) -> None:
+                 language: T.Optional[str] = None,
+                 extra_paths: T.Optional[T.List[str]] = None) -> None:
         super().__init__(DependencyTypeName('pkgconfig'), environment, kwargs, language=language)
         self.name = name
         self.is_libtool = False
-        pkgconfig = PkgConfigInterface.instance(self.env, self.for_machine, self.silent)
+        self.extra_paths = extra_paths
+        pkgconfig = PkgConfigInterface.instance(self.env, self.for_machine, self.silent, self.extra_paths)
         if not pkgconfig:
             msg = f'Pkg-config for machine {self.for_machine} not found. Giving up.'
             if self.required:

mesonbuild/dependencies/python.py

@@ -8,7 +8,7 @@
 import typing as T
 
 from .. import mesonlib, mlog
-from .base import process_method_kw, DependencyException, DependencyMethods, DependencyTypeName, ExternalDependency, SystemDependency
+from .base import process_method_kw, DependencyException, DependencyMethods, ExternalDependency, SystemDependency
 from .configtool import ConfigToolDependency
 from .detect import packages
 from .factory import DependencyFactory
@@ -116,6 +116,15 @@ def __init__(self, name: str, command: T.Optional[T.List[str]] = None,
         }
         self.pure: bool = True
 
+    @property
+    def version(self) -> str:
+        if self.build_config:
+            value = self.build_config['language']['version']
+        else:
+            value = self.info['variables'].get('LDVERSION') or self.info['version']
+        assert isinstance(value, str)
+        return value
+
     def _check_version(self, version: str) -> bool:
         if self.name == 'python2':
             return mesonlib.version_compare(version, '< 3.0')
@@ -357,19 +366,28 @@ def find_libpy_windows(self, env: 'Environment', limited_api: bool = False) -> N
 
 class PythonPkgConfigDependency(PkgConfigDependency, _PythonDependencyBase):
 
-    def __init__(self, name: str, environment: 'Environment',
-                 kwargs: T.Dict[str, T.Any], installation: 'BasicPythonExternalProgram',
-                 libpc: bool = False):
-        if libpc:
-            mlog.debug(f'Searching for {name!r} via pkgconfig lookup in LIBPC')
+    def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any],
+                 installation: 'BasicPythonExternalProgram', embed: bool):
+        pkg_embed = '-embed' if embed and mesonlib.version_compare(installation.info['version'], '>=3.8') else ''
+        pkg_name = f'python-{installation.version}{pkg_embed}'
+
+        if installation.build_config:
+            pkg_libdir = installation.build_config['c_api']['pkgconfig_path']
+            pkg_libdir_origin = 'c_api.pkgconfig_path from the Python build config'
         else:
-            mlog.debug(f'Searching for {name!r} via fallback pkgconfig lookup in default paths')
+            pkg_libdir = installation.info['variables'].get('LIBPC')
+            pkg_libdir_origin = 'LIBPC' if pkg_libdir else 'the default paths'
+        mlog.debug(f'Searching for {pkg_libdir!r} via pkgconfig lookup in {pkg_libdir_origin}')
+        pkgconfig_paths = [pkg_libdir] if pkg_libdir else []
 
-        PkgConfigDependency.__init__(self, name, environment, kwargs)
+        PkgConfigDependency.__init__(self, pkg_name, environment, kwargs, extra_paths=pkgconfig_paths)
         _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
 
-        if libpc and not self.is_found:
-            mlog.debug(f'"python-{self.version}" could not be found in LIBPC, this is likely due to a relocated python installation')
+        if pkg_libdir and not self.is_found:
+            mlog.debug(
+                f'{pkg_name!r} could not be found in {pkg_libdir_origin}, '
+                'this is likely due to a relocated python installation'
+            )
 
         # pkg-config files are usually accurate starting with python 3.8
         if not self.link_libpython and mesonlib.version_compare(self.version, '< 3.8'):
@@ -438,48 +456,9 @@ def python_factory(env: 'Environment', for_machine: 'MachineChoice',
         installation = BasicPythonExternalProgram('python3', mesonlib.python_command)
         installation.sanity()
 
-    if installation.build_config:
-        pkg_version = installation.build_config['language']['version']
-    else:
-        pkg_version = installation.info['variables'].get('LDVERSION') or installation.info['version']
-
     if DependencyMethods.PKGCONFIG in methods:
         if from_installation:
-            if installation.build_config:
-                pkg_libdir = installation.build_config['c_api']['pkgconfig_path']
-            else:
-                pkg_libdir = installation.info['variables'].get('LIBPC')
-            pkg_embed = '-embed' if embed and mesonlib.version_compare(installation.info['version'], '>=3.8') else ''
-            pkg_name = f'python-{pkg_version}{pkg_embed}'
-
-            # If python-X.Y.pc exists in LIBPC, we will try to use it
-            def wrap_in_pythons_pc_dir(name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
-                                       installation: 'BasicPythonExternalProgram') -> 'ExternalDependency':
-                if not pkg_libdir:
-                    # there is no LIBPC, so we can't search in it
-                    empty = ExternalDependency(DependencyTypeName('pkgconfig'), env, {})
-                    empty.name = 'python'
-                    return empty
-
-                old_pkg_libdir = os.environ.pop('PKG_CONFIG_LIBDIR', None)
-                old_pkg_path = os.environ.pop('PKG_CONFIG_PATH', None)
-                os.environ['PKG_CONFIG_LIBDIR'] = pkg_libdir
-                try:
-                    return PythonPkgConfigDependency(name, env, kwargs, installation, True)
-                finally:
-                    def set_env(name: str, value: str) -> None:
-                        if value is not None:
-                            os.environ[name] = value
-                        elif name in os.environ:
-                            del os.environ[name]
-                    set_env('PKG_CONFIG_LIBDIR', old_pkg_libdir)
-                    set_env('PKG_CONFIG_PATH', old_pkg_path)
-
-            candidates.append(functools.partial(wrap_in_pythons_pc_dir, pkg_name, env, kwargs, installation))
-            # We only need to check both, if a python install has a LIBPC. It might point to the wrong location,
-            # e.g. relocated / cross compilation, but the presence of LIBPC indicates we should definitely look for something.
-            if pkg_libdir is not None:
-                candidates.append(functools.partial(PythonPkgConfigDependency, pkg_name, env, kwargs, installation))
+            candidates.append(functools.partial(PythonPkgConfigDependency, env, kwargs, installation, embed))
         else:
             candidates.append(functools.partial(PkgConfigDependency, 'python3', env, kwargs))
 
@@ -488,7 +467,7 @@ def set_env(name: str, value: str) -> None:
 
     if DependencyMethods.EXTRAFRAMEWORK in methods:
         nkwargs = kwargs.copy()
-        if mesonlib.version_compare(pkg_version, '>= 3'):
+        if mesonlib.version_compare(installation.version, '>= 3'):
             # 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']