modules: rust: add package.override_dependency method

Signed-off-by: Paolo Bonzini <[email protected]>

Author: bonzini

docs/markdown/Rust-module.md

@@ -421,6 +421,33 @@ Builds a proc-macro crate for a workspace package.
 
 Accepts all keyword arguments from [[shared_library]].
 
+#### package.override_dependency()
+
+```meson
+pkg.override_dependency(dep[, rust_abi: abi])
+```
+
+Keyword arguments:
+- `rust_abi`: (`str`, optional) The ABI to use for the dependency. Valid values are
+  `'rust'`, `'c'`, or `'proc-macro'`; the value must match the crate types and is
+  mandatory if more than one ABI is exposed by the crate.
+
+Make the crate available as a dependency to other crates.  This is the same
+as calling `meson.override_dependency`, but it computes the correct dependency
+name from `pkg`'s name, API version and ABI (Rust vs. C).
+
+It is typically used with `library() or `proc_macro()`, for example:
+
+```meson
+lib_pkg = cargo.package('myproject-lib')
+lib = lib_pkg.library(install: false)
+lib_pkg.override_dependency(declare_dependency(link_with: lib))
+
+# Declares myproject-lib as a dependency in Cargo.toml
+exe_pkg = cargo.package()
+exe_pkg.executable(install: true)
+```
+
 #### package.executable()
 
 ```meson

mesonbuild/cargo/interpreter.py

@@ -813,9 +813,6 @@ def _create_lib(self, pkg: PackageState, build: builder.Builder, subdir: str,
             'rust_args': build.identifier(_extra_args_varname()),
         }
 
-        depname_suffix = '' if lib_type == 'c' else '-rs'
-        depname = _dependency_name(pkg.manifest.package.name, pkg.manifest.package.api, depname_suffix)
-
         if lib_type == 'proc-macro':
             lib = build.method('proc_macro', build.identifier('pkg_obj'), posargs, kwargs)
         else:
@@ -843,9 +840,8 @@ def _create_lib(self, pkg: PackageState, build: builder.Builder, subdir: str,
             ),
             build.method(
                 'override_dependency',
-                build.identifier('meson'),
+                build.identifier('pkg_obj'),
                 [
-                    build.string(depname),
                     build.identifier('dep'),
                 ],
             ),

mesonbuild/modules/__init__.py

@@ -7,14 +7,15 @@
 import dataclasses
 import typing as T
 
-from .. import build, dependencies, mesonlib
+from .. import build, dependencies, mesonlib, mlog
 from ..options import OptionKey
 from ..build import IncludeDirs
 from ..interpreterbase.decorators import noKwargs, noPosargs
 from ..mesonlib import relpath, HoldableObject, MachineChoice
 from ..programs import ExternalProgram
 
 if T.TYPE_CHECKING:
+    from ..dependencies.base import DependencyObjectKWs
     from ..interpreter import Interpreter
     from ..interpreter.interpreter import ProgramVersionFunc
     from ..interpreterbase import TYPE_var, TYPE_kwargs
@@ -110,6 +111,20 @@ def find_tool(self, name: str, depname: str, varname: str, required: bool = True
         # Normal program lookup
         return self.find_program(name, required=required, wanted=wanted)
 
+    def override_dependency(self, depname: str, dep: Dependency, static: T.Optional[bool] = None,
+                            for_machine: MachineChoice = MachineChoice.HOST) -> None:
+        kwargs: DependencyObjectKWs = {}
+        if static is not None:
+            kwargs['static'] = static
+        identifier = dependencies.get_dep_identifier(depname, kwargs)
+        override = self.dependency_overrides[for_machine].get(identifier)
+        if override:
+            m = 'Tried to override dependency {!r} which has already been resolved or overridden at {}'
+            location = mlog.get_error_location_string(override.node.filename, override.node.lineno)
+            raise mesonlib.MesonException(m.format(depname, location))
+        self.dependency_overrides[for_machine][identifier] = \
+            build.DependencyOverride(dep, self._interpreter.current_node)
+
     def overridden_dependency(self, depname: str, for_machine: MachineChoice = MachineChoice.HOST) -> Dependency:
         identifier = dependencies.get_dep_identifier(depname, {})
         try:

mesonbuild/modules/rust.py

@@ -250,6 +250,7 @@ def __init__(self, rust_ws: RustWorkspace, package: cargo.PackageState) -> None:
             'proc_macro': self.proc_macro_method,
             'shared_module': self.shared_module_method,
             'executable': self.executable_method,
+            'override_dependency': self.override_dependency_method,
         })
 
     @noPosargs
@@ -362,6 +363,19 @@ def _proc_macro_method(self, state: 'ModuleState', args: T.Tuple[
         result = self._library_method(state, args, kwargs, shared=True, static=False)
         return T.cast('SharedLibrary', result)
 
+    @typed_pos_args('package.override_dependency', Dependency)
+    @typed_kwargs('package.override_dependency',
+                  KwargInfo('rust_abi', (str, NoneType), default=None, validator=in_set_validator({'rust', 'c', 'proc-macro'})))
+    def override_dependency_method(self, state: ModuleState, args: T.Tuple[Dependency], kwargs: FuncDependency) -> None:
+        dep = args[0]
+        rust_abi = self.package.abi_resolve_default(kwargs['rust_abi'])
+        depname = self.package.get_dependency_name(rust_abi)
+        state.override_dependency(depname, dep)
+        if self.package.abi_has_static(rust_abi):
+            state.override_dependency(depname, dep, static=True)
+        if self.package.abi_has_shared(rust_abi):
+            state.override_dependency(depname, dep, static=False)
+
     @typed_pos_args('package.library', optargs=[(str, StructuredSources), StructuredSources])
     @typed_kwargs(
         'package.library',

test cases/rust/32 rust.workspace workspace/more/meson.build

@@ -9,4 +9,4 @@ l = static_library('more', 'src/lib.rs',
   rust_dependency_map: more_pkg.rust_dependency_map(),
 )
 more_dep = declare_dependency(link_with: l)
-meson.override_dependency('more-0.1-rs', more_dep)
+more_pkg.override_dependency(more_dep)