cargo: add configurable features to Interpreter

Add features property to cargo.Interpreter to make default features configurable;
customization of which features are enabled by default is triggered by
rust.workspace().

Author: bonzini

docs/markdown/Rust-module.md

@@ -180,9 +180,21 @@ rustmod.workspace(...)
 Create and return a `workspace` object for managing the project's Cargo
 workspace.
 
+Keyword arguments:
+- `default_features`: (`bool`, optional) Whether to enable default features.
+  If not specified and `features` is provided, defaults to true.
+- `features`: (`list[str]`, optional) List of additional features to enable globally
+
 The function must be called in a project with `Cargo.lock` and `Cargo.toml`
 files in the root source directory.  While the object currently has
 no methods, upon its creation Meson analyzes the `Cargo.toml` file and
 computes the full set of dependencies and features needed to build the
 package in `Cargo.toml`.  Therefore, this function should be invoked before
 using Cargo subprojects.  Methods will be added in future versions of Meson.
+
+If either argument is provided, the build will use a custom set of features.
+Features can only be set once - subsequent calls will fail if different features
+are specified.
+
+When `features` is provided without `default_features`, the 'default' feature is
+automatically included.

mesonbuild/cargo/interpreter.py

@@ -22,7 +22,7 @@
 from .cfg import eval_cfg
 from .toml import load_toml
 from .manifest import Manifest, CargoLock, Workspace, fixup_meson_varname
-from ..mesonlib import MesonException, MachineChoice, PerMachine, version_compare
+from ..mesonlib import MesonException, MachineChoice, PerMachine, unique_list, version_compare
 from .. import coredata, mlog
 from ..wrap.wrap import PackageDefinition
 
@@ -98,6 +98,8 @@ class WorkspaceState:
 
 
 class Interpreter:
+    _features: T.Optional[T.List[str]] = None
+
     def __init__(self, env: Environment, subdir: str, subprojects_dir: str) -> None:
         self.environment = env
         # Map Cargo.toml's subdir to loaded manifest.
@@ -115,6 +117,21 @@ def __init__(self, env: Environment, subdir: str, subprojects_dir: str) -> None:
             self.subdir = subdir
             self.environment.wrap_resolver.merge_wraps(self.cargolock.wraps)
 
+    @property
+    def features(self) -> T.List[str]:
+        """Get the features list. Once read, it cannot be modified."""
+        if self._features is None:
+            self._features = ['default']
+        return self._features
+
+    @features.setter
+    def features(self, value: T.List[str]) -> None:
+        """Set the features list. Can only be set before first read."""
+        value_unique = sorted(unique_list(value))
+        if self._features is not None and value_unique != self._features:
+            raise MesonException("Cannot modify features after they have been selected or used")
+        self._features = value_unique
+
     def get_build_def_files(self) -> T.List[str]:
         build_def_files = [os.path.join(subdir, 'Cargo.toml') for subdir in self.manifests]
         if self.cargolock:
@@ -130,7 +147,8 @@ def load_root_package(self) -> PackageState:
         key = PackageKey(manifest.package.name, manifest.package.api)
         self.packages[key] = pkg
         self._prepare_package(pkg, MachineChoice.HOST)
-        self._enable_feature(pkg, 'default', MachineChoice.HOST)
+        for feature in self.features:
+            self._enable_feature(pkg, feature, MachineChoice.HOST)
         return pkg
 
     def interpret(self, subdir: str, project_root: T.Optional[str] = None) -> mparser.CodeBlockNode:

mesonbuild/modules/rust.py

@@ -18,7 +18,7 @@
     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, noKwargs, noPosargs, permittedKwargs
+from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, typed_kwargs, typed_pos_args, noPosargs, permittedKwargs
 from ..interpreter.interpreterobjects import Doctest
 from ..mesonlib import File, MesonException, PerMachine
 from ..programs import ExternalProgram, NonExistingExternalProgram
@@ -495,13 +495,34 @@ def proc_macro(self, state: ModuleState, args: T.Tuple[str, SourcesVarargsType],
         return target
 
     @noPosargs
-    @noKwargs
+    @typed_kwargs(
+        'rust.workspace',
+        KwargInfo('default_features', (bool, NoneType), default=None),
+        KwargInfo(
+            'features',
+            (ContainerTypeInfo(list, str), NoneType),
+            default=None,
+            listify=True,
+        ),
+    )
     def workspace(self, state: ModuleState, args: T.List, kwargs: T.Dict[str, T.Any]) -> 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)")
 
+        default_features = kwargs['default_features']
+        features = kwargs['features']
+        if default_features is not None or features is not None:
+            # If custom features are provided, default_features = None should be treated as True
+            if default_features is None:
+                default_features = True
+
+            cargo_features = ['default'] if default_features else []
+            if features is not None:
+                cargo_features.extend(features)
+            self.interpreter.cargo.features = cargo_features
+
         # Check if we already have a cached workspace for this cargo interpreter
         ws_obj = self._workspace_cache.get(self.interpreter.cargo)
         if ws_obj is None: