cargo: implement machine-specific dependency tracking

Change the dependency resolution code to take a MachineChoice as an
argument.  Create build- and/or host-side configurations
through the machines_from() method in Manifest.

Author: bonzini

docs/markdown/Wrap-dependency-system-manual.md

@@ -364,6 +364,10 @@ Some naming conventions need to be respected:
   This is typically used as `extra_deps += dependency('foo')`.
 - Since *1.10.0* the `features` variable is an array of enabled features for the subproject.
 
+Note that currently `meson/meson.build` is only evaluated once even if a given
+dependency is needed for both the build and host machine.  This should rarely be
+a problem, but it should be kept in mind to avoid problems when cross compiling.
+
 Since *1.5.0* Cargo wraps can also be provided with `Cargo.lock` file at the root
 of (sub)project source tree. Meson will automatically load that file and convert
 it into a series of wraps definitions.

mesonbuild/cargo/interpreter.py

@@ -144,10 +144,11 @@ def interpret_package(self, manifest: Manifest, build: builder.Builder, subdir:
         else:
             pkg, cached = self._fetch_package(manifest.package.name, manifest.package.api)
             if not cached:
-                self._prepare_package(pkg)
-                # This is an entry point, always enable the 'default' feature.
-                # FIXME: We should have a Meson option similar to `cargo build --no-default-features`
-                self._enable_feature(pkg, 'default')
+                for machine in pkg.manifest.machines_from(MachineChoice.HOST):
+                    self._prepare_package(pkg, machine)
+                    # This is an entry point, always enable the 'default' feature.
+                    # FIXME: We should have a Meson option similar to `cargo build --no-default-features`
+                    self._enable_feature(pkg, 'default', machine)
             ast += self._create_project(pkg.manifest.package.name, pkg, build)
             ast.append(build.assign(build.function('import', [build.string('rust')]), 'rust'))
         ast += self._create_package(pkg, build, subdir)
@@ -192,6 +193,8 @@ def _create_package(self, pkg: PackageState, build: builder.Builder, subdir: str
 
                 if pkg.manifest.lib:
                     for crate_type in pkg.manifest.lib.crate_type:
+                        if crate_type == 'proc-macro' and machine == MachineChoice.HOST:
+                            continue
                         ast.extend(self._create_lib(pkg, build, crate_type, machine))
 
         return ast
@@ -205,7 +208,8 @@ def interpret_workspace(self, workspace: Workspace, build: builder.Builder, subd
         if not ws.required_members:
             for member in ws.workspace.default_members:
                 pkg = self._require_workspace_member(ws, member)
-                self._prepare_package(pkg)
+                for machine in pkg.manifest.machines_from(MachineChoice.HOST):
+                    self._prepare_package(pkg, machine)
 
         # Call subdir() for each required member of the workspace. The order is
         # important, if a member depends on another member, that member must be
@@ -216,12 +220,16 @@ def _process_member(member: str) -> None:
             if member in processed_members:
                 return
             pkg = ws.packages[member]
-            cfg = pkg.cfg[MachineChoice.HOST]
-            for depname in cfg.required_deps:
-                dep = pkg.manifest.dependencies[depname]
-                if dep.path:
-                    dep_member = os.path.normpath(os.path.join(pkg.ws_member, dep.path))
-                    _process_member(dep_member)
+            # Process dependencies for all configured machines
+            for machine in MachineChoice:
+                cfg = pkg.cfg[machine]
+                if cfg is None:
+                    continue
+                for depname in cfg.required_deps:
+                    dep = pkg.manifest.dependencies[depname]
+                    if dep.path:
+                        dep_member = os.path.normpath(os.path.join(pkg.ws_member, dep.path))
+                        _process_member(dep_member)
             if member == '.':
                 ast.extend(self._create_package(pkg, build, subdir))
             else:
@@ -301,20 +309,21 @@ def _fetch_package_from_subproject(self, package_name: str, meson_depname: str)
         self.packages[key] = pkg
         return pkg, False
 
-    def _prepare_package(self, pkg: PackageState) -> None:
-        if pkg.cfg[MachineChoice.HOST]:
-            return
+    def _prepare_package(self, pkg: PackageState, machine: MachineChoice) -> None:
+        """Prepare package configuration for specific machine."""
+        if pkg.cfg[machine] is not None:
+            return  # Already prepared for this machine
 
-        _ = pkg.get_or_create_cfg(MachineChoice.HOST)
-        # Merge target specific dependencies that are enabled
-        cfgs = self._get_cfgs(MachineChoice.HOST)
+        _ = pkg.get_or_create_cfg(machine)
+        # Merge target-specific dependencies that are enabled for this machine
+        target_cfgs = self._get_cfgs(machine)
         for condition, dependencies in pkg.manifest.target.items():
-            if eval_cfg(condition, cfgs):
+            if eval_cfg(condition, target_cfgs):
                 pkg.manifest.dependencies.update(dependencies)
-        # Fetch required dependencies recursively.
+        # Fetch required dependencies recursively for this machine
         for depname, dep in pkg.manifest.dependencies.items():
             if not dep.optional:
-                self._add_dependency(pkg, depname)
+                self._add_dependency(pkg, depname, machine)
 
     def _dep_package(self, pkg: PackageState, dep: Dependency) -> PackageState:
         if dep.path:
@@ -369,8 +378,8 @@ def _load_manifest(self, subdir: str, workspace: T.Optional[Workspace] = None, m
             self.manifests[subdir] = manifest_
         return manifest_
 
-    def _add_dependency(self, pkg: PackageState, depname: str) -> None:
-        cfg = pkg.cfg[MachineChoice.HOST]
+    def _add_dependency(self, pkg: PackageState, depname: str, machine: MachineChoice) -> None:
+        cfg = pkg.cfg[machine]
         if depname in cfg.required_deps:
             return
         dep = pkg.manifest.dependencies.get(depname)
@@ -379,22 +388,24 @@ def _add_dependency(self, pkg: PackageState, depname: str) -> None:
             return
         cfg.required_deps.add(depname)
         dep_pkg = self._dep_package(pkg, dep)
-        self._prepare_package(dep_pkg)
-        if dep.default_features:
-            self._enable_feature(dep_pkg, 'default')
-        for f in dep.features:
-            self._enable_feature(dep_pkg, f)
-        for f in cfg.optional_deps_features[depname]:
-            self._enable_feature(dep_pkg, f)
-
-    def _enable_feature(self, pkg: PackageState, feature: str) -> None:
-        cfg = pkg.cfg[MachineChoice.HOST]
+        # Use machines_from() to determine which machines the dependency needs
+        for dep_machine in dep_pkg.manifest.machines_from(machine):
+            self._prepare_package(dep_pkg, dep_machine)
+            if dep.default_features:
+                self._enable_feature(dep_pkg, 'default', dep_machine)
+            for f in dep.features:
+                self._enable_feature(dep_pkg, f, dep_machine)
+            for f in cfg.optional_deps_features[depname]:
+                self._enable_feature(dep_pkg, f, dep_machine)
+
+    def _enable_feature(self, pkg: PackageState, feature: str, machine: MachineChoice) -> None:
+        cfg = pkg.cfg[machine]
         if feature in cfg.features:
             return
         cfg.features.add(feature)
         # A feature can also be a dependency.
         if feature in pkg.manifest.dependencies:
-            self._add_dependency(pkg, feature)
+            self._add_dependency(pkg, feature, machine)
         # Recurse on extra features and dependencies this feature pulls.
         # https://doc.rust-lang.org/cargo/reference/features.html#the-features-section
         for f in pkg.manifest.features.get(feature, []):
@@ -403,19 +414,21 @@ def _enable_feature(self, pkg: PackageState, feature: str) -> None:
                 if depname[-1] == '?':
                     depname = depname[:-1]
                 else:
-                    self._add_dependency(pkg, depname)
+                    self._add_dependency(pkg, depname, machine)
                 if depname in cfg.required_deps:
                     dep = pkg.manifest.dependencies[depname]
                     dep_pkg = self._dep_package(pkg, dep)
-                    self._enable_feature(dep_pkg, dep_f)
+                    # Use machines_from() to determine which machines the dependency needs
+                    for dep_machine in dep_pkg.manifest.machines_from(machine):
+                        self._enable_feature(dep_pkg, dep_f, dep_machine)
                 else:
                     # This feature will be enabled only if that dependency
                     # is later added.
                     cfg.optional_deps_features[depname].add(dep_f)
             elif f.startswith('dep:'):
-                self._add_dependency(pkg, f[4:])
+                self._add_dependency(pkg, f[4:], machine)
             else:
-                self._enable_feature(pkg, f)
+                self._enable_feature(pkg, f, machine)
 
     def has_check_cfg(self, machine: MachineChoice) -> bool:
         if not self.environment.is_cross_build():
@@ -507,8 +520,10 @@ def _create_dependencies(self, pkg: PackageState, build: builder.Builder, machin
         for depname in cfg.required_deps:
             dep = pkg.manifest.dependencies[depname]
             dep_pkg = self._dep_package(pkg, dep)
-            if dep_pkg.manifest.lib:
-                ast += self._create_dependency(dep_pkg, dep, build, machine)
+            if not dep_pkg.manifest.lib:
+                continue
+            for dep_machine in dep_pkg.manifest.machines_from(machine):
+                ast += self._create_dependency(dep_pkg, dep, build, dep_machine)
         ast.append(build.assign(build.array([]), 'system_deps_args'))
         for name, sys_dep in pkg.manifest.system_dependencies.items():
             if sys_dep.enabled(cfg.features):
@@ -632,10 +647,11 @@ def _create_lib(self, pkg: PackageState, build: builder.Builder, crate_type: raw
         for name in cfg.required_deps:
             dep = pkg.manifest.dependencies[name]
             dep_pkg = self._dep_package(pkg, dep)
-            dependencies.append(build.identifier(_dependency_varname(dep.package, machine)))
+            for dep_machine in dep_pkg.manifest.machines_from(machine):
+                dependencies.append(build.identifier(_dependency_varname(dep.package, dep_machine)))
             dep_lib_name = dep_pkg.manifest.lib.name
             dep_crate_name = name if name != dep.package else dep_lib_name
-            dependency_map[build.string(_fixup_meson_target_name(dep_lib_name, machine))] = build.string(dep_crate_name)
+            dependency_map[build.string(_fixup_meson_target_name(dep_lib_name, dep_machine))] = build.string(dep_crate_name)
         for name, sys_dep in pkg.manifest.system_dependencies.items():
             if sys_dep.enabled(cfg.features):
                 dependencies.append(build.identifier(f'{fixup_meson_varname(name)}_system_dep'))

mesonbuild/cargo/manifest.py

@@ -11,7 +11,7 @@
 import typing as T
 
 from . import version
-from ..mesonlib import MesonException, lazy_property, Version
+from ..mesonlib import MesonException, lazy_property, Version, MachineChoice
 from .. import mlog
 
 if T.TYPE_CHECKING:
@@ -513,6 +513,26 @@ class Manifest:
     def __post_init__(self) -> None:
         self.features.setdefault('default', [])
 
+    def machines_from(self, parent_machine: MachineChoice) -> T.Iterable[MachineChoice]:
+        """Return the machines this manifest should be built for based on the machine
+           for the package that depended on this one."""
+        if self.lib is None:
+            # No support for bin, test, etc.
+            return
+
+        need_build = False
+        need_host = False
+        for crate_type in self.lib.crate_type:
+            if crate_type == 'proc-macro' or parent_machine == MachineChoice.BUILD:
+                need_build = True
+            else:
+                need_host = True
+
+        if need_build:
+            yield MachineChoice.BUILD
+        if need_host:
+            yield MachineChoice.HOST
+
     @lazy_property
     def system_dependencies(self) -> T.Dict[str, SystemDependency]:
         return {k: SystemDependency.from_raw(k, v) for k, v in self.package.metadata.get('system-deps', {}).items()}