minstall: Add --skip-subprojects option

By default all subprojects are installed. If --skip-subprojects is given
with no value only the main project is installed. If --skip-subprojects
is given with a value, it should be a coma separated list of subprojects
to skip and all others will be installed.

Fixes: #2550.

Author: xclaesse

docs/markdown/snippets/install_skip_subprojects.md

@@ -0,0 +1,10 @@
+## Skip subprojects installation
+
+It is now possible to skip installation of some or all subprojects. This is
+useful when subprojects are internal dependencies static linked into the main
+project.
+
+By default all subprojects are still installed.
+- `meson install -C builddir --skip-subprojects` installs only the main project.
+- `meson install -C builddir --skip-subprojects foo,bar` installs the main project
+  and all subprojects except for subprojects `foo` and `bar` if they are used.

mesonbuild/backend/backends.py

@@ -23,7 +23,6 @@
 import re
 import typing as T
 import hashlib
-import copy
 
 from .. import build
 from .. import dependencies
@@ -100,20 +99,18 @@ def __init__(self, source_dir: str, build_dir: str, prefix: str,
         self.strip_bin = strip_bin
         self.install_umask = install_umask
         self.targets: T.List[TargetInstallData] = []
-        self.headers: 'InstallType' = []
-        self.man: 'InstallType' = []
-        self.data: 'InstallType' = []
-        self.po_package_name: str = ''
-        self.po = []
+        self.headers: T.List[InstallDataBase] = []
+        self.man: T.List[InstallDataBase] = []
+        self.data: T.List[InstallDataBase] = []
         self.install_scripts: T.List[ExecutableSerialisation] = []
-        self.install_subdirs: 'InstallSubdirsType' = []
+        self.install_subdirs: T.List[SubdirInstallData] = []
         self.mesonintrospect = mesonintrospect
         self.version = version
 
 class TargetInstallData:
     def __init__(self, fname: str, outdir: str, aliases: T.Dict[str, str], strip: bool,
                  install_name_mappings: T.Dict, rpath_dirs_to_remove: T.Set[bytes],
-                 install_rpath: str, install_mode: 'FileMode', optional: bool = False):
+                 install_rpath: str, install_mode: 'FileMode', subproject: str, optional: bool = False):
         self.fname = fname
         self.outdir = outdir
         self.aliases = aliases
