cargo: use dependencies() method to get dependencies

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

1 files changed, 22 insertions, 62 deletions

diff --git a/mesonbuild/cargo/interpreter.py b/mesonbuild/cargo/interpreter.py
index fc3465a0f..fcdc661a3 100644
--- a/mesonbuild/cargo/interpreter.py
+++ b/mesonbuild/cargo/interpreter.py
@@ -35,7 +35,7 @@ if T.TYPE_CHECKING:
     from .. import mparser
     from typing_extensions import Literal
 
-    from .manifest import Dependency, SystemDependency
+    from .manifest import Dependency
     from ..environment import Environment
     from ..interpreterbase import SubProject
     from ..compilers.rust import RustCompiler
@@ -47,10 +47,6 @@ def _dependency_name(package_name: str, api: str, suffix: str = '-rs') -> str:
     return f'{basename}-{api}{suffix}'
 
 
-def _dependency_varname(dep: Dependency) -> str:
-    return f'{fixup_meson_varname(dep.package)}_{(dep.api.replace(".", "_"))}_dep'
-
-
 def _library_name(name: str, api: str, lib_type: Literal['rust', 'c', 'proc-macro'] = 'rust') -> str:
     # Add the API version to the library name to avoid conflicts when multiple
     # versions of the same crate are used. The Ninja backend removed everything
@@ -711,40 +707,15 @@ class Interpreter:
             dep_pkg = self._dep_package(pkg, dep)
             if dep_pkg.manifest.lib:
                 ast += self._create_dependency(dep_pkg, dep, build)
-        for name, sys_dep in pkg.manifest.system_dependencies.items():
-            if sys_dep.enabled(cfg.features):
-                ast += self._create_system_dependency(name, sys_dep, build)
         return ast
 
-    def _create_system_dependency(self, name: str, dep: SystemDependency, build: builder.Builder) -> T.List[mparser.BaseNode]:
-        # TODO: handle feature_overrides
-        kw = {
-            'version': build.array([build.string(s) for s in dep.meson_version]),
-            'required': build.bool(not dep.optional),
-        }
-        varname = f'{fixup_meson_varname(name)}_system_dep'
-        return [
-            build.assign(
-                build.method(
-                    'to_system_dependency',
-                    build.identifier('rust'), [
-                        build.function(
-                            'dependency',
-                            [build.string(dep.name)],
-                            kw,
-                        ),
-                        build.string(name)
-                    ]),
-                varname,
-            ),
-        ]
-
     def _create_dependency(self, pkg: PackageState, dep: Dependency, build: builder.Builder) -> T.List[mparser.BaseNode]:
         cfg = pkg.cfg
-        dep_obj: mparser.BaseNode
+        feat_obj: mparser.BaseNode
         if self.cargolock and self.resolve_package(dep.package, dep.api):
-            dep_obj = build.method(
-                'dependency',
+            # actual_features = cargo_ws.subproject(...).features()
+            feat_obj = build.method(
+                'features',
                 build.method(
                     'subproject',
                     build.identifier('cargo_ws'),
@@ -754,10 +725,21 @@ class Interpreter:
             kw = {
                 'version': build.array([build.string(s) for s in version_]),
             }
+            # actual_features = dependency(...).get_variable('features', default_value : '').split(',')
             dep_obj = build.function(
                  'dependency',
                  [build.string(_dependency_name(dep.package, dep.api))],
                  kw)
+            feat_obj = build.method(
+                'split',
+                build.method(
+                    'get_variable',
+                    dep_obj,
+                    [build.string('features')],
+                    {'default_value': build.string('')}
+                ),
+                [build.string(',')],
+            )
 
         # However, this subproject could have been previously configured with a
         # different set of features. Cargo collects the set of features globally
@@ -769,23 +751,9 @@ class Interpreter:
         # option manually with -Dxxx-rs:feature-yyy=true, or the main project can do
         # that in its project(..., default_options: ['xxx-rs:feature-yyy=true']).
         return [
-            # xxx_dep = cargo_ws.subproject('xxx', 'api').dependency()
+            # actual_features = dependency(...).get_variable('features', default_value : '').split(',')
             build.assign(
-                dep_obj,
-                _dependency_varname(dep),
-            ),
-            # actual_features = xxx_dep.get_variable('features', default_value : '').split(',')
-            build.assign(
-                build.method(
-                    'split',
-                    build.method(
-                        'get_variable',
-                        build.identifier(_dependency_varname(dep)),
-                        [build.string('features')],
-                        {'default_value': build.string('')}
-                    ),
-                    [build.string(',')],
-                ),
+                feat_obj,
                 'actual_features'
             ),
             # needed_features = [f1, f2, ...]
@@ -830,22 +798,14 @@ class Interpreter:
     def _create_lib(self, pkg: PackageState, build: builder.Builder, subdir: str,
                     lib_type: RUST_ABI,
                     static: bool = False, shared: bool = False) -> T.List[mparser.BaseNode]:
-        cfg = pkg.cfg
-        dependencies: T.List[mparser.BaseNode] = []
-        for name in cfg.required_deps:
-            dep = pkg.manifest.dependencies[name]
-            dependencies.append(build.identifier(_dependency_varname(dep)))
-
-        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'))
+        pkg_dependencies = build.method('dependencies', build.identifier('pkg_obj'))
+        extra_deps_ref = build.identifier(_extra_deps_varname())
+        dependencies = build.plus(pkg_dependencies, extra_deps_ref)
 
         package_rust_args = build.method('rust_args', build.identifier('pkg_obj'))
         extra_args_ref = build.identifier(_extra_args_varname())
         rust_args = build.plus(package_rust_args, extra_args_ref)
 
-        dependencies.append(build.identifier(_extra_deps_varname()))
-
         override_options: T.Dict[mparser.BaseNode, mparser.BaseNode] = {
             build.string('rust_std'): build.string(pkg.manifest.package.edition),
         }
@@ -856,7 +816,7 @@ class Interpreter:
         ]
 
         kwargs: T.Dict[str, mparser.BaseNode] = {
-            'dependencies': build.array(dependencies),
+            'dependencies': dependencies,
             'rust_dependency_map': build.method('rust_dependency_map', build.identifier('pkg_obj')),
             'rust_args': rust_args,
             'override_options': build.dict(override_options),