modules: Stop using ModuleReturnValue where it's not needed

It is only needed in functions that need to add targets to the
interpreter.

mesonbuild/modules/cmake.py

@@ -390,9 +390,8 @@ class CmakeModule(ExtensionModule):
     @FeatureNew('subproject_options', '0.55.0')
     @noKwargs
     @noPosargs
-    def subproject_options(self, state, args, kwargs) -> ModuleReturnValue:
-        opts = CMakeSubprojectOptions()
-        return ModuleReturnValue(opts, [])
+    def subproject_options(self, state, args, kwargs) -> CMakeSubprojectOptions:
+        return CMakeSubprojectOptions()
 
 def initialize(*args, **kwargs):
     return CmakeModule(*args, **kwargs)

mesonbuild/modules/fs.py

@@ -19,7 +19,6 @@ from pathlib import Path, PurePath, PureWindowsPath
 
 from .. import mlog
 from . import ExtensionModule
-from . import ModuleReturnValue
 from ..mesonlib import (
     File,
     FileOrString,
@@ -60,62 +59,55 @@ class FSModule(ExtensionModule):
             pass
         return path
 
-    def _check(self, check: str, state: 'ModuleState', args: T.Sequence['FileOrString']) -> ModuleReturnValue:
-        test_file = self._resolve_dir(state, args[0])
-        val = getattr(test_file, check)()
-        if isinstance(val, Path):
-            val = str(val)
-        return ModuleReturnValue(val, [])
-
     @noKwargs
     @FeatureNew('fs.expanduser', '0.54.0')
     @typed_pos_args('fs.expanduser', str)
-    def expanduser(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
-        return ModuleReturnValue(str(Path(args[0]).expanduser()), [])
+    def expanduser(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> str:
+        return str(Path(args[0]).expanduser())
 
     @noKwargs
     @FeatureNew('fs.is_absolute', '0.54.0')
     @typed_pos_args('fs.is_absolute', (str, File))
-    def is_absolute(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def is_absolute(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> bool:
         if isinstance(args[0], File):
             FeatureNew('fs.is_absolute_file', '0.59.0').use(state.subproject)
-        return ModuleReturnValue(PurePath(str(args[0])).is_absolute(), [])
+        return PurePath(str(args[0])).is_absolute()
 
     @noKwargs
     @FeatureNew('fs.as_posix', '0.54.0')
     @typed_pos_args('fs.as_posix', str)
-    def as_posix(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def as_posix(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> str:
         """
         this function assumes you are passing a Windows path, even if on a Unix-like system
         and so ALL '\' are turned to '/', even if you meant to escape a character
         """
-        return ModuleReturnValue(PureWindowsPath(args[0]).as_posix(), [])
+        return PureWindowsPath(args[0]).as_posix()
 
     @noKwargs
     @typed_pos_args('fs.exists', str)
-    def exists(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
-        return self._check('exists', state, args)
+    def exists(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> bool:
+        return self._resolve_dir(state, args[0]).exists()
 
     @noKwargs
     @typed_pos_args('fs.is_symlink', (str, File))
-    def is_symlink(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def is_symlink(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> bool:
         if isinstance(args[0], File):
             FeatureNew('fs.is_symlink_file', '0.59.0').use(state.subproject)
-        return ModuleReturnValue(self._absolute_dir(state, args[0]).is_symlink(), [])
+        return self._absolute_dir(state, args[0]).is_symlink()
 
     @noKwargs
     @typed_pos_args('fs.is_file', str)
-    def is_file(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
-        return self._check('is_file', state, args)
+    def is_file(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> bool:
+        return self._resolve_dir(state, args[0]).is_file()
 
     @noKwargs
     @typed_pos_args('fs.is_dir', str)
-    def is_dir(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
-        return self._check('is_dir', state, args)
+    def is_dir(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> bool:
+        return self._resolve_dir(state, args[0]).is_dir()
 
     @noKwargs
     @typed_pos_args('fs.hash', (str, File), str)
-    def hash(self, state: 'ModuleState', args: T.Tuple['FileOrString', str], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def hash(self, state: 'ModuleState', args: T.Tuple['FileOrString', str], kwargs: T.Dict[str, T.Any]) -> str:
         if isinstance(args[0], File):
             FeatureNew('fs.hash_file', '0.59.0').use(state.subproject)
         file = self._resolve_dir(state, args[0])
@@ -127,78 +119,78 @@ class FSModule(ExtensionModule):
             raise MesonException('hash algorithm {} is not available'.format(args[1]))
         mlog.debug('computing {} sum of {} size {} bytes'.format(args[1], file, file.stat().st_size))
         h.update(file.read_bytes())
-        return ModuleReturnValue(h.hexdigest(), [])
+        return h.hexdigest()
 
     @noKwargs
     @typed_pos_args('fs.size', (str, File))
-    def size(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def size(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> int:
         if isinstance(args[0], File):
             FeatureNew('fs.size_file', '0.59.0').use(state.subproject)
         file = self._resolve_dir(state, args[0])
         if not file.is_file():
             raise MesonException(f'{file} is not a file and therefore cannot be sized')
         try:
-            return ModuleReturnValue(file.stat().st_size, [])
+            return file.stat().st_size
         except ValueError:
             raise MesonException('{} size could not be determined'.format(args[0]))
 
     @noKwargs
     @typed_pos_args('fs.is_samepath', (str, File), (str, File))
-    def is_samepath(self, state: 'ModuleState', args: T.Tuple['FileOrString', 'FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def is_samepath(self, state: 'ModuleState', args: T.Tuple['FileOrString', 'FileOrString'], kwargs: T.Dict[str, T.Any]) -> bool:
         if isinstance(args[0], File) or isinstance(args[1], File):
             FeatureNew('fs.is_samepath_file', '0.59.0').use(state.subproject)
         file1 = self._resolve_dir(state, args[0])
         file2 = self._resolve_dir(state, args[1])
         if not file1.exists():
-            return ModuleReturnValue(False, [])
+            return False
         if not file2.exists():
-            return ModuleReturnValue(False, [])
+            return False
         try:
-            return ModuleReturnValue(file1.samefile(file2), [])
+            return file1.samefile(file2)
         except OSError:
-            return ModuleReturnValue(False, [])
+            return False
 
     @noKwargs
     @typed_pos_args('fs.replace_suffix', (str, File), str)
-    def replace_suffix(self, state: 'ModuleState', args: T.Tuple['FileOrString', str], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def replace_suffix(self, state: 'ModuleState', args: T.Tuple['FileOrString', str], kwargs: T.Dict[str, T.Any]) -> str:
         if isinstance(args[0], File):
             FeatureNew('fs.replace_suffix_file', '0.59.0').use(state.subproject)
         original = PurePath(str(args[0]))
         new = original.with_suffix(args[1])
-        return ModuleReturnValue(str(new), [])
+        return str(new)
 
     @noKwargs
     @typed_pos_args('fs.parent', (str, File))
-    def parent(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def parent(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> str:
         if isinstance(args[0], File):
             FeatureNew('fs.parent_file', '0.59.0').use(state.subproject)
         original = PurePath(str(args[0]))
         new = original.parent
-        return ModuleReturnValue(str(new), [])
+        return str(new)
 
     @noKwargs
     @typed_pos_args('fs.name', (str, File))
-    def name(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def name(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> str:
         if isinstance(args[0], File):
             FeatureNew('fs.name_file', '0.59.0').use(state.subproject)
         original = PurePath(str(args[0]))
         new = original.name
-        return ModuleReturnValue(str(new), [])
+        return str(new)
 
     @noKwargs
     @typed_pos_args('fs.stem', (str, File))
     @FeatureNew('fs.stem', '0.54.0')
-    def stem(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def stem(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> str:
         if isinstance(args[0], File):
             FeatureNew('fs.stem_file', '0.59.0').use(state.subproject)
         original = PurePath(str(args[0]))
         new = original.stem
-        return ModuleReturnValue(str(new), [])
+        return str(new)
 
     @FeatureNew('fs.read', '0.57.0')
     @permittedKwargs({'encoding'})
     @typed_pos_args('fs.read', (str, File))
-    def read(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> ModuleReturnValue:
+    def read(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> str:
         """Read a file from the source tree and return its value as a decoded
         string.
 
@@ -238,7 +230,7 @@ class FSModule(ExtensionModule):
         # part of the build configuration (e.g. `project(..., version:
         # fs.read_file('VERSION')` or `configure_file(...)`
         self.interpreter.add_build_def_file(path)
-        return ModuleReturnValue(data, [])
+        return data
 
 
 def initialize(*args: T.Any, **kwargs: T.Any) -> FSModule:

mesonbuild/modules/gnome.py

@@ -1162,7 +1162,7 @@ class GnomeModule(ExtensionModule):
         modulename = args[0]
         if not isinstance(modulename, str):
             raise MesonException('Argument must be a string')
-        return ModuleReturnValue(os.path.join('share/gtk-doc/html', modulename), [])
+        return os.path.join('share/gtk-doc/html', modulename)
 
     @staticmethod
     def _unpack_args(arg, kwarg_name, kwargs, expend_file_state=None):

mesonbuild/modules/hotdoc.py

@@ -408,8 +408,7 @@ class HotDocModule(ExtensionModule):
 
     @noKwargs
     def has_extensions(self, state, args, kwargs):
-        res = self.hotdoc.run_hotdoc(['--has-extension=%s' % extension for extension in args]) == 0
-        return ModuleReturnValue(res, [res])
+        return self.hotdoc.run_hotdoc(['--has-extension=%s' % extension for extension in args]) == 0
 
     def generate_doc(self, state, args, kwargs):
         if len(args) != 1:

mesonbuild/modules/i18n.py

@@ -61,7 +61,6 @@ class I18nModule(ExtensionModule):
     @staticmethod
     def nogettext_warning():
         mlog.warning('Gettext not found, all translation targets will be ignored.', once=True)
-        return ModuleReturnValue(None, [])
 
     @staticmethod
     def _get_data_dirs(state, dirs):
@@ -74,7 +73,8 @@ class I18nModule(ExtensionModule):
     @permittedKwargs(build.CustomTarget.known_kwargs | {'data_dirs', 'po_dir', 'type', 'args'})
     def merge_file(self, state, args, kwargs):
         if not shutil.which('xgettext'):
-            return self.nogettext_warning()
+            self.nogettext_warning()
+            return
         podir = kwargs.pop('po_dir', None)
         if not podir:
             raise MesonException('i18n: po_dir is a required kwarg')
@@ -128,7 +128,8 @@ class I18nModule(ExtensionModule):
         if len(args) != 1:
             raise coredata.MesonException('Gettext requires one positional argument (package name).')
         if not shutil.which('xgettext'):
-            return self.nogettext_warning()
+            self.nogettext_warning()
+            return
         packagename = args[0]
         languages = mesonlib.stringlistify(kwargs.get('languages', []))
         datadirs = self._get_data_dirs(state, mesonlib.stringlistify(kwargs.get('data_dirs', [])))

mesonbuild/modules/modtest.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import ModuleReturnValue
 from . import ExtensionModule
 from ..interpreterbase import noKwargs
 
@@ -21,8 +20,6 @@ class TestModule(ExtensionModule):
     @noKwargs
     def print_hello(self, state, args, kwargs):
         print('Hello from a Meson module')
-        rv = ModuleReturnValue(None, [])
-        return rv
 
 def initialize(*args, **kwargs):
     return TestModule(*args, **kwargs)

mesonbuild/modules/python3.py

@@ -16,7 +16,6 @@ import sysconfig
 from .. import mesonlib
 
 from . import ExtensionModule
-from mesonbuild.modules import ModuleReturnValue
 from ..interpreterbase import noKwargs, permittedKwargs, FeatureDeprecated
 from ..build import known_shmod_kwargs
 from ..programs import ExternalProgram
@@ -53,11 +52,11 @@ class Python3Module(ExtensionModule):
             py3 = ExternalProgram.from_entry('python3', command)
         else:
             py3 = ExternalProgram('python3', mesonlib.python_command, silent=True)
-        return ModuleReturnValue(py3, [py3])
+        return py3
 
     @noKwargs
     def language_version(self, state, args, kwargs):
-        return ModuleReturnValue(sysconfig.get_python_version(), [])
+        return sysconfig.get_python_version()
 
     @noKwargs
     def sysconfig_path(self, state, args, kwargs):
@@ -69,8 +68,7 @@ class Python3Module(ExtensionModule):
             raise mesonlib.MesonException(f'{path_name} is not a valid path name {valid_names}.')
 
         # Get a relative path without a prefix, e.g. lib/python3.6/site-packages
-        path = sysconfig.get_path(path_name, vars={'base': '', 'platbase': '', 'installed_base': ''})[1:]
-        return ModuleReturnValue(path, [])
+        return sysconfig.get_path(path_name, vars={'base': '', 'platbase': '', 'installed_base': ''})[1:]
 
 
 def initialize(*args, **kwargs):

mesonbuild/modules/rpm.py

@@ -20,7 +20,6 @@ from .. import compilers
 import datetime
 from .. import mlog
 from . import GirTarget, TypelibTarget
-from . import ModuleReturnValue
 from . import ExtensionModule
 from ..interpreterbase import noKwargs
 
@@ -150,7 +149,6 @@ class RPMModule(ExtensionModule):
             fn.write('- \n')
             fn.write('\n')
         mlog.log('RPM spec template written to %s.spec.\n' % proj)
-        return ModuleReturnValue(None, [])
 
     def __get_required_compilers(self):
         required_compilers = set()

mesonbuild/modules/unstable_rust.py

@@ -130,7 +130,7 @@ class RustModule(ExtensionModule):
         test = self.interpreter.make_test(
             self.interpreter.current_node, [name, e], kwargs)
 
-        return ModuleReturnValue([], [e, test])
+        return ModuleReturnValue(None, [e, test])
 
     @noPosargs
     @permittedKwargs({'input', 'output', 'include_directories', 'c_args', 'args'})