Allow specifying method in dependency() and subproject()

If the Cargo subproject is part of the main repo we had to write a dummy
wrap file to specify the method:
```
[wrap-file]
method=cargo
```

We can now instead directly call `subproject('rust', method: 'cargo')`
with no wrap file. This also allows the method to be a user
option: `method: get_option('cargo') ? 'cargo' : 'meson'`.

Author: xclaesse

docs/yaml/functions/dependency.yaml

@@ -123,6 +123,15 @@ kwargs:
       If the value is an empty array it has the same effect as
       `allow_fallback: false`.
 
+  fallback_method:
+    type: str
+    since: 1.10.0
+    description: |
+      Specifies which method should be used to configure the fallback if the
+      dependency is not found in the system. Supported values are `meson`,
+      `cmake` and `cargo`. It defaults to the `method` field in the wrap file
+      if any, otherwise it defaults to `meson`.
+
   language:
     type: str
     since: 0.42.0

docs/yaml/functions/subproject.yaml

@@ -65,3 +65,11 @@ kwargs:
     default: true
     description: |
       Works just the same as in [[dependency]].
+
+  method:
+    type: str
+    since: 1.10.0
+    description: |
+      Specifies which method should be used to configure the subproject.
+      Supported values are `meson`, `cmake` and `cargo`. It defaults to the
+      `method` field in the wrap file if any, otherwise it defaults to `meson`.

mesonbuild/dependencies/detect.py

@@ -45,20 +45,21 @@ def get_dep_identifier(name: str, kwargs: T.Dict[str, T.Any]) -> 'TV_DepID':
     nkwargs.update(kwargs)
 
     from ..interpreter import permitted_dependency_kwargs
-    assert len(permitted_dependency_kwargs) == 19, \
+    assert len(permitted_dependency_kwargs) == 20, \
            'Extra kwargs have been added to dependency(), please review if it makes sense to handle it here'
     for key, value in nkwargs.items():
         # 'version' is irrelevant for caching; the caller must check version matches
         # 'native' is handled above with `for_machine`
         # 'required' is irrelevant for caching; the caller handles it separately
-        # 'fallback' and 'allow_fallback' is not part of the cache because,
-        #     once a dependency has been found through a fallback, it should
-        #     be used for the rest of the Meson run.
+        # 'fallback', 'allow_fallback' and 'fallback_method' are not part of the
+        #     cache because, once a dependency has been found through a fallback,
+        #     it should be used for the rest of the Meson run.
         # 'default_options' is only used in fallback case
         # 'not_found_message' has no impact on the dependency lookup
         # 'include_type' is handled after the dependency lookup
-        if key in {'version', 'native', 'required', 'fallback', 'allow_fallback', 'default_options',
-                   'not_found_message', 'include_type'}:
+        if key in {'version', 'native', 'required', 'fallback', 'allow_fallback',
+                   'fallback_method', 'default_options', 'not_found_message',
+                   'include_type'}:
             continue
         # All keyword arguments are strings, ints, or lists (or lists of lists)
         if isinstance(value, list):

mesonbuild/interpreter/dependencyfallbacks.py

@@ -20,14 +20,16 @@
     from .interpreter import Interpreter
     from ..interpreterbase import TYPE_nkwargs, TYPE_nvar
     from .interpreterobjects import SubprojectHolder
+    from ..wrap.wrap import Method
 
 
 class DependencyFallbacksHolder(MesonInterpreterObject):
     def __init__(self,
                  interpreter: 'Interpreter',
                  names: T.List[str],
                  allow_fallback: T.Optional[bool] = None,
-                 default_options: T.Optional[T.Dict[str, str]] = None) -> None:
+                 default_options: T.Optional[T.Dict[str, str]] = None,
+                 fallback_method: Method = 'meson') -> None:
         super().__init__(subproject=interpreter.subproject)
         self.interpreter = interpreter
         self.subproject = interpreter.subproject
