cargo: pick exact dependency version from Cargo.toml

A dependency might specify a version that is compatible with the one
in Cargo.lock, but not the exact same version.  Whenever Cargo.lock
contains the package, only use the pinned versions that can be used;
update the version in the manifest so that the correct API level is
used as well.

Originally by Xavier Claessens <xclaessens@netflix.com>, but
almost completely rewritten.

Author: bonzini

mesonbuild/cargo/interpreter.py

@@ -20,7 +20,7 @@
 from . import builder, version, cfg
 from .toml import load_toml
 from .manifest import Manifest, CargoLock, fixup_meson_varname
-from ..mesonlib import MesonException, MachineChoice
+from ..mesonlib import MesonException, MachineChoice, version_compare_many
 from .. import coredata, mlog
 from ..wrap.wrap import PackageDefinition
 
@@ -151,6 +151,19 @@ def _dep_package(self, dep: Dependency) -> PackageState:
             _, _, directory = _parse_git_url(dep.git, dep.branch)
             dep_pkg, _ = self._fetch_package_from_subproject(dep.package, directory)
         else:
+            # From all available versions from Cargo.lock, pick the most recent
+            # satisfying the constraints
+            if self.cargolock:
+                cargo_lock_pkgs = self.cargolock.named(dep.package)
+            else:
+                cargo_lock_pkgs = []
+            for cargo_pkg in cargo_lock_pkgs:
+                if version_compare_many(cargo_pkg.version, dep.meson_version):
+                    dep.update_version(f'={cargo_pkg.version}')
+                    break
+            else:
+                if not dep.meson_version:
+                    raise MesonException(f'Cannot determine version of cargo package {dep.package}')
             dep_pkg, _ = self._fetch_package(dep.package, dep.api)
         return dep_pkg
 

mesonbuild/cargo/manifest.py

@@ -5,12 +5,13 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
 import dataclasses
 import os
 import typing as T
 
 from . import version
-from ..mesonlib import MesonException, lazy_property
+from ..mesonlib import MesonException, lazy_property, Version
 from .. import mlog
 
 if T.TYPE_CHECKING:
@@ -254,7 +255,7 @@ def api(self) -> str:
             elif v.startswith('='):
                 api.add(version.api(v[1:].strip()))
         if not api:
-            return '0'
+            return ''
         elif len(api) == 1:
             return api.pop()
         else:
@@ -280,6 +281,17 @@ def from_raw(cls, name: str, raw_depv: T.Union[raw.FromWorkspace, raw.Dependency
         raw_dep = _depv_to_dep(raw_depv)
         return cls.from_raw_dict(name, raw_dep, member_path, raw_ws_dep)
 
+    def update_version(self, v: str) -> None:
+        self.version = v
+        try:
+            delattr(self, 'api')
+        except AttributeError:
+            pass
+        try:
+            delattr(self, 'meson_version')
+        except AttributeError:
+            pass
+
 
 @dataclasses.dataclass
 class BuildTarget(T.Generic[_R]):
@@ -489,6 +501,14 @@ class CargoLockPackage:
     checksum: T.Optional[str] = None
     dependencies: T.List[str] = dataclasses.field(default_factory=list)
 
+    @lazy_property
+    def api(self) -> str:
+        return version.api(self.version)
+
+    @lazy_property
+    def subproject(self) -> str:
+        return f'{self.name}-{self.api}-rs'
+
     @classmethod
     def from_raw(cls, raw: raw.CargoLockPackage) -> CargoLockPackage:
         return _raw_to_dataclass(raw, cls, 'Cargo.lock package')
@@ -508,3 +528,15 @@ class CargoLock:
     def from_raw(cls, raw: raw.CargoLock) -> CargoLock:
         return _raw_to_dataclass(raw, cls, 'Cargo.lock',
                                  package=lambda x: [CargoLockPackage.from_raw(p) for p in x])
+
+    def named(self, name: str) -> T.Sequence[CargoLockPackage]:
+        return self._versions[name]
+
+    @lazy_property
+    def _versions(self) -> T.Dict[str, T.List[CargoLockPackage]]:
+        versions = defaultdict(list)
+        for pkg in self.package:
+            versions[pkg.name].append(pkg)
+        for pkg_versions in versions.values():
+            pkg_versions.sort(reverse=True, key=lambda pkg: Version(pkg.version))
+        return versions