Add and use a an alias for Program types

mesonbuild/build.py

@@ -363,7 +363,7 @@ def __init__(self, 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, programs.AnyProgram] = {}
         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
@@ -2850,7 +2850,7 @@ def __init__(self,
                  environment: Environment,
                  command: T.Sequence[T.Union[
                      str, BuildTargetTypes, GeneratedList,
-                     programs.ExternalProgram, File]],
+                     programs.AnyProgram, File]],
                  sources: T.Sequence[T.Union[
                      str, File, BuildTargetTypes, ExtractedObjects,
                      GeneratedList, programs.ExternalProgram]],

mesonbuild/interpreter/interpreter.py

@@ -119,7 +119,7 @@
     from ..backend.backends import Backend
     from ..interpreterbase.baseobjects import InterpreterObject, TYPE_var, TYPE_kwargs
     from ..options import OptionDict
-    from ..programs import OverrideProgram
+    from ..programs import AnyProgram
     from .type_checking import SourcesVarargsType
 
     # Input source types passed to Targets
@@ -131,7 +131,7 @@
 
     BuildTargetSource = T.Union[mesonlib.FileOrString, build.GeneratedTypes, build.StructuredSources]
 
-    ProgramVersionFunc = T.Callable[[T.Union[ExternalProgram, build.Executable, OverrideProgram]], str]
+    ProgramVersionFunc = T.Callable[[AnyProgram], str]
 
     TestClass = T.TypeVar('TestClass', bound=Test)
 
@@ -1585,7 +1585,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[AnyProgram]:
         for name in command_names:
             if not isinstance(name, str):
                 continue
@@ -1600,7 +1600,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: AnyProgram) -> 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:
@@ -1625,7 +1625,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']:
+                          ) -> AnyProgram:
         args = mesonlib.listify(args)
 
         extra_info: T.List[mlog.TV_Loggable] = []
@@ -1657,7 +1657,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[AnyProgram]:
         progobj = self.program_from_overrides(args, extra_info)
         if progobj:
             return progobj
@@ -1693,7 +1693,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: AnyProgram,
                               wanted: T.Union[str, T.List[str]],
                               version_func: T.Optional[ProgramVersionFunc],
                               extra_info: T.List[mlog.TV_Loggable]) -> bool:
@@ -1720,7 +1720,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]]:
+                              ) -> AnyProgram:
         mlog.log('Fallback to subproject', mlog.bold(fallback), 'which provides program',
                  mlog.bold(' '.join(args)))
         sp_kwargs: kwtypes.DoSubproject = {
@@ -1747,7 +1747,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']:
+                          ) -> AnyProgram:
         disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
         if disabled:
             mlog.log('Program', mlog.bold(' '.join(args[0])), 'skipped: feature', mlog.bold(feature), 'disabled')

mesonbuild/modules/__init__.py

@@ -18,7 +18,7 @@
     from ..interpreter import Interpreter
     from ..interpreter.interpreter import ProgramVersionFunc
     from ..interpreterbase import TYPE_var, TYPE_kwargs
-    from ..programs import OverrideProgram
+    from ..programs import AnyProgram
     from ..dependencies import Dependency
     from ..options import ElementaryOptionValues
 
@@ -75,14 +75,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) -> AnyProgram:
         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) -> AnyProgram:
         # Look in overrides in case it's built as subproject
         progobj = self._interpreter.program_from_overrides([name], [])
         if progobj is not None:

mesonbuild/modules/_qt.py

@@ -28,7 +28,7 @@
     from ..interpreter import Interpreter
     from ..interpreter import kwargs
     from ..mesonlib import FileOrString
-    from ..programs import ExternalProgram
+    from ..programs import AnyProgram, CommandList
     from typing_extensions import Literal
 
     QtDependencyType = T.Union[QtPkgConfigDependency, QmakeQtDependency]
@@ -208,8 +208,8 @@ def __init__(self, interpreter: Interpreter, qt_version: int = 5):
         ExtensionModule.__init__(self, interpreter)
         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]] = {
+        # the returned program will change as well
+        self.tools: T.Dict[str, AnyProgram] = {
             tool: NonExistingExternalProgram(tool) for tool in self._set_of_qt_tools
         }
         self.methods.update({
@@ -251,7 +251,7 @@ def gen_bins() -> T.Generator[T.Tuple[str, str], None, None]:
                 arg = ['-v']
 
             # Ensure that the version of qt and each tool are the same
-            def get_version(p: T.Union[ExternalProgram, build.Executable]) -> str:
+            def get_version(p: AnyProgram) -> str:
                 _, out, err = Popen_safe(p.get_command() + arg)
                 if name == 'lrelease' or not qt_dep.version.startswith('4'):
                     care = out
@@ -727,7 +727,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: CommandList = [self.tools['lrelease'], '@INPUT@', '-qm', '@OUTPUT@']
             lrelease_target = build.CustomTarget(
                 f'qt{self.qt_version}-compile-{ts}',
                 outdir,

mesonbuild/modules/codegen.py

@@ -21,18 +21,16 @@
 from .. import mlog
 
 if T.TYPE_CHECKING:
-    from typing_extensions import Literal, TypeAlias, TypedDict
+    from typing_extensions import Literal, TypedDict
 
     from . import ModuleState
     from .._typing import ImmutableListProtocol
-    from ..build import Executable
     from ..interpreter import Interpreter
     from ..interpreter.kwargs import ExtractRequired
     from ..interpreterbase import TYPE_var, TYPE_kwargs
     from ..mesonlib import MachineChoice
-    from ..programs import OverrideProgram
+    from ..programs import AnyProgram, CommandList
 
-    Program: TypeAlias = T.Union[Executable, ExternalProgram, OverrideProgram]
     LexImpls = Literal['lex', 'flex', 'reflex', 'win_flex']
     YaccImpls = Literal['yacc', 'byacc', 'bison', 'win_bison']
 
@@ -87,12 +85,11 @@ def inner(check: T.List[str]) -> T.Optional[str]:
 class _CodeGenerator(HoldableObject):
 
     name: str
-    program: Program
+    program: AnyProgram
     arguments: ImmutableListProtocol[str] = dataclasses.field(default_factory=list)
 
-    def command(self) -> T.List[T.Union[Program, str]]:
-        return (T.cast('T.List[T.Union[Program, str]]', [self.program]) +
-                T.cast('T.List[T.Union[Program, str]]', self.arguments))
+    def command(self) -> CommandList:
+        return T.cast('CommandList', [self.program]) + T.cast('CommandList', self.arguments)
 
     def found(self) -> bool:
         return self.program.found()

mesonbuild/modules/dlang.py

@@ -22,20 +22,18 @@
     from typing_extensions import Literal, TypeAlias
 
     from . import ModuleState
-    from ..build import OverrideExecutable
     from ..interpreter.interpreter import Interpreter
     from ..interpreterbase.baseobjects import TYPE_kwargs
-    from ..programs import ExternalProgram, OverrideProgram
+    from ..programs import AnyProgram
 
-    _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[AnyProgram, Literal[False], None] = None
     init_dub = False
 
-    dubbin: T.Union[_AnyProgram, Literal[False], None]
+    dubbin: T.Union[AnyProgram, Literal[False], None]
 
     INFO = ModuleInfo('dlang', '0.48.0')
 
@@ -122,7 +120,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[AnyProgram, Literal[False]]:
         dubbin = state.find_program('dub', silent=True)
         if dubbin.found():
             try: