frida 16.2.0 → 16.2.2

package/releng/meson/mesonbuild/dependencies/dub.py

@@ -0,0 +1,424 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2013-2021 The Meson development team
+
+from __future__ import annotations
+
+from .base import ExternalDependency, DependencyException, DependencyTypeName
+from .pkgconfig import PkgConfigDependency
+from ..mesonlib import (Popen_safe, OptionKey, join_args, version_compare)
+from ..programs import ExternalProgram
+from .. import mlog
+import re
+import os
+import json
+import typing as T
+
+if T.TYPE_CHECKING:
+    from ..environment import Environment
+
+
+class DubDependency(ExternalDependency):
+    # dub program and version
+    class_dubbin: T.Optional[T.Tuple[ExternalProgram, str]] = None
+    class_dubbin_searched = False
+
+    def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+        super().__init__(DependencyTypeName('dub'), environment, kwargs, language='d')
+        self.name = name
+        from ..compilers.d import DCompiler, d_feature_args
+
+        _temp_comp = super().get_compiler()
+        assert isinstance(_temp_comp, DCompiler)
+        self.compiler = _temp_comp
+
+        if 'required' in kwargs:
+            self.required = kwargs.get('required')
+
+        if DubDependency.class_dubbin is None and not DubDependency.class_dubbin_searched:
+            DubDependency.class_dubbin = self._check_dub()
+            DubDependency.class_dubbin_searched = True
+        if DubDependency.class_dubbin is None:
+            if self.required:
+                raise DependencyException('DUB not found.')
+            self.is_found = False
+            return
+
+        (self.dubbin, dubver) = DubDependency.class_dubbin  # pylint: disable=unpacking-non-sequence
+
+        assert isinstance(self.dubbin, ExternalProgram)
+
+        # Check if Dub version is compatible with Meson
+        if version_compare(dubver, '>1.31.1'):
+            if self.required:
+                raise DependencyException(
+                    f"DUB version {dubver} is not compatible with Meson (can't locate artifacts in Dub cache)")
+            self.is_found = False
+            return
+
+        mlog.debug('Determining dependency {!r} with DUB executable '
+                   '{!r}'.format(name, self.dubbin.get_path()))
+
+        # if an explicit version spec was stated, use this when querying Dub
+        main_pack_spec = name
+        if 'version' in kwargs:
+            version_spec = kwargs['version']
+            if isinstance(version_spec, list):
+                version_spec = " ".join(version_spec)
+            main_pack_spec = f'{name}@{version_spec}'
+
+        # we need to know the target architecture
+        dub_arch = self.compiler.arch
+
+        # we need to know the build type as well
+        dub_buildtype = str(environment.coredata.get_option(OptionKey('buildtype')))
+        # MESON types: choices=['plain', 'debug', 'debugoptimized', 'release', 'minsize', 'custom'])),
+        # DUB types: debug (default), plain, release, release-debug, release-nobounds, unittest, profile, profile-gc,
+        # docs, ddox, cov, unittest-cov, syntax and custom
+        if dub_buildtype == 'debugoptimized':
+            dub_buildtype = 'release-debug'
+        elif dub_buildtype == 'minsize':
+            dub_buildtype = 'release'
+
+        # Ask dub for the package
+        describe_cmd = [
+            'describe', main_pack_spec, '--arch=' + dub_arch,
+            '--build=' + dub_buildtype, '--compiler=' + self.compiler.get_exelist()[-1]
+        ]
+        ret, res, err = self._call_dubbin(describe_cmd)
+
+        if ret != 0:
+            mlog.debug('DUB describe failed: ' + err)
+            if 'locally' in err:
+                fetch_cmd = ['dub', 'fetch', main_pack_spec]
+                mlog.error(mlog.bold(main_pack_spec), 'is not present locally. You may try the following command:')
+                mlog.log(mlog.bold(join_args(fetch_cmd)))
+            self.is_found = False
+            return
+
+        # A command that might be useful in case of missing DUB package
+        def dub_build_deep_command() -> str:
+            cmd = [
+                'dub', 'run', 'dub-build-deep', '--yes', '--', main_pack_spec,
+                '--arch=' + dub_arch, '--compiler=' + self.compiler.get_exelist()[-1],
+                '--build=' + dub_buildtype
+            ]
+            return join_args(cmd)
+
+        dub_comp_id = self.compiler.get_id().replace('llvm', 'ldc').replace('gcc', 'gdc')
+        description = json.loads(res)
+
+        self.compile_args = []
+        self.link_args = self.raw_link_args = []
+
+        show_buildtype_warning = False
+
+        def find_package_target(pkg: T.Dict[str, str]) -> bool:
+            nonlocal show_buildtype_warning
+            # try to find a static library in a DUB folder corresponding to
+            # version, configuration, compiler, arch and build-type
+            # if can find, add to link_args.
+            # link_args order is meaningful, so this function MUST be called in the right order
+            pack_id = f'{pkg["name"]}@{pkg["version"]}'
+            (tgt_file, compatibilities) = self._find_compatible_package_target(description, pkg, dub_comp_id)
+            if tgt_file is None:
+                if not compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'not found')
+                elif 'compiler' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled with ', mlog.bold(dub_comp_id))
+                elif dub_comp_id != 'gdc' and 'compiler_version' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled with',
+                               mlog.bold(f'{dub_comp_id}-{self.compiler.version}'))
+                elif 'arch' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled for', mlog.bold(dub_arch))
+                elif 'platform' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled for',
+                               mlog.bold(description['platform'].join('.')))
+                elif 'configuration' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled for the',
+                               mlog.bold(pkg['configuration']), 'configuration')
+                else:
+                    mlog.error(mlog.bold(pack_id), 'not found')
+
+                mlog.log('You may try the following command to install the necessary DUB libraries:')
+                mlog.log(mlog.bold(dub_build_deep_command()))
+
+                return False
+
+            if 'build_type' not in compatibilities:
+                mlog.warning(mlog.bold(pack_id), 'found but not compiled as', mlog.bold(dub_buildtype))
+                show_buildtype_warning = True
+
+            self.link_args.append(tgt_file)
+            return True
+
+        # Main algorithm:
+        # 1. Ensure that the target is a compatible library type (not dynamic)
+        # 2. Find a compatible built library for the main dependency
+        # 3. Do the same for each sub-dependency.
+        #    link_args MUST be in the same order than the "linkDependencies" of the main target
+        # 4. Add other build settings (imports, versions etc.)
+
+        # 1
+        self.is_found = False
+        packages = {}
+        for pkg in description['packages']:
+            packages[pkg['name']] = pkg
+
+            if not pkg['active']:
+                continue
+
+            if pkg['targetType'] == 'dynamicLibrary':
+                mlog.error('DUB dynamic library dependencies are not supported.')
+                self.is_found = False
+                return
+
+            # check that the main dependency is indeed a library
+            if pkg['name'] == name:
+                self.is_found = True
+
+                if pkg['targetType'] not in ['library', 'sourceLibrary', 'staticLibrary']:
+                    mlog.error(mlog.bold(name), "found but it isn't a library")
+                    self.is_found = False
+                    return
+
+                self.version = pkg['version']
+                self.pkg = pkg
+
+        # collect all targets
+        targets = {}
+        for tgt in description['targets']:
+            targets[tgt['rootPackage']] = tgt
+
+        if name not in targets:
+            self.is_found = False
+            if self.pkg['targetType'] == 'sourceLibrary':
+                # source libraries have no associated targets,
+                # but some build settings like import folders must be found from the package object.
+                # Current algo only get these from "buildSettings" in the target object.
+                # Let's save this for a future PR.
+                # (See openssl DUB package for example of sourceLibrary)
+                mlog.error('DUB targets of type', mlog.bold('sourceLibrary'), 'are not supported.')
+            else:
+                mlog.error('Could not find target description for', mlog.bold(main_pack_spec))
+
+        if not self.is_found:
+            mlog.error(f'Could not find {name} in DUB description')
+            return
+
+        # Current impl only supports static libraries
+        self.static = True
+
+        # 2
+        if not find_package_target(self.pkg):
+            self.is_found = False
+            return
+
+        # 3
+        for link_dep in targets[name]['linkDependencies']:
+            pkg = packages[link_dep]
+            if not find_package_target(pkg):
+                self.is_found = False
+                return
+
+        if show_buildtype_warning:
+            mlog.log('If it is not suitable, try the following command and reconfigure Meson with', mlog.bold('--clearcache'))
+            mlog.log(mlog.bold(dub_build_deep_command()))
+
+        # 4
+        bs = targets[name]['buildSettings']
+
+        for flag in bs['dflags']:
+            self.compile_args.append(flag)
+
+        for path in bs['importPaths']:
+            self.compile_args.append('-I' + path)
+
+        for path in bs['stringImportPaths']:
+            if 'import_dir' not in d_feature_args[self.compiler.id]:
+                break
+            flag = d_feature_args[self.compiler.id]['import_dir']
+            self.compile_args.append(f'{flag}={path}')
+
+        for ver in bs['versions']:
+            if 'version' not in d_feature_args[self.compiler.id]:
+                break
+            flag = d_feature_args[self.compiler.id]['version']
+            self.compile_args.append(f'{flag}={ver}')
+
+        if bs['mainSourceFile']:
+            self.compile_args.append(bs['mainSourceFile'])
+
+        # pass static libraries
+        # linkerFiles are added during step 3
+        # for file in bs['linkerFiles']:
+        #     self.link_args.append(file)
+
+        for file in bs['sourceFiles']:
+            # sourceFiles may contain static libraries
+            if file.endswith('.lib') or file.endswith('.a'):
+                self.link_args.append(file)
+
+        for flag in bs['lflags']:
+            self.link_args.append(flag)
+
+        is_windows = self.env.machines.host.is_windows()
+        if is_windows:
+            winlibs = ['kernel32', 'user32', 'gdi32', 'winspool', 'shell32', 'ole32',
+                       'oleaut32', 'uuid', 'comdlg32', 'advapi32', 'ws2_32']
+
+        for lib in bs['libs']:
+            if os.name != 'nt':
+                # trying to add system libraries by pkg-config
+                pkgdep = PkgConfigDependency(lib, environment, {'required': 'true', 'silent': 'true'})
+                if pkgdep.is_found:
+                    for arg in pkgdep.get_compile_args():
+                        self.compile_args.append(arg)
+                    for arg in pkgdep.get_link_args():
+                        self.link_args.append(arg)
+                    for arg in pkgdep.get_link_args(raw=True):
+                        self.raw_link_args.append(arg)
+                    continue
+
+            if is_windows and lib in winlibs:
+                self.link_args.append(lib + '.lib')
+                continue
+
+            # fallback
+            self.link_args.append('-l'+lib)
+
+    # This function finds the target of the provided JSON package, built for the right
+    # compiler, architecture, configuration...
+    # It returns (target|None, {compatibilities})
+    # If None is returned for target, compatibilities will list what other targets were found without full compatibility
+    def _find_compatible_package_target(self, jdesc: T.Dict[str, str], jpack: T.Dict[str, str], dub_comp_id: str) -> T.Tuple[str, T.Set[str]]:
+        dub_build_path = os.path.join(jpack['path'], '.dub', 'build')
+
+        if not os.path.exists(dub_build_path):
+            return (None, None)
+
+        # try to find a dir like library-debug-linux.posix-x86_64-ldc_2081-EF934983A3319F8F8FF2F0E107A363BA
+
+        # fields are:
+        #  - configuration
+        #  - build type
+        #  - platform
+        #  - architecture
+        #  - compiler id (dmd, ldc, gdc)
+        #  - compiler version or frontend id or frontend version?
+
+        conf = jpack['configuration']
+        build_type = jdesc['buildType']
+        platforms = jdesc['platform']
+        archs = jdesc['architecture']
+
+        # Get D frontend version implemented in the compiler, or the compiler version itself
+        # gdc doesn't support this
+        comp_versions = []
+
+        if dub_comp_id != 'gdc':
+            comp_versions.append(self.compiler.version)
+
+            ret, res = self._call_compbin(['--version'])[0:2]
+            if ret != 0:
+                mlog.error('Failed to run {!r}', mlog.bold(dub_comp_id))
+                return (None, None)
+            d_ver_reg = re.search('v[0-9].[0-9][0-9][0-9].[0-9]', res)  # Ex.: v2.081.2
+
+            if d_ver_reg is not None:
+                frontend_version = d_ver_reg.group()
+                frontend_id = frontend_version.rsplit('.', 1)[0].replace(
+                    'v', '').replace('.', '')  # Fix structure. Ex.: 2081
+                comp_versions.extend([frontend_version, frontend_id])
+
+        compatibilities: T.Set[str] = set()
+
+        # build_type is not in check_list because different build types might be compatible.
+        # We do show a WARNING that the build type is not the same.
+        # It might be critical in release builds, and acceptable otherwise
+        check_list = ('configuration', 'platform', 'arch', 'compiler', 'compiler_version')
+
+        for entry in os.listdir(dub_build_path):
+
+            target = os.path.join(dub_build_path, entry, jpack['targetFileName'])
+            if not os.path.exists(target):
+                # unless Dub and Meson are racing, the target file should be present
+                # when the directory is present
+                mlog.debug("WARNING: Could not find a Dub target: " + target)
+                continue
+
+            # we build a new set for each entry, because if this target is returned
+            # we want to return only the compatibilities associated to this target
+            # otherwise we could miss the WARNING about build_type
+            comps = set()
+
+            if conf in entry:
+                comps.add('configuration')
+
+            if build_type in entry:
+                comps.add('build_type')
+
+            if all(platform in entry for platform in platforms):
+                comps.add('platform')
+
+            if all(arch in entry for arch in archs):
+                comps.add('arch')
+
+            if dub_comp_id in entry:
+                comps.add('compiler')
+
+            if dub_comp_id == 'gdc' or any(cv in entry for cv in comp_versions):
+                comps.add('compiler_version')
+
+            if all(key in comps for key in check_list):
+                return (target, comps)
+            else:
+                compatibilities = set.union(compatibilities, comps)
+
+        return (None, compatibilities)
+
+    def _call_dubbin(self, args: T.List[str], env: T.Optional[T.Dict[str, str]] = None) -> T.Tuple[int, str, str]:
+        assert isinstance(self.dubbin, ExternalProgram)
+        p, out, err = Popen_safe(self.dubbin.get_command() + args, env=env)
+        return p.returncode, out.strip(), err.strip()
+
+    def _call_compbin(self, args: T.List[str], env: T.Optional[T.Dict[str, str]] = None) -> T.Tuple[int, str, str]:
+        p, out, err = Popen_safe(self.compiler.get_exelist() + args, env=env)
+        return p.returncode, out.strip(), err.strip()
+
+    def _check_dub(self) -> T.Optional[T.Tuple[ExternalProgram, str]]:
+
+        def find() -> T.Optional[T.Tuple[ExternalProgram, str]]:
+            dubbin = ExternalProgram('dub', silent=True)
+
+            if not dubbin.found():
+                return None
+
+            try:
+                p, out = Popen_safe(dubbin.get_command() + ['--version'])[0:2]
+                if p.returncode != 0:
+                    mlog.warning('Found dub {!r} but couldn\'t run it'
+                                 ''.format(' '.join(dubbin.get_command())))
+                    return None
+
+            except (FileNotFoundError, PermissionError):
+                return None
+
+            vermatch = re.search(r'DUB version (\d+\.\d+\.\d+.*), ', out.strip())
+            if vermatch:
+                dubver = vermatch.group(1)
+            else:
+                mlog.warning(f"Found dub {' '.join(dubbin.get_command())} but couldn't parse version in {out.strip()}")
+                return None
+
+            return (dubbin, dubver)
+
+        found = find()
+
+        if found is None:
+            mlog.log('Found DUB:', mlog.red('NO'))
+        else:
+            (dubbin, dubver) = found
+            mlog.log('Found DUB:', mlog.bold(dubbin.get_path()),
+                     '(version %s)' % dubver)
+
+        return found