@@ -42,6 +44,7 @@ def __init__(self,
         self.names: T.List[str] = []
         self.forcefallback: bool = False
         self.nofallback: bool = False
+        self.fallback_method = fallback_method
         for name in names:
             if not name:
                 raise InterpreterException('dependency_fallbacks empty name \'\' is not allowed')
@@ -132,7 +135,7 @@ def _do_subproject(self, kwargs: TYPE_nkwargs, func_args: TYPE_nvar, func_kwargs
         subp_name = self.subproject_name
         varname = self.subproject_varname
         func_kwargs.setdefault('version', [])
-        self.interpreter.do_subproject(subp_name, func_kwargs, forced_options=forced_options)
+        self.interpreter.do_subproject(subp_name, func_kwargs, forced_options=forced_options, force_method=self.fallback_method)
         return self._get_subproject_dep(subp_name, varname, kwargs)
 
     def _get_subproject(self, subp_name: str) -> T.Optional[SubprojectHolder]:

mesonbuild/interpreter/interpreter.py

@@ -16,6 +16,7 @@
 from .. import compilers
 from .. import envconfig
 from ..wrap import wrap, WrapMode
+from ..wrap.wrap import METHODS
 from .. import mesonlib
 from ..mesonlib import (EnvironmentVariables, ExecutableSerialisation, MesonBugException, MesonException, HoldableObject,
                         FileMode, MachineChoice, is_parent_path, listify,
@@ -91,6 +92,7 @@
     STATIC_LIB_KWS,
     VARIABLES_KW,
     TEST_KWS,
+    FALLBACK_METHOD_KW,
     NoneType,
     in_set_validator,
     env_convertor_with_method
@@ -245,6 +247,7 @@ class InterpreterRuleRelaxation(Enum):
     'components',
     'default_options',
     'fallback',
+    'fallback_method',
     'include_type',
     'language',
     'main',
@@ -867,6 +870,7 @@ def func_option(self, nodes, args, kwargs):
         REQUIRED_KW,
         DEFAULT_OPTIONS.evolve(since='0.38.0'),
         KwargInfo('version', ContainerTypeInfo(list, str), default=[], listify=True),
+        FALLBACK_METHOD_KW.evolve(name='method'),
     )
     def func_subproject(self, nodes: mparser.BaseNode, args: T.Tuple[str], kwargs: kwtypes.Subproject) -> SubprojectHolder:
         kw: kwtypes.DoSubproject = {
@@ -876,7 +880,7 @@ def func_subproject(self, nodes: mparser.BaseNode, args: T.Tuple[str], kwargs: k
             'options': None,
             'cmake_options': [],
         }
-        return self.do_subproject(args[0], kw)
+        return self.do_subproject(args[0], kw, force_method=kwargs['method'])
 
     def disabled_subproject(self, subp_name: str, disabled_feature: T.Optional[str] = None,
                             exception: T.Optional[Exception] = None) -> SubprojectHolder:
@@ -1809,7 +1813,8 @@ def func_dependency(self, node: mparser.BaseNode, args: T.Tuple[T.List[str]], kw
             raise InvalidArguments('"allow_fallback" argument must be boolean')
         fallback = kwargs.get('fallback')
         default_options = kwargs.get('default_options')
-        df = DependencyFallbacksHolder(self, names, allow_fallback, default_options)
+        fallback_method = kwargs.get('fallback_method')
+        df = DependencyFallbacksHolder(self, names, allow_fallback, default_options, fallback_method)
         df.set_fallback(fallback)
         not_found_message = kwargs.get('not_found_message', '')
         if not isinstance(not_found_message, str):

mesonbuild/interpreter/kwargs.py

@@ -17,6 +17,7 @@
 from ..options import OptionKey
 from ..modules.cmake import CMakeSubprojectOptions
 from ..programs import ExternalProgram
+from ..wrap.wrap import Method as WrapMethod
 from .type_checking import PkgConfigDefineType, SourcesVarargsType
 
 TestArgs = T.Union[str, File, build.Target, ExternalProgram]
@@ -315,6 +316,7 @@ class Subproject(ExtractRequired):
 
     default_options: T.Dict[OptionKey, options.ElementaryOptionValues]
     version: T.List[str]
+    method: T.Optional[WrapMethod]
 
 
 class DoSubproject(ExtractRequired):
@@ -491,3 +493,4 @@ class FuncDeclareDependency(TypedDict):
 class FuncDependency(TypedDict):
 
     default_options: T.Dict[OptionKey, options.ElementaryOptionValues]
+    fallback_method: T.Optional[WrapMethod]

mesonbuild/interpreter/type_checking.py

@@ -17,6 +17,7 @@
 from ..mesonlib import (File, FileMode, MachineChoice, has_path_sep, listify, stringlistify,
                         EnvironmentVariables)
 from ..programs import ExternalProgram
+from ..wrap.wrap import METHODS
 
 # Helper definition for type checks that are `Optional[T]`
 NoneType: T.Type[None] = type(None)
@@ -892,7 +893,15 @@ def _pkgconfig_define_convertor(x: T.List[str]) -> PkgConfigDefineType:
     convertor=_pkgconfig_define_convertor,
 )
 
+FALLBACK_METHOD_KW: KwargInfo = KwargInfo(
+    'fallback_method',
+    (str, NoneType),
+    default=None,
+    validator=in_set_validator(METHODS),
+    since='1.10.0')
+
 
 DEPENDENCY_KWS: T.List[KwargInfo] = [
     DEFAULT_OPTIONS.evolve(since='0.38.0'),
+    FALLBACK_METHOD_KW,
 ]

mesonbuild/wrap/wrap.py

@@ -56,6 +56,7 @@
 WHITELIST_SUBDOMAIN = 'wrapdb.mesonbuild.com'
 
 ALL_TYPES = ['file', 'git', 'hg', 'svn', 'redirect']
+METHODS = {'meson', 'cmake', 'cargo'}
 
 if mesonlib.is_windows():
     from ..programs import ExternalProgram

test cases/rust/31 cargo fallback method/meson.build

@@ -0,0 +1,4 @@
+project('cargo fallback method')
+
+subproject('rust', method : 'cargo')
+dependency('foo-0-rs', fallback_method : 'cargo')

test cases/rust/31 cargo fallback method/subprojects/rust/Cargo.toml

@@ -0,0 +1,2 @@
+[package]
+name = "empty"