@@ -122,8 +119,21 @@ def __init__(self, fname: str, outdir: str, aliases: T.Dict[str, str], strip: bo
         self.rpath_dirs_to_remove = rpath_dirs_to_remove
         self.install_rpath = install_rpath
         self.install_mode = install_mode
+        self.subproject = subproject
         self.optional = optional
 
+class InstallDataBase:
+    def __init__(self, path: str, install_path: str, install_mode: 'FileMode', subproject: str):
+        self.path = path
+        self.install_path = install_path
+        self.install_mode = install_mode
+        self.subproject = subproject
+
+class SubdirInstallData(InstallDataBase):
+    def __init__(self, path: str, install_path: str, install_mode: 'FileMode', exclude, subproject: str):
+        super().__init__(path, install_path, install_mode, subproject)
+        self.exclude = exclude
+
 class ExecutableSerialisation:
     def __init__(self, cmd_args, env: T.Optional[build.EnvironmentVariables] = None, exe_wrapper=None,
                  workdir=None, extra_paths=None, capture=None) -> None:
@@ -138,6 +148,7 @@ def __init__(self, cmd_args, env: T.Optional[build.EnvironmentVariables] = None,
         self.pickled = False
         self.skip_if_destdir = False
         self.verbose = False
+        self.subproject = ''
 
 class TestSerialisation:
     def __init__(self, name: str, project: str, suite: str, fname: T.List[str],
@@ -972,7 +983,7 @@ def generate_depmf_install(self, d: InstallData) -> None:
         with open(ifilename, 'w') as f:
             f.write(json.dumps(mfobj))
         # Copy file from, to, and with mode unchanged
-        d.data.append((ifilename, ofilename, None))
+        d.data.append(InstallDataBase(ifilename, ofilename, None, ''))
 
     def get_regen_filelist(self):
         '''List of all files whose alteration means that the build
@@ -1297,7 +1308,7 @@ def generate_target_install(self, d: InstallData) -> None:
                     i = TargetInstallData(self.get_target_filename(t), outdirs[0],
                                           t.get_aliases(), should_strip, mappings,
                                           t.rpath_dirs_to_remove,
-                                          t.install_rpath, install_mode)
+                                          t.install_rpath, install_mode, t.subproject)
                     d.targets.append(i)
 
                     if isinstance(t, (build.SharedLibrary, build.SharedModule, build.Executable)):
@@ -1315,14 +1326,15 @@ def generate_target_install(self, d: InstallData) -> None:
                             # Install the import library; may not exist for shared modules
                             i = TargetInstallData(self.get_target_filename_for_linking(t),
                                                   implib_install_dir, {}, False, {}, set(), '', install_mode,
-                                                  optional=isinstance(t, build.SharedModule))
+                                                  t.subproject, optional=isinstance(t, build.SharedModule))
                             d.targets.append(i)
 
                         if not should_strip and t.get_debug_filename():
                             debug_file = os.path.join(self.get_target_dir(t), t.get_debug_filename())
                             i = TargetInstallData(debug_file, outdirs[0],
                                                   {}, False, {}, set(), '',
-                                                  install_mode, optional=True)
+                                                  install_mode, t.subproject,
+                                                  optional=True)
                             d.targets.append(i)
                 # Install secondary outputs. Only used for Vala right now.
                 if num_outdirs > 1:
@@ -1331,7 +1343,8 @@ def generate_target_install(self, d: InstallData) -> None:
                         if outdir is False:
                             continue
                         f = os.path.join(self.get_target_dir(t), output)
-                        i = TargetInstallData(f, outdir, {}, False, {}, set(), None, install_mode)
+                        i = TargetInstallData(f, outdir, {}, False, {}, set(), None,
+                                              install_mode, t.subproject)
                         d.targets.append(i)
             elif isinstance(t, build.CustomTarget):
                 # If only one install_dir is specified, assume that all
@@ -1345,7 +1358,7 @@ def generate_target_install(self, d: InstallData) -> None:
                     for output in t.get_outputs():
                         f = os.path.join(self.get_target_dir(t), output)
                         i = TargetInstallData(f, outdirs[0], {}, False, {}, set(), None, install_mode,
-                                              optional=not t.build_by_default)
+                                              t.subproject, optional=not t.build_by_default)
                         d.targets.append(i)
                 else:
                     for output, outdir in zip(t.get_outputs(), outdirs):
@@ -1354,23 +1367,11 @@ def generate_target_install(self, d: InstallData) -> None:
                             continue
                         f = os.path.join(self.get_target_dir(t), output)
                         i = TargetInstallData(f, outdir, {}, False, {}, set(), None, install_mode,
-                                              optional=not t.build_by_default)
+                                              t.subproject, optional=not t.build_by_default)
                         d.targets.append(i)
 
     def generate_custom_install_script(self, d: InstallData) -> None:
-        result: T.List[ExecutableSerialisation] = []
-        srcdir = self.environment.get_source_dir()
-        builddir = self.environment.get_build_dir()
-        for i in self.build.install_scripts:
-            fixed_args = []
-            for a in i.cmd_args:
-                a = a.replace('@SOURCE_ROOT@', srcdir)
-                a = a.replace('@BUILD_ROOT@', builddir)
-                fixed_args.append(a)
-            es = copy.copy(i)
-            es.cmd_args = fixed_args
-            result.append(es)
-        d.install_scripts = result
+        d.install_scripts = self.build.install_scripts
 
     def generate_header_install(self, d: InstallData) -> None:
         incroot = self.environment.get_includedir()
@@ -1387,7 +1388,7 @@ def generate_header_install(self, d: InstallData) -> None:
                     msg = 'Invalid header type {!r} can\'t be installed'
                     raise MesonException(msg.format(f))
                 abspath = f.absolute_path(srcdir, builddir)
-                i = (abspath, outdir, h.get_custom_install_mode())
+                i = InstallDataBase(abspath, outdir, h.get_custom_install_mode(), h.subproject)
                 d.headers.append(i)
 
     def generate_man_install(self, d: InstallData) -> None:
@@ -1401,7 +1402,7 @@ def generate_man_install(self, d: InstallData) -> None:
                     subdir = os.path.join(manroot, 'man' + num)
                 srcabs = f.absolute_path(self.environment.get_source_dir(), self.environment.get_build_dir())
                 dstabs = os.path.join(subdir, os.path.basename(f.fname))
-                i = (srcabs, dstabs, m.get_custom_install_mode())
+                i = InstallDataBase(srcabs, dstabs, m.get_custom_install_mode(), m.subproject)
                 d.man.append(i)
 
     def generate_data_install(self, d: InstallData):
@@ -1416,7 +1417,7 @@ def generate_data_install(self, d: InstallData):
             for src_file, dst_name in zip(de.sources, de.rename):
                 assert(isinstance(src_file, mesonlib.File))
                 dst_abs = os.path.join(subdir, dst_name)
-                i = (src_file.absolute_path(srcdir, builddir), dst_abs, de.install_mode)
+                i = InstallDataBase(src_file.absolute_path(srcdir, builddir), dst_abs, de.install_mode, de.subproject)
                 d.data.append(i)
 
     def generate_subdir_install(self, d: InstallData) -> None:
@@ -1432,8 +1433,8 @@ def generate_subdir_install(self, d: InstallData) -> None:
                                    sd.install_dir)
             if not sd.strip_directory:
                 dst_dir = os.path.join(dst_dir, os.path.basename(src_dir))
-            d.install_subdirs.append(
-                (src_dir, dst_dir, sd.install_mode, sd.exclude))
+            i = SubdirInstallData(src_dir, dst_dir, sd.install_mode, sd.exclude, sd.subproject)
+            d.install_subdirs.append(i)
 
     def get_introspection_data(self, target_id: str, target: build.Target) -> T.List[T.Dict[str, T.Union[bool, str, T.List[T.Union[str, T.Dict[str, T.Union[str, T.List[str], bool]]]]]]]:
         '''

mesonbuild/build.py

@@ -127,11 +127,13 @@ def __init__(self, dep, node, explicit=True):
 class Headers:
 
     def __init__(self, sources: T.List[File], install_subdir: T.Optional[str],
-                 install_dir: T.Optional[str], install_mode: T.Optional['FileMode']):
+                 install_dir: T.Optional[str], install_mode: T.Optional['FileMode'],
+                 subproject: str):
         self.sources = sources
         self.install_subdir = install_subdir
         self.custom_install_dir = install_dir
         self.custom_install_mode = install_mode
+        self.subproject = subproject
 
     # TODO: we really don't need any of these methods, but they're preserved to
     # keep APIs relying on them working.
@@ -155,10 +157,11 @@ def get_custom_install_mode(self) -> T.Optional['FileMode']:
 class Man:
 
     def __init__(self, sources: T.List[File], install_dir: T.Optional[str],
-                 install_mode: T.Optional['FileMode']):
+                 install_mode: T.Optional['FileMode'], subproject: str):
         self.sources = sources
         self.custom_install_dir = install_dir
         self.custom_install_mode = install_mode
+        self.subproject = subproject
 
     def get_custom_install_dir(self) -> T.Optional[str]:
         return self.custom_install_dir
@@ -175,14 +178,16 @@ class InstallDir:
     def __init__(self, src_subdir: str, inst_subdir: str, install_dir: str,
                  install_mode: T.Optional['FileMode'],
                  exclude: T.Tuple[T.Set[str], T.Set[str]],
-                 strip_directory: bool, from_source_dir: bool = True):
+                 strip_directory: bool, subproject: str,
+                 from_source_dir: bool = True):
         self.source_subdir = src_subdir
         self.installable_subdir = inst_subdir
         self.install_dir = install_dir
         self.install_mode = install_mode
         self.exclude = exclude
         self.strip_directory = strip_directory
         self.from_source_dir = from_source_dir
