modules: rust: implement workspace.subproject() and package.dependency()

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

Author: bonzini

docs/markdown/Rust-module.md

@@ -203,3 +203,36 @@ are specified.
 
 When `features` is provided without `default_features`, the 'default' feature is
 automatically included.
+
+#### workspace.subproject()
+
+```meson
+package = ws.subproject(package_name, ...)
+```
+
+Returns a `package` object for managing a specific package within the workspace.
+
+Positional arguments:
+- `package_name`: (`str`) The name of the package to retrieve
+
+Keyword arguments:
+- `version`: (`list[str]`, optional) List of version constraints for the package
+
+## Package object
+
+The package object returned by `workspace.subproject()` provides methods for working with individual packages in a Cargo workspace.
+
+### package.dependency()
+
+```meson
+dep = package.dependency(...)
+```
+
+Returns a dependency object for the package that can be used with other Meson targets.
+
+*Note*: right now, this method is implemented on top of the normal Meson function
+[[dependency]]; this is subject to change in future releases.  It is recommended
+to always retrieve a Cargo subproject's dependency object via this method.
+
+Keyword arguments:
+- `rust_abi`: (`str`, optional) The ABI to use for the dependency. Valid values are `'rust'` (default), `'c'`, or `'proc-macro'`. The package must support the specified ABI.

mesonbuild/cargo/interpreter.py

@@ -28,11 +28,15 @@
 if T.TYPE_CHECKING:
     from . import raw
     from .. import mparser
+    from typing_extensions import Literal
+
     from .manifest import Dependency, SystemDependency
     from ..environment import Environment
     from ..interpreterbase import SubProject
     from ..compilers.rust import RustCompiler
 
+    RUST_ABI = Literal['rust', 'c', 'proc-macro']
+
 def _dependency_name(package_name: str, api: str, suffix: str = '-rs') -> str:
     basename = package_name[:-len(suffix)] if package_name.endswith(suffix) else package_name
     return f'{basename}-{api}{suffix}'
@@ -70,6 +74,34 @@ class PackageState:
     # Package configuration state
     cfg: T.Optional[PackageConfiguration] = None
 
+    def uses_abi(self, abi: str) -> bool:
+        """Check if this package supports the given ABI."""
+        crate_types = self.manifest.lib.crate_type
+        if abi == 'rust':
+            return any(ct in {'lib', 'rlib'} for ct in crate_types)
+        elif abi == 'c':
+            return any(ct in {'staticlib', 'cdylib'} for ct in crate_types)
+        elif abi == 'proc-macro':
+            return 'proc-macro' in crate_types
+        else:
+            return False
+
+    def get_dependency_name(self, rust_abi: RUST_ABI) -> str:
+        """Get the dependency name for a package with the given ABI."""
+        if not self.uses_abi(rust_abi):
+            raise MesonException(f'Package {self.manifest.package.name} does not support ABI {rust_abi}')
+
+        # TODO: Implement dependency name generation
+        package_name = self.manifest.package.name
+        api = self.manifest.package.api
+
+        if rust_abi in {'rust', 'proc-macro'}:
+            return f'{package_name}-{api}-rs'
+        elif rust_abi == 'c':
+            return f'{package_name}-{api}'
+        else:
+            raise MesonException(f'Unknown rust_abi: {rust_abi}')
+
 
 @dataclasses.dataclass(frozen=True)
 class PackageKey:
@@ -300,6 +332,11 @@ def _resolve_package(self, package_name: str, version_constraints: T.List[str])
             raise MesonException(f'Cannot determine version of cargo package {package_name}')
         return None
 
+    def resolve_package(self, package_name: str, version_constraints: T.List[str]) -> T.Optional[PackageState]:
+        cargo_pkg = self._resolve_package(package_name, version_constraints)
+        api = version.api(cargo_pkg.version)
+        return self._fetch_package(package_name, api)
+
     def _fetch_package_from_subproject(self, package_name: str, meson_depname: str) -> PackageState:
         subp_name, _ = self.environment.wrap_resolver.find_dep_provider(meson_depname)
         if subp_name is None:

mesonbuild/modules/__init__.py

@@ -7,7 +7,7 @@
 import dataclasses
 import typing as T
 
-from .. import build, mesonlib
+from .. import build, dependencies, mesonlib
 from ..options import OptionKey
 from ..build import IncludeDirs
 from ..interpreterbase.decorators import noKwargs, noPosargs
@@ -46,6 +46,7 @@ def __init__(self, interpreter: 'Interpreter') -> None:
         # The backend object is under-used right now, but we will need it:
         # https://github.com/mesonbuild/meson/issues/1419
         self.backend = interpreter.backend
+        self.dependency_overrides = interpreter.build.dependency_overrides
         self.targets = interpreter.build.targets
         self.data = interpreter.build.data
         self.headers = interpreter.build.get_headers()
@@ -108,6 +109,13 @@ 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 overridden_dependency(self, depname: str, for_machine: MachineChoice = MachineChoice.HOST) -> Dependency:
+        identifier = dependencies.get_dep_identifier(depname, {})
+        try:
+            return self.dependency_overrides[for_machine][identifier].dep
+        except KeyError:
+            raise mesonlib.MesonException(f'dependency "{depname}" was not overridden for the {for_machine}')
+
     def dependency(self, depname: str, native: bool = False, required: bool = True,
                    wanted: T.Optional[str] = None) -> 'Dependency':
         kwargs: T.Dict[str, object] = {'native': native, 'required': required}

mesonbuild/modules/rust.py

@@ -14,7 +14,9 @@
 from .. import mesonlib, mlog
 from ..build import (BothLibraries, BuildTarget, CustomTargetIndex, Executable, ExtractedObjects, GeneratedList,
                      CustomTarget, InvalidArguments, Jar, StructuredSources, SharedLibrary, StaticLibrary)
+from ..cargo import PackageState
 from ..compilers.compilers import are_asserts_disabled_for_subproject, lang_suffixes
+from ..dependencies import Dependency
 from ..interpreter.type_checking import (
     DEPENDENCIES_KW, LINK_WITH_KW, LINK_WHOLE_KW, SHARED_LIB_KWS, TEST_KWS, TEST_KWS_NO_ARGS,
     OUTPUT_KW, INCLUDE_DIRECTORIES, SOURCES_VARARGS, NoneType, in_set_validator
@@ -28,8 +30,9 @@
     from . import ModuleState
     from ..build import BuildTargetTypes, ExecutableKeywordArguments, IncludeDirs, LibTypes
     from .. import cargo
+    from ..cargo.interpreter import RUST_ABI
     from ..compilers.rust import RustCompiler
-    from ..dependencies import Dependency, ExternalLibrary
+    from ..dependencies import ExternalLibrary
     from ..interpreter import Interpreter
     from ..interpreter import kwargs as _kwargs
     from ..interpreter.interpreter import SourceInputs, SourceOutputs
@@ -69,6 +72,12 @@ class FuncWorkspace(TypedDict):
         features: T.List[str]
         dev_dependencies: bool
 
+    class FuncWorkspaceSubproject(TypedDict):
+        version: T.List[str]
+
+    class FuncDependency(TypedDict):
+        rust_abi: RUST_ABI
+
 RUST_TEST_KWS: T.List[KwargInfo] = [
      KwargInfo(
          'rust_args',
@@ -90,10 +99,55 @@ class RustWorkspace(MutableModuleObject):
     """Represents a Rust workspace, controlling the build of packages
        recorded in a Cargo.lock file."""
 
-    def __init__(self, state: ModuleState, root_package: T.Union[cargo.WorkspaceState, cargo.PackageState]) -> None:
+    def __init__(self, state: ModuleState, interpreter: Interpreter, root_package: T.Union[cargo.WorkspaceState, cargo.PackageState]) -> None:
         super().__init__()
         self.state = state
+        self.interpreter = interpreter
         self.root_package = root_package
+        self.methods.update({
+            'subproject': self.subproject_method,
+        })
+
+    @typed_pos_args('workspace.subproject', str)
+    @typed_kwargs('workspace.subproject',
+                  KwargInfo('version', ContainerTypeInfo(list, str), default=[], listify=True))
+    def subproject_method(self, state: ModuleState, args: T.Tuple[str], kwargs: FuncWorkspaceSubproject) -> RustPackage:
+        """Returns a package object for a subproject package."""
+        package_name = args[0]
+        pkg = self.interpreter.cargo.resolve_package(package_name, kwargs['version'])
+        if pkg is None:
+            raise MesonException(f'No version of cargo package {package_name} satisfies constraints {kwargs["version"]}')
+
+        kw: _kwargs.DoSubproject = {
+            'required': True,
+            'version': kwargs['version'],
+            'options': None,
+            'cmake_options': [],
+            'default_options': {},
+        }
+        subp_name = f'{pkg.manifest.package.name}-{pkg.manifest.package.api}-rs'
+        self.interpreter.do_subproject(subp_name, kw, force_method='cargo')
+        return RustPackage(state, pkg)
+
+
+class RustPackage(MutableModuleObject):
+    """Represents a Rust package within a workspace."""
+
+    def __init__(self, state: ModuleState, package: PackageState) -> None:
+        super().__init__()
+        self.state = state
+        self.package = package
+        self.methods.update({
+            'dependency': self.dependency_method,
+        })
+
+    @noPosargs
+    @typed_kwargs('package.dependency',
+                  KwargInfo('rust_abi', str, default='rust', validator=in_set_validator({'rust', 'c', 'proc-macro'})))
+    def dependency_method(self, state: 'ModuleState', args: T.List, kwargs: FuncDependency) -> Dependency:
+        """Returns dependency for the package with the given ABI."""
+        depname = self.package.get_dependency_name(kwargs['rust_abi'])
+        return self.state.overridden_dependency(depname)
 
 
 class RustModule(ExtensionModule):
@@ -557,7 +611,7 @@ def workspace(self, state: ModuleState, args: T.List, kwargs: FuncWorkspace) ->
         ws_obj = self._workspace_cache.get(self.interpreter.cargo)
         if ws_obj is None:
             root_pkg = self.interpreter.cargo.load_workspace()
-            ws_obj = RustWorkspace(state, root_pkg)
+            ws_obj = RustWorkspace(state, self.interpreter, root_pkg)
             self._workspace_cache[self.interpreter.cargo] = ws_obj
 
         return ws_obj

test cases/rust/31 rust.workspace package/meson.build

@@ -3,10 +3,18 @@ project('package test', 'rust', default_options: ['rust_std=2021'])
 rust = import('rust')
 cargo = rust.workspace()
 
-hello_dep = dependency('hello-1-rs')
-answer_dep = dependency('answer-1-rs')
+hello_rs = cargo.subproject('hello')
+answer_rs = cargo.subproject('answer')
 
 e = executable('package-test', 'src/main.rs',
-  dependencies: [hello_dep, answer_dep],
+  dependencies: [hello_rs.dependency(), answer_rs.dependency()],
 )
 test('package-test', e)
+
+# failure test cases for dependency()
+testcase expect_error('package.dependency.*must be one of c, proc-macro, rust.*', how: 're')
+  hello_rs.dependency(rust_abi: 'something else')
+endtestcase
+testcase expect_error('Package hello does not support ABI c')
+  hello_rs.dependency(rust_abi: 'c')
+endtestcase

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

@@ -3,10 +3,18 @@ project('workspace test', 'rust', default_options: ['rust_std=2021'])
 rust = import('rust')
 cargo = rust.workspace()
 
-hello_dep = dependency('hello-1-rs')
-answer_dep = dependency('answer-1-rs')
+hello_rs = cargo.subproject('hello')
+answer_rs = cargo.subproject('answer')
 
 e = executable('workspace-test', 'src/main.rs',
-  dependencies: [hello_dep, answer_dep],
+  dependencies: [hello_rs.dependency(), answer_rs.dependency()],
 )
 test('workspace-test', e)
+
+# failure test cases for dependency()
+testcase expect_error('package.dependency.*must be one of c, proc-macro, rust.*', how: 're')
+  hello_rs.dependency(rust_abi: 'something else')
+endtestcase
+testcase expect_error('Package hello does not support ABI c')
+  hello_rs.dependency(rust_abi: 'c')
+endtestcase