package/releng/meson/mesonbuild/dependencies/factory.py

@@ -0,0 +1,146 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2013-2021 The Meson development team
+# Copyright © 2021-2023 Intel Corporation
+
+from __future__ import annotations
+
+import functools
+import typing as T
+
+from .base import DependencyException, DependencyMethods
+from .base import process_method_kw
+from .base import BuiltinDependency, SystemDependency
+from .cmake import CMakeDependency
+from .framework import ExtraFrameworkDependency
+from .pkgconfig import PkgConfigDependency
+
+if T.TYPE_CHECKING:
+    from .base import ExternalDependency
+    from .configtool import ConfigToolDependency
+    from ..environment import Environment
+    from ..mesonlib import MachineChoice
+
+    DependencyGenerator = T.Callable[[], ExternalDependency]
+    FactoryFunc = T.Callable[
+        [
+            'Environment',
+            MachineChoice,
+            T.Dict[str, T.Any],
+            T.List[DependencyMethods]
+        ],
+        T.List[DependencyGenerator]
+    ]
+
+    WrappedFactoryFunc = T.Callable[
+        [
+            'Environment',
+            MachineChoice,
+            T.Dict[str, T.Any]
+        ],
+        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.
+
+    This class provides an initializer that takes a set of names and classes
+    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
+        parameter of the each dependency unless it is overridden on a per
+        type basis.
+    :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.
+    """
+
+    def __init__(self, name: str, methods: T.List[DependencyMethods], *,
+                 extra_kwargs: T.Optional[T.Dict[str, T.Any]] = 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')
+
+        self.extra_kwargs = extra_kwargs or {}
+        self.methods = methods
+        self.classes: T.Dict[
+            DependencyMethods,
+            T.Callable[['Environment', T.Dict[str, T.Any]], 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,
+        }
+        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:
+        """Report whether a method is valid or not.
+
+        If the method is valid, return true, otherwise return false. This is
+        used in a list comprehension to filter methods that are not possible.
+
+        By default this only remove EXTRAFRAMEWORK dependencies for non-mac platforms.
+        """
+        # Extra frameworks are only valid for macOS and other apple products
+        if (method is DependencyMethods.EXTRAFRAMEWORK and
+                not env.machines[for_machine].is_darwin()):
+            return False
+        return True
+
+    def __call__(self, env: 'Environment', for_machine: MachineChoice,
+                 kwargs: T.Dict[str, T.Any]) -> 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)
+
+        return [functools.partial(self.classes[m], env, nwargs) for m in methods
+                if self._process_method(m, env, for_machine)]
+
+
+def factory_methods(methods: T.Set[DependencyMethods]) -> T.Callable[['FactoryFunc'], 'WrappedFactoryFunc']:
+    """Decorator for handling methods for dependency factory functions.
+
+    This helps to make factory functions self documenting
+    >>> @factory_methods([DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE])
+    >>> def factory(env: Environment, for_machine: MachineChoice, kwargs: T.Dict[str, T.Any], methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+    >>>     pass
+    """
+
+    def inner(func: 'FactoryFunc') -> 'WrappedFactoryFunc':
+
+        @functools.wraps(func)
+        def wrapped(env: 'Environment', for_machine: MachineChoice, kwargs: T.Dict[str, T.Any]) -> T.List['DependencyGenerator']:
+            return func(env, for_machine, kwargs, process_method_kw(methods, kwargs))
+
+        return wrapped
+
+    return inner

package/releng/meson/mesonbuild/dependencies/framework.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2013-2021 The Meson development team
+
+from __future__ import annotations
+
+from .base import DependencyTypeName, ExternalDependency, DependencyException
+from ..mesonlib import MesonException, Version, stringlistify
+from .. import mlog
+from pathlib import Path
+import typing as T
+
+if T.TYPE_CHECKING:
+    from ..environment import Environment
+
+class ExtraFrameworkDependency(ExternalDependency):
+    system_framework_paths: T.Optional[T.List[str]] = None
+
+    def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None) -> None:
+        paths = stringlistify(kwargs.get('paths', []))
+        super().__init__(DependencyTypeName('extraframeworks'), env, kwargs, language=language)
+        self.name = name
+        # Full path to framework directory
+        self.framework_path: T.Optional[str] = None
+        if not self.clib_compiler:
+            raise DependencyException('No C-like compilers are available')
+        if self.system_framework_paths is None:
+            try:
+                self.system_framework_paths = self.clib_compiler.find_framework_paths(self.env)
+            except MesonException as e:
+                if 'non-clang' in str(e):
+                    # Apple frameworks can only be found (and used) with the
+                    # system compiler. It is not available so bail immediately.
+                    self.is_found = False
+                    return
+                raise
+        self.detect(name, paths)
+
+    def detect(self, name: str, paths: T.List[str]) -> None:
+        if not paths:
+            paths = self.system_framework_paths
+        for p in paths:
+            mlog.debug(f'Looking for framework {name} in {p}')
+            # We need to know the exact framework path because it's used by the
+            # Qt5 dependency class, and for setting the include path. We also
+            # want to avoid searching in an invalid framework path which wastes
+            # time and can cause a false positive.
+            framework_path = self._get_framework_path(p, name)
+            if framework_path is None:
+                continue
+            # We want to prefer the specified paths (in order) over the system
+            # paths since these are "extra" frameworks.
+            # For example, Python2's framework is in /System/Library/Frameworks and
+            # Python3's framework is in /Library/Frameworks, but both are called
+            # Python.framework. We need to know for sure that the framework was
+            # found in the path we expect.
+            allow_system = p in self.system_framework_paths
+            args = self.clib_compiler.find_framework(name, self.env, [p], allow_system)
+            if args is None:
+                continue
+            self.link_args = args
+            self.framework_path = framework_path.as_posix()
+            self.compile_args = ['-F' + self.framework_path]
+            # We need to also add -I includes to the framework because all
+            # cross-platform projects such as OpenGL, Python, Qt, GStreamer,
+            # etc do not use "framework includes":
+            # https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPFrameworks/Tasks/IncludingFrameworks.html
+            incdir = self._get_framework_include_path(framework_path)
+            if incdir:
+                self.compile_args += ['-idirafter' + incdir]
+            self.is_found = True
+            return
+
+    def _get_framework_path(self, path: str, name: str) -> T.Optional[Path]:
+        p = Path(path)
+        lname = name.lower()
+        for d in p.glob('*.framework/'):
+            if lname == d.name.rsplit('.', 1)[0].lower():
+                return d
+        return None
+
+    def _get_framework_latest_version(self, path: Path) -> str:
+        versions: T.List[Version] = []
+        for each in path.glob('Versions/*'):
+            # macOS filesystems are usually case-insensitive
+            if each.name.lower() == 'current':
+                continue
+            versions.append(Version(each.name))
+        if len(versions) == 0:
+            # most system frameworks do not have a 'Versions' directory
+            return 'Headers'
+        return 'Versions/{}/Headers'.format(sorted(versions)[-1]._s)
+
+    def _get_framework_include_path(self, path: Path) -> T.Optional[str]:
+        # According to the spec, 'Headers' must always be a symlink to the
+        # Headers directory inside the currently-selected version of the
+        # framework, but sometimes frameworks are broken. Look in 'Versions'
+        # for the currently-selected version or pick the latest one.
+        trials = ('Headers', 'Versions/Current/Headers',
+                  self._get_framework_latest_version(path))
+        for each in trials:
+            trial = path / each
+            if trial.is_dir():
+                return trial.as_posix()
+        return None
+
+    def log_info(self) -> str:
+        return self.framework_path or ''
+
+    @staticmethod
+    def log_tried() -> str:
+        return 'framework'