+        self.subproject = subproject
 
 
 class Build:
@@ -2616,14 +2621,16 @@ def keys(self) -> T.Iterator[str]:
 # during install.
 class Data:
     def __init__(self, sources: T.List[File], install_dir: str,
-                 install_mode: T.Optional['FileMode'] = None, rename: T.List[str] = None):
+                 install_mode: T.Optional['FileMode'], subproject: str,
+                 rename: T.List[str] = None):
         self.sources = sources
         self.install_dir = install_dir
         self.install_mode = install_mode
         if rename is None:
             self.rename = [os.path.basename(f.fname) for f in self.sources]
         else:
             self.rename = rename
+        self.subproject = subproject
 
 class TestSetup:
     def __init__(self, exe_wrapper: T.Optional[T.List[str]], gdb: bool,

mesonbuild/interpreter.py

@@ -1966,7 +1966,9 @@ def _find_source_script(self, prog: T.Union[str, mesonlib.File, ExecutableHolder
         else:
             m = 'Script or command {!r} not found or not executable'
             raise InterpreterException(m.format(prog))
-        return self.interpreter.backend.get_executable_serialisation([found] + args)
+        es = self.interpreter.backend.get_executable_serialisation([found] + args)
+        es.subproject = self.interpreter.subproject
+        return es
 
     def _process_script_args(
             self, name: str, args: T.List[T.Union[
@@ -2584,6 +2586,7 @@ def process_new_values(self, invalues):
             elif isinstance(v, build.GeneratedList):
                 pass
             elif isinstance(v, ExecutableSerialisation):
+                v.subproject = self.subproject
                 self.build.install_scripts.append(v)
             elif isinstance(v, build.Data):
                 self.build.data.append(v)
@@ -2593,8 +2596,9 @@ def process_new_values(self, invalues):
                 # FIXME: This is special cased and not ideal:
                 # The first source is our new VapiTarget, the rest are deps
                 self.process_new_values(v.sources[0])
-            elif isinstance(v, InstallDirHolder):
-                self.build.install_dirs.append(v.held_object)
+            elif isinstance(v, build.InstallDir):
+                self.build.install_dirs.append(v)
+                return InstallDirHolder(v)
             elif isinstance(v, Test):
                 self.build.tests.append(v)
             elif hasattr(v, 'held_object'):
@@ -4229,7 +4233,7 @@ def func_install_headers(self, node, args, kwargs):
         if install_dir is not None and not isinstance(install_dir, str):
             raise InterpreterException('install_dir keyword argument must be a string if provided')
 
-        h = build.Headers(source_files, install_subdir, install_dir, install_mode)
+        h = build.Headers(source_files, install_subdir, install_dir, install_mode, self.subproject)
         self.build.headers.append(h)
 
         return HeadersHolder(h)
@@ -4250,7 +4254,7 @@ def func_install_man(self, node, args, kwargs):
         if custom_install_dir is not None and not isinstance(custom_install_dir, str):
             raise InterpreterException('install_dir must be a string.')
 
-        m = build.Man(sources, custom_install_dir, custom_install_mode)
+        m = build.Man(sources, custom_install_dir, custom_install_mode, self.subproject)
         self.build.man.append(m)
 
         return ManHolder(m)
@@ -4350,7 +4354,7 @@ def func_install_data(self, node, args: T.List, kwargs: T.Dict[str, T.Any]):
                     '"rename" and "sources" argument lists must be the same length if "rename" is given. '
                     f'Rename has {len(rename)} elements and sources has {len(sources)}.')
 
-        data = DataHolder(build.Data(sources, install_dir, install_mode, rename))
+        data = DataHolder(build.Data(sources, install_dir, install_mode, self.subproject, rename))
         self.build.data.append(data.held_object)
         return data
 
@@ -4397,7 +4401,7 @@ def func_install_subdir(self, node, args, kwargs):
             exclude_directories = set()
         exclude = (exclude_files, exclude_directories)
         install_mode = self._get_kwarg_install_mode(kwargs)
-        idir = build.InstallDir(self.subdir, subdir, install_dir, install_mode, exclude, strip_directory)
+        idir = build.InstallDir(self.subdir, subdir, install_dir, install_mode, exclude, strip_directory, self.subproject)
         self.build.install_dirs.append(idir)
         return InstallDirHolder(idir)
 
@@ -4587,7 +4591,7 @@ def func_configure_file(self, node, args, kwargs):
                                            'is true')
             cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
             install_mode = self._get_kwarg_install_mode(kwargs)
-            self.build.data.append(build.Data([cfile], idir, install_mode))
+            self.build.data.append(build.Data([cfile], idir, install_mode, self.subproject))
         return mesonlib.File.from_built_file(self.subdir, output)
 
     def extract_incdirs(self, kwargs):