Override program with a custom target

docs/markdown/snippets/override_program_ct.md

@@ -0,0 +1,14 @@
+## Override a program with a custom target
+
+A program can now be generated using a [[custom_target]] and set an override
+so subprojects can use it at compile time.
+
+```meson
+ct = custom_target(
+  output : 'program',
+  command: ['program_generator.py'],
+  depends: my_pymod,
+  install: true,
+)
+meson.override_find_program('program', ct)
+```

docs/yaml/builtins/meson.yaml

@@ -389,7 +389,7 @@ methods:
         description: The name of the program to override.
 
       program:
-        type: exe | file | external_program
+        type: exe | file | external_program | custom_tgt | custom_idx
         description: The program to set as the override for `progname`.
 
   - name: override_dependency

mesonbuild/backend/backends.py

@@ -529,7 +529,7 @@ def determine_swift_dep_dirs(self, target: build.BuildTarget) -> T.List[str]:
         return result
 
     def get_executable_serialisation(
-            self, cmd: T.Sequence[T.Union[programs.ExternalProgram, build.BuildTarget, build.CustomTarget, File, str]],
+            self, cmd: T.Sequence[T.Union[programs.ExternalProgram, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, File, str]],
             workdir: T.Optional[str] = None,
             extra_bdeps: T.Optional[T.List[build.BuildTarget]] = None,
             capture: T.Optional[str] = None,
@@ -548,7 +548,7 @@ def get_executable_serialisation(
         elif isinstance(exe, build.BuildTarget):
             exe_cmd = [self.get_target_filename_abs(exe)]
             exe_for_machine = exe.for_machine
-        elif isinstance(exe, build.CustomTarget):
+        elif isinstance(exe, (build.CustomTarget, build.CustomTargetIndex)):
             # The output of a custom target can either be directly runnable
             # or not, that is, a script, a native binary or a cross compiled
             # binary when exe wrapper is available and when it is not.
@@ -567,7 +567,7 @@ def get_executable_serialisation(
         for c in raw_cmd_args:
             if isinstance(c, programs.ExternalProgram):
                 cmd_args += c.get_command()
-            elif isinstance(c, (build.BuildTarget, build.CustomTarget)):
+            elif isinstance(c, (build.BuildTarget, build.CustomTarget, build.CustomTargetIndex)):
                 cmd_args.append(self.get_target_filename_abs(c))
             elif isinstance(c, mesonlib.File):
                 cmd_args.append(c.rel_to_builddir(self.environment.source_dir))

mesonbuild/build.py

@@ -42,7 +42,7 @@
     from ._typing import ImmutableListProtocol
     from .backend.backends import Backend
     from .compilers import Compiler
-    from .interpreter.interpreter import SourceOutputs, Interpreter
+    from .interpreter.interpreter import SourceOutputs, Interpreter, ProgramType
     from .interpreter.interpreterobjects import Test, Doctest
     from .interpreterbase import SubProject
     from .linkers.linkers import StaticLinker
@@ -291,7 +291,7 @@ def __init__(self, environment: environment.Environment):
         self.stdlibs = PerMachine({}, {})
         self.test_setups: T.Dict[str, TestSetup] = {}
         self.test_setup_default_name = None
-        self.find_overrides: T.Dict[str, T.Union['OverrideExecutable', programs.ExternalProgram, programs.OverrideProgram]] = {}
+        self.find_overrides: T.Dict[str, ProgramType] = {}
         self.searched_programs: T.Set[str] = set() # The list of all programs that have been searched for.
 
         # If we are doing a cross build we need two caches, if we're doing a
@@ -1981,7 +1981,7 @@ def __str__(self) -> str:
         return self.fname
 
 class Generator(HoldableObject):
-    def __init__(self, exe: T.Union['Executable', programs.ExternalProgram],
+    def __init__(self, exe: ProgramType,
                  arguments: T.List[str],
                  output: T.List[str],
                  # how2dataclass
@@ -2002,7 +2002,7 @@ def __repr__(self) -> str:
         repr_str = "<{0}: {1}>"
         return repr_str.format(self.__class__.__name__, self.exe)
 
-    def get_exe(self) -> T.Union['Executable', programs.ExternalProgram]:
+    def get_exe(self) -> ProgramType:
         return self.exe
 
     def get_base_outnames(self, inname: str) -> T.List[str]:
@@ -3356,6 +3356,18 @@ def __getattr__(self, name: str) -> T.Any:
     def get_version(self, interpreter: T.Optional[Interpreter] = None) -> str:
         return self._version
 
+class OverrideCustomTarget(CustomTargetIndex):
+    def __init__(self, target: CustomTargetIndex, version: str):
+        self._target = target
+        self._version = version
+
+    def __getattr__(self, name: str) -> T.Any:
+        _target = object.__getattribute__(self, '_target')
+        return getattr(_target, name)
+
+    def get_version(self, interpreter: T.Optional[Interpreter] = None) -> str:
+        return self._version
+
 # A bit poorly named, but this represents plain data files to copy
 # during install.
 @dataclass(eq=False)

mesonbuild/interpreter/interpreter.py

@@ -131,6 +131,8 @@
 
     BuildTargetSource = T.Union[mesonlib.FileOrString, build.GeneratedTypes, build.StructuredSources]
 
+    ProgramType = T.Union[ExternalProgram, OverrideProgram, build.OverrideExecutable, build.OverrideCustomTarget]
+
     ProgramVersionFunc = T.Callable[[T.Union[ExternalProgram, build.Executable, OverrideProgram]], str]
 
     TestClass = T.TypeVar('TestClass', bound=Test)
@@ -428,6 +430,7 @@ def build_holder_map(self) -> None:
             build.GeneratedList: OBJ.GeneratedListHolder,
             build.ExtractedObjects: OBJ.GeneratedObjectsHolder,
             build.OverrideExecutable: OBJ.OverrideExecutableHolder,
+            build.OverrideCustomTarget: OBJ.OverrideCustomTargetHolder,
             build.RunTarget: OBJ.RunTargetHolder,
             build.AliasTarget: OBJ.AliasTargetHolder,
             build.Headers: OBJ.HeadersHolder,
@@ -1589,7 +1592,7 @@ def program_from_system(self, args: T.List[mesonlib.FileOrString], search_dirs:
 
     def program_from_overrides(self, command_names: T.List[mesonlib.FileOrString],
                                extra_info: T.List['mlog.TV_Loggable']
-                               ) -> T.Optional[T.Union[ExternalProgram, OverrideProgram, build.OverrideExecutable]]:
+                               ) -> T.Optional[ProgramType]:
         for name in command_names:
             if not isinstance(name, str):
                 continue
@@ -1604,7 +1607,7 @@ def store_name_lookups(self, command_names: T.List[mesonlib.FileOrString]) -> No
             if isinstance(name, str):
                 self.build.searched_programs.add(name)
 
-    def add_find_program_override(self, name: str, exe: T.Union[build.OverrideExecutable, ExternalProgram, 'OverrideProgram']) -> None:
+    def add_find_program_override(self, name: str, exe: ProgramType) -> None:
         if name in self.build.searched_programs:
             raise InterpreterException(f'Tried to override finding of executable "{name}" which has already been found.')
         if name in self.build.find_overrides:
@@ -1629,7 +1632,7 @@ def find_program_impl(self, args: T.List[mesonlib.FileOrString],
                           search_dirs: T.Optional[T.List[str]] = None,
                           version_arg: T.Optional[str] = '',
                           version_func: T.Optional[ProgramVersionFunc] = None
-                          ) -> T.Union['ExternalProgram', 'build.OverrideExecutable', 'OverrideProgram']:
+                          ) -> ProgramType:
         args = mesonlib.listify(args)
 
         extra_info: T.List[mlog.TV_Loggable] = []
@@ -1661,7 +1664,7 @@ def program_lookup(self, args: T.List[mesonlib.FileOrString], for_machine: Machi
                        version_arg: T.Optional[str],
                        version_func: T.Optional[ProgramVersionFunc],
                        extra_info: T.List[mlog.TV_Loggable]
-                       ) -> T.Optional[T.Union[ExternalProgram, build.Executable, OverrideProgram]]:
+                       ) -> T.Optional[ProgramType]:
         progobj = self.program_from_overrides(args, extra_info)
         if progobj:
             return progobj
@@ -1697,7 +1700,7 @@ def program_lookup(self, args: T.List[mesonlib.FileOrString], for_machine: Machi
 
         return progobj
 
-    def check_program_version(self, progobj: T.Union[ExternalProgram, build.Executable, OverrideProgram],
+    def check_program_version(self, progobj: ProgramType,
                               wanted: T.Union[str, T.List[str]],
                               version_func: T.Optional[ProgramVersionFunc],
                               extra_info: T.List[mlog.TV_Loggable]) -> bool:
@@ -1724,7 +1727,7 @@ def check_program_version(self, progobj: T.Union[ExternalProgram, build.Executab
     def find_program_fallback(self, fallback: str, args: T.List[mesonlib.FileOrString],
                               default_options: OptionDict,
                               required: bool, extra_info: T.List[mlog.TV_Loggable]
-                              ) -> T.Optional[T.Union[ExternalProgram, build.Executable, OverrideProgram]]:
+                              ) -> T.Optional[ProgramType]:
         mlog.log('Fallback to subproject', mlog.bold(fallback), 'which provides program',
                  mlog.bold(' '.join(args)))
         sp_kwargs: kwtypes.DoSubproject = {
@@ -1751,7 +1754,7 @@ def find_program_fallback(self, fallback: str, args: T.List[mesonlib.FileOrStrin
     @disablerIfNotFound
     def func_find_program(self, node: mparser.BaseNode, args: T.Tuple[T.List[mesonlib.FileOrString]],
                           kwargs: 'kwtypes.FindProgram',
-                          ) -> T.Union['build.Executable', ExternalProgram, 'OverrideProgram']:
+                          ) -> ProgramType:
         disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
         if disabled:
             assert feature, 'for mypy'

mesonbuild/interpreter/interpreterobjects.py

@@ -1171,3 +1171,18 @@ class OverrideExecutableHolder(BuildTargetHolder[build.OverrideExecutable]):
     @InterpreterObject.method('version')
     def version_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
         return self.held_object.get_version(self.interpreter)
+
+class OverrideCustomTargetHolder(ObjectHolder[build.OverrideCustomTarget]):
+    @noPosargs
+    @noKwargs
+    @FeatureNew('OverrideCustomTarget.version', '1.10.0')
+    @InterpreterObject.method('version')
+    def version_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+        return self.held_object.get_version(self.interpreter)
+
+    @noPosargs
+    @noKwargs
+    @FeatureNew('OverrideCustomTarget.found', '1.10.0')
+    @InterpreterObject.method('found')
+    def found_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+        return True

mesonbuild/interpreter/mesonmain.py

@@ -59,7 +59,7 @@ def __init__(self, build: 'build.Build', interpreter: 'Interpreter'):
     def _find_source_script(
             self, name: str, prog: T.Union[str, mesonlib.File, build.Executable, ExternalProgram],
             args: T.List[str]) -> 'ExecutableSerialisation':
-        largs: T.List[T.Union[str, build.Executable, ExternalProgram]] = []
+        largs: T.List[T.Union[str, build.Executable, ExternalProgram, build.CustomTargetIndex]] = []
 
         if isinstance(prog, (build.Executable, ExternalProgram)):
             FeatureNew.single_use(f'Passing executable/found program object to script parameter of {name}',
@@ -312,10 +312,10 @@ def install_dependency_manifest_method(self, args: T.Tuple[str], kwargs: 'TYPE_k
         self.build.dep_manifest_name = args[0]
 
     @FeatureNew('meson.override_find_program', '0.46.0')
-    @typed_pos_args('meson.override_find_program', str, (mesonlib.File, ExternalProgram, build.Executable))
+    @typed_pos_args('meson.override_find_program', str, (mesonlib.File, ExternalProgram, build.Executable, build.CustomTarget, build.CustomTargetIndex))
     @noKwargs
     @InterpreterObject.method('override_find_program')
-    def override_find_program_method(self, args: T.Tuple[str, T.Union[mesonlib.File, ExternalProgram, build.Executable]], kwargs: 'TYPE_kwargs') -> None:
+    def override_find_program_method(self, args: T.Tuple[str, T.Union[mesonlib.File, ExternalProgram, build.Executable, build.CustomTarget, build.CustomTargetIndex]], kwargs: 'TYPE_kwargs') -> None:
         name, exe = args
         if isinstance(exe, mesonlib.File):
             abspath = exe.absolute_path(self.interpreter.environment.source_dir,
@@ -325,6 +325,14 @@ def override_find_program_method(self, args: T.Tuple[str, T.Union[mesonlib.File,
             exe = OverrideProgram(name, self.interpreter.project_version, command=[abspath])
         elif isinstance(exe, build.Executable):
             exe = build.OverrideExecutable(exe, self.interpreter.project_version)
+        elif isinstance(exe, build.CustomTarget):
+            FeatureNew.single_use('Overriding program with a CustomTarget', '1.10.0', self.subproject)
+            if len(exe.get_outputs()) != 1:
+                raise InterpreterException(f'Can only override {name} with a CustomTarget that has exactly one output file.')
+            exe = build.OverrideCustomTarget(exe[0], self.interpreter.project_version)
+        elif isinstance(exe, build.CustomTargetIndex):
+            FeatureNew.single_use('Overriding program with a CustomTargetIndex', '1.10.0', self.subproject)
+            exe = build.OverrideCustomTarget(exe, self.interpreter.project_version)
         self.interpreter.add_find_program_override(name, exe)
 
     @typed_kwargs(

mesonbuild/modules/__init__.py

@@ -16,9 +16,8 @@
 
 if T.TYPE_CHECKING:
     from ..interpreter import Interpreter
-    from ..interpreter.interpreter import ProgramVersionFunc
+    from ..interpreter.interpreter import ProgramVersionFunc, ProgramType
     from ..interpreterbase import TYPE_var, TYPE_kwargs
-    from ..programs import OverrideProgram
     from ..dependencies import Dependency
     from ..options import ElementaryOptionValues
 
@@ -75,14 +74,14 @@ def find_program(self, prog: T.Union[mesonlib.FileOrString, T.List[mesonlib.File
                      required: bool = True,
                      version_func: T.Optional[ProgramVersionFunc] = None,
                      wanted: T.Union[str, T.List[str]] = '', silent: bool = False,
-                     for_machine: MachineChoice = MachineChoice.HOST) -> T.Union[ExternalProgram, build.OverrideExecutable, OverrideProgram]:
+                     for_machine: MachineChoice = MachineChoice.HOST) -> ProgramType:
         if not isinstance(prog, list):
             prog = [prog]
         return self._interpreter.find_program_impl(prog, required=required, version_func=version_func,
                                                    wanted=wanted, silent=silent, for_machine=for_machine)
 
     def find_tool(self, name: str, depname: str, varname: str, required: bool = True,
-                  wanted: T.Optional[str] = None) -> T.Union[build.OverrideExecutable, ExternalProgram, 'OverrideProgram']:
+                  wanted: T.Optional[str] = None) -> ProgramType:
         # Look in overrides in case it's built as subproject
         progobj = self._interpreter.program_from_overrides([name], [])
         if progobj is not None:
@@ -118,7 +117,7 @@ def dependency(self, depname: str, native: bool = False, required: bool = True,
         # implementations of meson functions anyway.
         return self._interpreter.func_dependency(self.current_node, [depname], kwargs) # type: ignore
 
-    def test(self, args: T.Tuple[str, T.Union[build.Executable, build.Jar, 'ExternalProgram', mesonlib.File]],
+    def test(self, args: T.Tuple[str, T.Union[ProgramType, build.Jar, mesonlib.File]],
              workdir: T.Optional[str] = None,
              env: T.Union[T.List[str], T.Dict[str, str], str] = None,
              depends: T.List[T.Union[build.CustomTarget, build.BuildTarget]] = None) -> None:

mesonbuild/modules/_qt.py

@@ -24,8 +24,8 @@
 if T.TYPE_CHECKING:
     from . import ModuleState
     from ..dependencies.qt import QtPkgConfigDependency, QmakeQtDependency
-    from ..interpreter import Interpreter
-    from ..interpreter import kwargs
+    from ..interpreter import Interpreter, kwargs
+    from ..interpreter.interpreter import ProgramType
     from ..mesonlib import FileOrString
     from ..programs import ExternalProgram
     from typing_extensions import Literal
@@ -208,7 +208,7 @@ def __init__(self, interpreter: Interpreter, qt_version: int = 5):
         self.qt_version = qt_version
         # It is important that this list does not change order as the order of
         # the returned ExternalPrograms will change as well
-        self.tools: T.Dict[str, T.Union[ExternalProgram, build.Executable]] = {
+        self.tools: T.Dict[str, ProgramType] = {
             tool: NonExistingExternalProgram(tool) for tool in self._set_of_qt_tools
         }
         self.methods.update({
@@ -724,7 +724,7 @@ def compile_translations(self, state: ModuleState, args: T.Tuple, kwargs: Compil
                 ts = os.path.basename(ts)
             else:
                 outdir = state.subdir
-            cmd: T.List[T.Union[ExternalProgram, build.Executable, str]] = [self.tools['lrelease'], '@INPUT@', '-qm', '@OUTPUT@']
+            cmd: T.List[T.Union[ProgramType, str]] = [self.tools['lrelease'], '@INPUT@', '-qm', '@OUTPUT@']
             lrelease_target = build.CustomTarget(
                 f'qt{self.qt_version}-compile-{ts}',
                 outdir,

mesonbuild/modules/dlang.py

@@ -22,20 +22,17 @@
     from typing_extensions import Literal, TypeAlias
 
     from . import ModuleState
-    from ..build import OverrideExecutable
-    from ..interpreter.interpreter import Interpreter
+    from ..interpreter.interpreter import Interpreter, ProgramType
     from ..interpreterbase.baseobjects import TYPE_kwargs
-    from ..programs import ExternalProgram, OverrideProgram
 
-    _AnyProgram: TypeAlias = T.Union[OverrideExecutable, ExternalProgram, OverrideProgram]
     _JSONTypes: TypeAlias = T.Union[str, int, bool, None, T.List['_JSONTypes'], T.Dict[str, '_JSONTypes']]
 
 
 class DlangModule(ExtensionModule):
-    class_dubbin: T.Union[_AnyProgram, Literal[False], None] = None
+    class_dubbin: T.Union[ProgramType, Literal[False], None] = None
     init_dub = False
 
-    dubbin: T.Union[_AnyProgram, Literal[False], None]
+    dubbin: T.Union[ProgramType, Literal[False], None]
 
     INFO = ModuleInfo('dlang', '0.48.0')
 
@@ -122,7 +119,7 @@ def _call_dubbin(self, args: T.List[str], env: T.Optional[T.Mapping[str, str]] =
         p, out = Popen_safe(self.dubbin.get_command() + args, env=env)[0:2]
         return p.returncode, out.strip()
 
-    def check_dub(self, state: ModuleState) -> T.Union[_AnyProgram, Literal[False]]:
+    def check_dub(self, state: ModuleState) -> T.Union[ProgramType, Literal[False]]:
         dubbin = state.find_program('dub', silent=True)
         if dubbin.found():
             try: