interpreter: Add support for cargo subproject

docs/markdown/Wrap-dependency-system-manual.md

@@ -91,6 +91,7 @@ previously reserved to `wrap-file`:
   Supported methods:
   - `meson` requires `meson.build` file.
   - `cmake` requires `CMakeLists.txt` file. [See details](#cmake-wraps).
+  - `cargo` requires `Cargo.toml` file. [See details](#cargo-wraps).
 
 ### Specific to wrap-file
 - `source_url` - download url to retrieve the wrap-file source archive
@@ -307,6 +308,26 @@ method = cmake
 [provide]
 foo-bar-1.0 = foo_bar_dep
 ```
+### Cargo wraps
+
+Cargo subprojects automatically override the `<package_name>-rs` dependency name.
+`package_name` is defined in `[package] name = ...` section of the `Cargo.toml`
+and `-rs` suffix is added. That means the `.wrap` file should have
+`dependency_names = foo-rs` in their `[provide]` section when `Cargo.toml` has
+package name `foo`.
+
+Cargo subprojects require a toml parser. Python >= 3.11 have one built-in, older
+Python versions require either the external `tomli` module or `toml2json` program.
+
+For example, a Cargo project with the package name `foo-bar` would have a wrap
+file like that:
+```ini
+[wrap-file]
+...
+method = cargo
+[provide]
+dependency_names = foo-bar-rs
+```
 
 ## Using wrapped projects
 

docs/markdown/snippets/wrap.md

@@ -1,4 +1,4 @@
-## Automatic fallback to `cmake` subproject
+## Automatic fallback to `cmake` and `cargo` subproject
 
 CMake subprojects have been supported for a while using the `cmake.subproject()`
 module method. However until now it was not possible to use a CMake subproject
@@ -10,3 +10,4 @@ key in the wrap file's first section. The method defaults to `meson`.
 Supported methods:
 - `meson` requires `meson.build` file.
 - `cmake` requires `CMakeLists.txt` file. [See details](Wrap-dependency-system-manual.md#cmake-wraps).
+- `cargo` requires `Cargo.toml` file. [See details](Wrap-dependency-system-manual.md#cargo-wraps).

mesonbuild/cargo/__init__.py

@@ -0,0 +1,5 @@
+__all__ = [
+    'interpret'
+]
+
+from .interpreter import interpret

mesonbuild/cargo/interpreter.py

@@ -454,7 +454,13 @@ def _create_lib(cargo: Manifest, build: builder.Builder, crate_type: manifest.CR
     ]
 
 
-def interpret(cargo: Manifest, env: Environment) -> mparser.CodeBlockNode:
+def interpret(subp_name: str, subdir: str, env: Environment) -> mparser.CodeBlockNode:
+    package_name = subp_name[:-3] if subp_name.endswith('-rs') else subp_name
+    manifests = _load_manifests(os.path.join(env.source_dir, subdir))
+    cargo = manifests.get(package_name)
+    if not cargo:
+        raise MesonException(f'Cargo package {package_name!r} not found in {subdir}')
+
     filename = os.path.join(cargo.subdir, cargo.path, 'Cargo.toml')
     build = builder.Builder(filename)
 

mesonbuild/interpreter/interpreter.py

@@ -38,6 +38,7 @@
 from ..modules import ExtensionModule, ModuleObject, MutableModuleObject, NewExtensionModule, NotFoundExtensionModule
 from ..cmake import CMakeInterpreter
 from ..backend.backends import ExecutableSerialisation
+from .. import cargo
 
 from . import interpreterobjects as OBJ
 from . import compiler as compilerOBJ
@@ -935,13 +936,14 @@ def do_subproject(self, subp_name: str, kwargs: kwtypes.DoSubproject, force_meth
             m += ['method', mlog.bold(method)]
         mlog.log(*m, '\n', nested=False)
 
+        methods_map: T.Dict[wrap.Method, T.Callable[[str, str, T.Dict[OptionKey, str, kwtypes.DoSubproject]], SubprojectHolder]] = {
+            'meson': self._do_subproject_meson,
+            'cmake': self._do_subproject_cmake,
+            'cargo': self._do_subproject_cargo,
+        }
+
         try:
-            if method == 'meson':
-                return self._do_subproject_meson(subp_name, subdir, default_options, kwargs)
-            elif method == 'cmake':
-                return self._do_subproject_cmake(subp_name, subdir, default_options, kwargs)
-            else:
-                raise mesonlib.MesonBugException(f'The method {method} is invalid for the subproject {subp_name}')
+            return methods_map[method](subp_name, subdir, default_options, kwargs)
         # Invalid code is always an error
         except InvalidCode:
             raise
@@ -1042,6 +1044,16 @@ def _do_subproject_cmake(self, subp_name: str, subdir: str,
             result.cm_interpreter = cm_int
         return result
 
+    def _do_subproject_cargo(self, subp_name: str, subdir: str,
+                             default_options: T.Dict[OptionKey, str],
+                             kwargs: kwtypes.DoSubproject) -> SubprojectHolder:
+        with mlog.nested(subp_name):
+            ast = cargo.interpret(subp_name, subdir, self.environment)
+            return self._do_subproject_meson(
+                subp_name, subdir, default_options, kwargs, ast,
+                # FIXME: Are there other files used by cargo interpreter?
+                [os.path.join(subdir, 'Cargo.toml')])
+
     def get_option_internal(self, optname: str) -> coredata.UserOption:
         key = OptionKey.from_string(optname).evolve(subproject=self.subproject)
 

mesonbuild/wrap/wrap.py

@@ -45,7 +45,7 @@
 
 if T.TYPE_CHECKING:
     import http.client
-    Method = T.Literal['meson', 'cmake']
+    Method = T.Literal['meson', 'cmake', 'cargo']
 
 try:
     # Importing is just done to check if SSL exists, so all warnings
@@ -448,6 +448,7 @@ def resolve(self, packagename: str, force_method: T.Optional[Method] = None) ->
         methods_map: T.Dict[Method, str] = {
             'meson': 'meson.build',
             'cmake': 'CMakeLists.txt',
+            'cargo': 'Cargo.toml',
         }
 
         # Check if this wrap forces a specific method, use meson otherwise.

test cases/cmake/26 dependency fallback/meson.build

@@ -9,7 +9,7 @@ test('test1', exe1)
 # to meson but wrap force cmake.
 subproject('force_cmake')
 
-testcase expect_error('Wrap method \'notfound\' is not supported, must be one of: meson, cmake')
+testcase expect_error('Wrap method \'notfound\' is not supported, must be one of: meson, cmake, cargo')
   subproject('broken_method')
 endtestcase
 

test cases/rust/21 cargo subproject/main.c

@@ -0,0 +1,5 @@
+int rust_func(void);
+
+int main(int argc, char *argv[]) {
+    return rust_func();
+}

test cases/rust/21 cargo subproject/meson.build

@@ -0,0 +1,7 @@
+project('cargo subproject', 'c')
+
+foo_dep = dependency('foo-rs')
+exe = executable('foo', 'main.c',
+  dependencies: foo_dep,
+)
+test('cargo-test', exe)

test cases/rust/21 cargo subproject/subprojects/bar-rs.wrap

@@ -0,0 +1,2 @@
+[wrap-file]
+method = cargo

test cases/rust/21 cargo subproject/subprojects/bar-rs/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "bar"
+version = "0.1"

test cases/rust/21 cargo subproject/subprojects/bar-rs/src/lib.rs

@@ -0,0 +1 @@
+pub const VALUE: i32 = 0;

test cases/rust/21 cargo subproject/subprojects/foo-rs.wrap

@@ -0,0 +1,2 @@
+[wrap-file]
+method = cargo

test cases/rust/21 cargo subproject/subprojects/foo-rs/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "foo"
+version = "0.0.1"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+mybar = { version = "0.1", package = "bar" }

test cases/rust/21 cargo subproject/subprojects/foo-rs/src/lib.rs

@@ -0,0 +1,4 @@
+#[no_mangle]
+pub extern "C" fn rust_func() -> i32 {
+    mybar::VALUE
+}