modules: rust: add package.shared_module method

Author: bonzini

docs/markdown/Rust-module.md

@@ -394,6 +394,16 @@ Accepts all keyword arguments from [[shared_library]] and [[static_library]].
 `rust_abi` must match the crate types and is mandatory if more than one
 ABI is exposed by the crate.
 
+#### package.shared_module()
+
+```meson
+lib = pkg.shared_module(...)
+```
+
+Builds the `cdylib` for a workspace package as a shared module.
+
+Accepts all keyword arguments from [[shared_module]].
+
 #### package.proc_macro()
 
 ```meson

mesonbuild/modules/rust.py

@@ -13,14 +13,15 @@
 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)
+                     CustomTarget, InvalidArguments, Jar, StructuredSources, SharedLibrary, StaticLibrary,
+                     SharedModule)
 from ..compilers.compilers import are_asserts_disabled_for_subproject, lang_suffixes
 from ..compilers.rust import RustSystemDependency
 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,
-    EXECUTABLE_KWS, LIBRARY_KWS, _BASE_LANG_KW
+    EXECUTABLE_KWS, LIBRARY_KWS, SHARED_MOD_KWS, _BASE_LANG_KW
 )
 from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, typed_kwargs, typed_pos_args, noKwargs, noPosargs, permittedKwargs
 from ..interpreter.interpreterobjects import Doctest
@@ -247,6 +248,7 @@ def __init__(self, rust_ws: RustWorkspace, package: cargo.PackageState) -> None:
             'dependencies': self.dependencies_method,
             'library': self.library_method,
             'proc_macro': self.proc_macro_method,
+            'shared_module': self.shared_module_method,
             'executable': self.executable_method,
         })
 
@@ -313,7 +315,8 @@ def merge_kw_args(self, state: ModuleState, kwargs: T.Union[RustPackageExecutabl
     def _library_method(self, state: ModuleState, args: T.Tuple[
             T.Optional[T.Union[str, StructuredSources]],
             T.Optional[StructuredSources]], kwargs: RustPackageLibrary,
-            static: bool, shared: bool) -> T.Union[BothLibraries, SharedLibrary, StaticLibrary]:
+            static: bool, shared: bool,
+            shared_mod: bool = False) -> T.Union[BothLibraries, SharedLibrary, StaticLibrary]:
         tgt_args = self.validate_pos_args('package.library', args)
         if not self.package.manifest.lib:
             raise MesonException("no [lib] section in Cargo package")
@@ -333,6 +336,11 @@ def _library_method(self, state: ModuleState, args: T.Tuple[
         lib_args: T.Tuple[str, SourcesVarargsType] = (tgt_name, [sources])
         self.merge_kw_args(state, kwargs)
 
+        if shared_mod:
+            return state._interpreter.build_target(state.current_node, lib_args,
+                                                   T.cast('_kwargs.SharedModule', kwargs),
+                                                   SharedModule)
+
         if static and shared:
             return state._interpreter.build_both_libraries(state.current_node, lib_args, kwargs)
         elif shared:
@@ -400,6 +408,28 @@ def proc_macro_method(self, state: 'ModuleState', args: T.Tuple[
             raise MesonException("not a procedural macro crate")
         return self._proc_macro_method(state, args, kwargs)
 
+    @typed_pos_args('package.shared_module', optargs=[(str, StructuredSources), StructuredSources])
+    @typed_kwargs(
+        'package.shared_module',
+        *SHARED_MOD_KWS,
+        DEPENDENCIES_KW,
+        LINK_WITH_KW,
+        LINK_WHOLE_KW,
+        _BASE_LANG_KW.evolve(name='rust_args'),
+    )
+    def shared_module_method(self, state: 'ModuleState', args: T.Tuple[
+            T.Optional[T.Union[str, StructuredSources]],
+            T.Optional[StructuredSources]], kwargs: RustPackageLibrary) -> SharedModule:
+        if not self.package.manifest.lib:
+            raise MesonException("no [lib] section in Cargo package")
+        if 'cdylib' not in self.package.manifest.lib.crate_type:
+            raise MesonException("not a cdylib crate")
+
+        kwargs['rust_abi'] = None
+        kwargs['rust_crate_type'] = 'cdylib'
+        result = self._library_method(state, args, kwargs, shared=True, static=False, shared_mod=True)
+        return T.cast('SharedModule', result)
+
     @typed_pos_args('package.executable', optargs=[(str, StructuredSources), StructuredSources])
     @typed_kwargs(
         'package.executable',