# SPDX-License-Identifier: Apache-2.0 # Copyright © 2021 The Meson Developers # Copyright © 2021 Intel Corporation from __future__ import annotations """Keyword Argument type annotations.""" import typing as T from typing_extensions import TypedDict, Literal, Protocol from .. import build from .. import coredata from ..compilers import Compiler from ..dependencies.base import Dependency from ..mesonlib import EnvironmentVariables, MachineChoice, File, FileMode, FileOrString, OptionKey from ..modules.cmake import CMakeSubprojectOptions from ..programs import ExternalProgram from .type_checking import PkgConfigDefineType class FuncAddProjectArgs(TypedDict): """Keyword Arguments for the add_*_arguments family of arguments. including `add_global_arguments`, `add_project_arguments`, and their link variants Because of the use of a convertor function, we get the native keyword as a MachineChoice instance already. """ native: MachineChoice language: T.List[str] class BaseTest(TypedDict): """Shared base for the Rust module.""" args: T.List[T.Union[str, File, build.Target]] should_fail: bool timeout: int workdir: T.Optional[str] depends: T.List[T.Union[build.CustomTarget, build.BuildTarget]] priority: int env: EnvironmentVariables suite: T.List[str] class FuncBenchmark(BaseTest): """Keyword Arguments shared between `test` and `benchmark`.""" protocol: Literal['exitcode', 'tap', 'gtest', 'rust'] class FuncTest(FuncBenchmark): """Keyword Arguments for `test` `test` only adds the `is_parallel` argument over benchmark, so inheritance is helpful here. """ is_parallel: bool class ExtractRequired(TypedDict): """Keyword Arguments consumed by the `extract_required_kwargs` function. Any function that uses the `required` keyword argument which accepts either a boolean or a feature option should inherit it's arguments from this class. """ required: T.Union[bool, coredata.UserFeatureOption] class ExtractSearchDirs(TypedDict): """Keyword arguments consumed by the `extract_search_dirs` function. See the not in `ExtractRequired` """ dirs: T.List[str] class FuncGenerator(TypedDict): """Keyword rguments for the generator function.""" arguments: T.List[str] output: T.List[str] depfile: T.Optional[str] capture: bool depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]] class GeneratorProcess(TypedDict): """Keyword Arguments for generator.process.""" preserve_path_from: T.Optional[str] extra_args: T.List[str] class DependencyMethodPartialDependency(TypedDict): """ Keyword Arguments for the dep.partial_dependency methods """ compile_args: bool link_args: bool links: bool includes: bool sources: bool class BuildTargeMethodExtractAllObjects(TypedDict): recursive: bool class FuncInstallSubdir(TypedDict): install_dir: str strip_directory: bool exclude_files: T.List[str] exclude_directories: T.List[str] install_mode: FileMode follow_symlinks: T.Optional[bool] class FuncInstallData(TypedDict): install_dir: str sources: T.List[FileOrString] rename: T.List[str] install_mode: FileMode follow_symlinks: T.Optional[bool] class FuncInstallHeaders(TypedDict): install_dir: T.Optional[str] install_mode: FileMode subdir: T.Optional[str] follow_symlinks: T.Optional[bool] class FuncInstallMan(TypedDict): install_dir: T.Optional[str] install_mode: FileMode locale: T.Optional[str] class FuncImportModule(ExtractRequired): disabler: bool class FuncIncludeDirectories(TypedDict): is_system: bool class FuncAddLanguages(ExtractRequired): native: T.Optional[bool] class RunTarget(TypedDict): command: T.List[T.Union[str, build.BuildTarget, build.CustomTarget, ExternalProgram, File]] depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]] env: EnvironmentVariables class CustomTarget(TypedDict): build_always: bool build_always_stale: T.Optional[bool] build_by_default: T.Optional[bool] capture: bool command: T.List[T.Union[str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, ExternalProgram, File]] console: bool depend_files: T.List[FileOrString] depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]] depfile: T.Optional[str] env: EnvironmentVariables feed: bool input: T.List[T.Union[str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, build.ExtractedObjects, build.GeneratedList, ExternalProgram, File]] install: bool install_dir: T.List[T.Union[str, T.Literal[False]]] install_mode: FileMode install_tag: T.List[T.Optional[str]] output: T.List[str] class AddTestSetup(TypedDict): exe_wrapper: T.List[T.Union[str, ExternalProgram]] gdb: bool timeout_multiplier: int is_default: bool exclude_suites: T.List[str] env: EnvironmentVariables class Project(TypedDict): version: T.Optional[FileOrString] meson_version: T.Optional[str] default_options: T.Dict[OptionKey, T.Union[str, int, bool, T.List[str]]] license: T.List[str] subproject_dir: str class _FoundProto(Protocol): """Protocol for subdir arguments. This allows us to define any object that has a found(self) -> bool method """ def found(self) -> bool: ... class Subdir(TypedDict): if_found: T.List[_FoundProto] class Summary(TypedDict): section: str bool_yn: bool list_sep: T.Optional[str] class FindProgram(ExtractRequired, ExtractSearchDirs): default_options: T.Dict[OptionKey, T.Union[str, int, bool, T.List[str]]] native: MachineChoice version: T.List[str] class RunCommand(TypedDict): check: bool capture: T.Optional[bool] env: EnvironmentVariables class FeatureOptionRequire(TypedDict): error_message: T.Optional[str] class DependencyPkgConfigVar(TypedDict): default: T.Optional[str] define_variable: PkgConfigDefineType class DependencyGetVariable(TypedDict): cmake: T.Optional[str] pkgconfig: T.Optional[str] configtool: T.Optional[str] internal: T.Optional[str] default_value: T.Optional[str] pkgconfig_define: PkgConfigDefineType class ConfigurationDataSet(TypedDict): description: T.Optional[str] class VcsTag(TypedDict): command: T.List[T.Union[str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, ExternalProgram, File]] fallback: T.Optional[str] input: T.List[T.Union[str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, build.ExtractedObjects, build.GeneratedList, ExternalProgram, File]] output: T.List[str] replace_string: str class ConfigureFile(TypedDict): output: str capture: bool format: T.Literal['meson', 'cmake', 'cmake@'] output_format: T.Literal['c', 'json', 'nasm'] depfile: T.Optional[str] install: T.Optional[bool] install_dir: T.Union[str, T.Literal[False]] install_mode: FileMode install_tag: T.Optional[str] encoding: str command: T.Optional[T.List[T.Union[build.Executable, ExternalProgram, Compiler, File, str]]] input: T.List[FileOrString] configuration: T.Optional[T.Union[T.Dict[str, T.Union[str, int, bool]], build.ConfigurationData]] macro_name: T.Optional[str] class Subproject(ExtractRequired): default_options: T.Dict[OptionKey, T.Union[str, int, bool, T.List[str]]] version: T.List[str] class DoSubproject(ExtractRequired): default_options: T.Dict[OptionKey, T.Union[str, int, bool, T.List[str]]] version: T.List[str] cmake_options: T.List[str] options: T.Optional[CMakeSubprojectOptions] class _BaseBuildTarget(TypedDict): """Arguments used by all BuildTarget like functions. This really exists because Jar is so different than all of the other BuildTarget functions. """ override_options: T.Dict[OptionKey, T.Union[str, int, bool, T.List[str]]] class _BuildTarget(_BaseBuildTarget): """Arguments shared by non-JAR functions""" rust_dependency_map: T.Dict[str, str] class _LibraryMixin(TypedDict): rust_abi: T.Optional[Literal['c', 'rust']] class Executable(_BuildTarget): gui_app: T.Optional[bool] win_subsystem: T.Optional[str] class _StaticLibMixin(TypedDict): prelink: bool pic: T.Optional[bool] class StaticLibrary(_BuildTarget, _StaticLibMixin, _LibraryMixin): pass class _SharedLibMixin(TypedDict): darwin_versions: T.Optional[T.Tuple[str, str]] soversion: T.Optional[str] version: T.Optional[str] vs_module_defs: T.Optional[T.Union[str, File, build.CustomTarget]] class SharedLibrary(_BuildTarget, _SharedLibMixin, _LibraryMixin): pass class SharedModule(_BuildTarget, _LibraryMixin): vs_module_defs: T.Optional[T.Union[str, File, build.CustomTarget]] class Library(_BuildTarget, _SharedLibMixin, _StaticLibMixin, _LibraryMixin): """For library, both_library, and as a base for build_target""" class BuildTarget(Library): target_type: Literal['executable', 'shared_library', 'static_library', 'shared_module', 'both_libraries', 'library', 'jar'] class Jar(_BaseBuildTarget): main_class: str java_resources: T.Optional[build.StructuredSources] class FuncDeclareDependency(TypedDict): compile_args: T.List[str] d_import_dirs: T.List[T.Union[build.IncludeDirs, str]] d_module_versions: T.List[T.Union[str, int]] dependencies: T.List[Dependency] extra_files: T.List[FileOrString] include_directories: T.List[T.Union[build.IncludeDirs, str]] link_args: T.List[str] link_whole: T.List[T.Union[build.StaticLibrary, build.CustomTarget, build.CustomTargetIndex]] link_with: T.List[build.LibTypes] objects: T.List[build.ExtractedObjects] sources: T.List[T.Union[FileOrString, build.GeneratedTypes]] variables: T.Dict[str, str] version: T.Optional[str]