rust: add rust.workspace() skeleton implementation

rust.workspace() is the entry point for global feature resolution.
It loads a Cargo.toml file and ensures that all dependencies will be
built with the correct set of features.

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

3 files changed, 45 insertions, 9 deletions

diff --git a/mesonbuild/cargo/__init__.py b/mesonbuild/cargo/__init__.py
index c5b157f3c..d461d10bb 100644
--- a/mesonbuild/cargo/__init__.py
+++ b/mesonbuild/cargo/__init__.py
@@ -1,7 +1,8 @@
 __all__ = [
     'Interpreter',
     'TomlImplementationMissing',
+    'WorkspaceState',
 ]
 
-from .interpreter import Interpreter
+from .interpreter import Interpreter, WorkspaceState
 from .toml import TomlImplementationMissing
diff --git a/mesonbuild/cargo/interpreter.py b/mesonbuild/cargo/interpreter.py
index 4f3acc133..cc7e2a65b 100644
--- a/mesonbuild/cargo/interpreter.py
+++ b/mesonbuild/cargo/interpreter.py
@@ -227,6 +227,15 @@ class Interpreter:
     def get_build_def_files(self) -> T.List[str]:
         return self.build_def_files
 
+    def load_workspace(self, subdir: str) -> WorkspaceState:
+        """Load the root Cargo.toml package and prepare it with features and dependencies."""
+        subdir = os.path.normpath(subdir)
+        manifest, cached = self._load_manifest(subdir)
+        ws = self._get_workspace(manifest, subdir, False)
+        if not cached:
+            self._prepare_entry_point(ws)
+        return ws
+
     def _prepare_entry_point(self, ws: WorkspaceState) -> None:
         pkgs = [self._require_workspace_member(ws, m) for m in ws.workspace.default_members]
         for pkg in pkgs:
@@ -234,18 +243,16 @@ class Interpreter:
             self._enable_feature(pkg, 'default')
 
     def interpret(self, subdir: str, project_root: T.Optional[str] = None) -> mparser.CodeBlockNode:
-        manifest, cached = self._load_manifest(subdir)
         filename = os.path.join(self.environment.source_dir, subdir, 'Cargo.toml')
         build = builder.Builder(filename)
         if project_root:
             # this is a subdir()
+            manifest, _ = self._load_manifest(subdir)
             assert isinstance(manifest, Manifest)
             return self.interpret_package(manifest, build, subdir, project_root)
-
-        ws = self._get_workspace(manifest, subdir, downloaded=False)
-        if not cached:
-            self._prepare_entry_point(ws)
-        return self.interpret_workspace(ws, build, subdir)
+        else:
+            ws = self.load_workspace(subdir)
+            return self.interpret_workspace(ws, build, subdir)
 
     def interpret_package(self, manifest: Manifest, build: builder.Builder, subdir: str, project_root: str) -> mparser.CodeBlockNode:
         # Build an AST for this package
diff --git a/mesonbuild/modules/rust.py b/mesonbuild/modules/rust.py
index a8fcc86a0..84ea70fce 100644
--- a/mesonbuild/modules/rust.py
+++ b/mesonbuild/modules/rust.py
@@ -10,7 +10,7 @@ import typing as T
 
 from mesonbuild.interpreterbase.decorators import FeatureNew
 
-from . import ExtensionModule, ModuleReturnValue, ModuleInfo
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo, ModuleObject
 from .. import mesonlib, mlog
 from ..build import (BothLibraries, BuildTarget, CustomTargetIndex, Executable, ExtractedObjects, GeneratedList,
                      CustomTarget, InvalidArguments, Jar, StructuredSources, SharedLibrary, StaticLibrary)
@@ -19,7 +19,8 @@ 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
 )
-from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, typed_kwargs, typed_pos_args, noPosargs, permittedKwargs
+from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, typed_kwargs, typed_pos_args, noKwargs, noPosargs, permittedKwargs
+from ..interpreterbase.baseobjects import TYPE_kwargs
 from ..interpreter.interpreterobjects import Doctest
 from ..mesonlib import File, MachineChoice, MesonException, PerMachine
 from ..programs import ExternalProgram, NonExistingExternalProgram
@@ -27,6 +28,7 @@ from ..programs import ExternalProgram, NonExistingExternalProgram
 if T.TYPE_CHECKING:
     from . import ModuleState
     from ..build import BuildTargetTypes, ExecutableKeywordArguments, IncludeDirs, LibTypes
+    from .. import cargo
     from ..compilers.rust import RustCompiler
     from ..dependencies import Dependency, ExternalLibrary
     from ..interpreter import Interpreter
@@ -81,6 +83,16 @@ def no_spaces_validator(arg: T.Optional[T.Union[str, T.List]]) -> T.Optional[str
     return None
 
 
+class RustWorkspace(ModuleObject):
+    """Represents a Rust workspace, controlling the build of packages
+       recorded in a Cargo.lock file."""
+
+    def __init__(self, interpreter: Interpreter, ws: cargo.WorkspaceState) -> None:
+        super().__init__()
+        self.interpreter = interpreter
+        self.ws = ws
+
+
 class RustModule(ExtensionModule):
 
     """A module that holds helper functions for rust."""
@@ -103,6 +115,7 @@ class RustModule(ExtensionModule):
             'doctest': self.doctest,
             'bindgen': self.bindgen,
             'proc_macro': self.proc_macro,
+            'workspace': self.workspace,
         })
 
     def test_common(self, funcname: str, state: ModuleState, args: T.Tuple[str, BuildTarget], kwargs: FuncRustTest) -> T.Tuple[Executable, _kwargs.FuncTest]:
@@ -500,6 +513,21 @@ class RustModule(ExtensionModule):
         target = state._interpreter.build_target(state.current_node, args, kwargs, SharedLibrary)
         return target
 
+    @FeatureNew('rust.workspace', '1.11.0')
+    @noPosargs
+    @noKwargs
+    def workspace(self, state: ModuleState, args: T.List, kwargs: TYPE_kwargs) -> RustWorkspace:
+        """Creates a Rust workspace object, controlling the build of
+           all the packages in a Cargo.lock file."""
+        if self.interpreter.cargo is None:
+            raise MesonException("rust.workspace() requires a Cargo project (Cargo.toml and Cargo.lock)")
+
+        self.interpreter.add_languages(['rust'], True, MachineChoice.HOST)
+        self.interpreter.add_languages(['rust'], True, MachineChoice.BUILD)
+
+        ws = self.interpreter.cargo.load_workspace(state.root_subdir)
+        return RustWorkspace(self.interpreter, ws)
+
 
 def initialize(interp: Interpreter) -> RustModule:
     return RustModule(interp)