diff options
| -rw-r--r-- | mesonbuild/ast/introspection.py | 48 | ||||
| -rw-r--r-- | mesonbuild/ast/postprocess.py | 4 | ||||
| -rw-r--r-- | mesonbuild/interpreterbase.py | 102 | ||||
| -rw-r--r-- | mesonbuild/mparser.py | 39 |
4 files changed, 96 insertions, 97 deletions
diff --git a/mesonbuild/ast/introspection.py b/mesonbuild/ast/introspection.py index c60c24b..d51b099 100644 --- a/mesonbuild/ast/introspection.py +++ b/mesonbuild/ast/introspection.py @@ -23,7 +23,7 @@ from ..mesonlib import MachineChoice from ..interpreterbase import InvalidArguments, TYPE_nvar from ..build import Executable, Jar, SharedLibrary, SharedModule, StaticLibrary from ..mparser import BaseNode, ArithmeticNode, ArrayNode, ElementaryNode, IdNode, FunctionNode, StringNode -from typing import Any, Dict, List, Optional +import typing as T import os build_target_functions = ['executable', 'jar', 'library', 'shared_library', 'shared_module', 'static_library', 'both_libraries'] @@ -33,7 +33,7 @@ class IntrospectionHelper: def __init__(self, cross_file: str) -> None: self.cross_file = cross_file # type: str self.native_file = None # type: str - self.cmd_line_options = {} # type: Dict[str, str] + self.cmd_line_options = {} # type: T.Dict[str, str] class IntrospectionInterpreter(AstInterpreter): # Interpreter to detect the options without a build directory @@ -42,11 +42,11 @@ class IntrospectionInterpreter(AstInterpreter): source_root: str, subdir: str, backend: str, - visitors: Optional[List[AstVisitor]] = None, - cross_file: Optional[str] = None, + visitors: T.Optional[T.List[AstVisitor]] = None, + cross_file: T.Optional[str] = None, subproject: str = '', subproject_dir: str = 'subprojects', - env: Optional[environment.Environment] = None) -> None: + env: T.Optional[environment.Environment] = None) -> None: visitors = visitors if visitors is not None else [] super().__init__(source_root, subdir, subproject, visitors=visitors) @@ -61,9 +61,9 @@ class IntrospectionInterpreter(AstInterpreter): self.option_file = os.path.join(self.source_root, self.subdir, 'meson_options.txt') self.backend = backend self.default_options = {'backend': self.backend} - self.project_data = {} # type: Dict[str, Any] - self.targets = [] # type: List[Dict[str, Any]] - self.dependencies = [] # type: List[Dict[str, Any]] + self.project_data = {} # type: T.Dict[str, T.Any] + self.targets = [] # type: T.List[T.Dict[str, T.Any]] + self.dependencies = [] # type: T.List[T.Dict[str, T.Any]] self.project_node = None # type: BaseNode self.funcs.update({ @@ -79,7 +79,7 @@ class IntrospectionInterpreter(AstInterpreter): 'both_libraries': self.func_both_lib, }) - def func_project(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> None: + def func_project(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> None: if self.project_node: raise InvalidArguments('Second call to project()') self.project_node = node @@ -136,7 +136,7 @@ class IntrospectionInterpreter(AstInterpreter): except (mesonlib.MesonException, RuntimeError): return - def func_add_languages(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> None: + def func_add_languages(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> None: args = self.flatten_args(args) for for_machine in [MachineChoice.BUILD, MachineChoice.HOST]: for lang in sorted(args, key=compilers.sort_clink): @@ -149,7 +149,7 @@ class IntrospectionInterpreter(AstInterpreter): if lang not in self.coredata.compilers[for_machine]: self.environment.detect_compiler_for(lang, for_machine) - def func_dependency(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> None: + def func_dependency(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> None: args = self.flatten_args(args) kwargs = self.flatten_kwargs(kwargs) if not args: @@ -173,7 +173,7 @@ class IntrospectionInterpreter(AstInterpreter): 'node': node }] - def build_target(self, node: BaseNode, args: List[TYPE_nvar], kwargs_raw: Dict[str, TYPE_nvar], targetclass) -> Optional[Dict[str, Any]]: + def build_target(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs_raw: T.Dict[str, TYPE_nvar], targetclass) -> T.Optional[T.Dict[str, T.Any]]: args = self.flatten_args(args) if not args or not isinstance(args[0], str): return None @@ -186,7 +186,7 @@ class IntrospectionInterpreter(AstInterpreter): kwargs = self.flatten_kwargs(kwargs_raw, True) - source_nodes = [] # type: List[BaseNode] + source_nodes = [] # type: T.List[BaseNode] while srcqueue: curr = srcqueue.pop(0) arg_node = None @@ -221,8 +221,8 @@ class IntrospectionInterpreter(AstInterpreter): kwargs_reduced = {k: v.value if isinstance(v, ElementaryNode) else v for k, v in kwargs_reduced.items()} kwargs_reduced = {k: v for k, v in kwargs_reduced.items() if not isinstance(v, BaseNode)} for_machine = MachineChoice.HOST - objects = [] # type: List[Any] - empty_sources = [] # type: List[Any] + objects = [] # type: T.List[T.Any] + empty_sources = [] # type: T.List[T.Any] # Passing the unresolved sources list causes errors target = targetclass(name, self.subdir, self.subproject, for_machine, empty_sources, objects, self.environment, kwargs_reduced) @@ -243,7 +243,7 @@ class IntrospectionInterpreter(AstInterpreter): self.targets += [new_target] return new_target - def build_library(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def build_library(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: default_library = self.coredata.get_builtin_option('default_library') if default_library == 'shared': return self.build_target(node, args, kwargs, SharedLibrary) @@ -253,28 +253,28 @@ class IntrospectionInterpreter(AstInterpreter): return self.build_target(node, args, kwargs, SharedLibrary) return None - def func_executable(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_executable(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: return self.build_target(node, args, kwargs, Executable) - def func_static_lib(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_static_lib(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: return self.build_target(node, args, kwargs, StaticLibrary) - def func_shared_lib(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_shared_lib(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: return self.build_target(node, args, kwargs, SharedLibrary) - def func_both_lib(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_both_lib(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: return self.build_target(node, args, kwargs, SharedLibrary) - def func_shared_module(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_shared_module(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: return self.build_target(node, args, kwargs, SharedModule) - def func_library(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_library(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: return self.build_library(node, args, kwargs) - def func_jar(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_jar(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: return self.build_target(node, args, kwargs, Jar) - def func_build_target(self, node: BaseNode, args: List[TYPE_nvar], kwargs: Dict[str, TYPE_nvar]) -> Optional[Dict[str, Any]]: + def func_build_target(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> T.Optional[T.Dict[str, T.Any]]: if 'target_type' not in kwargs: return None target_type = kwargs.pop('target_type') diff --git a/mesonbuild/ast/postprocess.py b/mesonbuild/ast/postprocess.py index aa19916..6d808be 100644 --- a/mesonbuild/ast/postprocess.py +++ b/mesonbuild/ast/postprocess.py @@ -17,7 +17,7 @@ from . import AstVisitor from .. import mparser -from typing import Dict +import typing as T class AstIndentationGenerator(AstVisitor): def __init__(self) -> None: @@ -77,7 +77,7 @@ class AstIndentationGenerator(AstVisitor): class AstIDGenerator(AstVisitor): def __init__(self) -> None: - self.counter = {} # type: Dict[str, int] + self.counter = {} # type: T.Dict[str, int] def visit_default_func(self, node: mparser.BaseNode) -> None: name = type(node).__name__ diff --git a/mesonbuild/interpreterbase.py b/mesonbuild/interpreterbase.py index db77266..e3c2c64 100644 --- a/mesonbuild/interpreterbase.py +++ b/mesonbuild/interpreterbase.py @@ -21,16 +21,16 @@ from . import environment, dependencies import os, copy, re import collections.abc from functools import wraps -from typing import Any, Callable, ClassVar, Dict, Generic, List, Set, Sequence, Tuple, TypeVar, Optional, Union +import typing as T class InterpreterObject: def __init__(self): - self.methods = {} # type: Dict[str, Callable] + self.methods = {} # type: T.Dict[str, T.Callable] # Current node set during a method call. This can be used as location # when printing a warning message during a method call. self.current_node = None # type: mparser.BaseNode - def method_call(self, method_name: str, args: List[Union[mparser.BaseNode, str, int, float, bool, list, dict, 'InterpreterObject', 'ObjectHolder']], kwargs: Dict[str, Union[mparser.BaseNode, str, int, float, bool, list, dict, 'InterpreterObject', 'ObjectHolder']]): + def method_call(self, method_name: str, args: T.List[T.Union[mparser.BaseNode, str, int, float, bool, list, dict, 'InterpreterObject', 'ObjectHolder']], kwargs: T.Dict[str, T.Union[mparser.BaseNode, str, int, float, bool, list, dict, 'InterpreterObject', 'ObjectHolder']]): if method_name in self.methods: method = self.methods[method_name] if not getattr(method, 'no-args-flattening', False): @@ -38,24 +38,24 @@ class InterpreterObject: return method(args, kwargs) raise InvalidCode('Unknown method "%s" in object.' % method_name) -TV_InterpreterObject = TypeVar('TV_InterpreterObject') +TV_InterpreterObject = T.TypeVar('TV_InterpreterObject') -class ObjectHolder(Generic[TV_InterpreterObject]): - def __init__(self, obj: InterpreterObject, subproject: Optional[str] = None): +class ObjectHolder(T.Generic[TV_InterpreterObject]): + def __init__(self, obj: InterpreterObject, subproject: T.Optional[str] = None): self.held_object = obj # type: InterpreterObject self.subproject = subproject # type: str def __repr__(self): return '<Holder: {!r}>'.format(self.held_object) -TYPE_elementary = Union[str, int, float, bool] -TYPE_var = Union[TYPE_elementary, list, dict, InterpreterObject, ObjectHolder] -TYPE_nvar = Union[TYPE_var, mparser.BaseNode] -TYPE_nkwargs = Dict[Union[mparser.BaseNode, str], TYPE_nvar] +TYPE_elementary = T.Union[str, int, float, bool] +TYPE_var = T.Union[TYPE_elementary, list, dict, InterpreterObject, ObjectHolder] +TYPE_nvar = T.Union[TYPE_var, mparser.BaseNode] +TYPE_nkwargs = T.Dict[T.Union[mparser.BaseNode, str], TYPE_nvar] # Decorators for method calls. -def check_stringlist(a: Any, msg: str = 'Arguments must be strings.') -> None: +def check_stringlist(a: T.Any, msg: str = 'Arguments must be strings.') -> None: if not isinstance(a, list): mlog.debug('Not a list:', str(a)) raise InvalidArguments('Argument not a list.') @@ -124,13 +124,13 @@ def _get_callee_args(wrapped_args, want_subproject: bool = False): kwargs = kwargs if kwargs is not None else {} return s, node, args, kwargs, subproject -def flatten(args: Union[TYPE_nvar, List[TYPE_nvar]]) -> List[TYPE_nvar]: +def flatten(args: T.Union[TYPE_nvar, T.List[TYPE_nvar]]) -> T.List[TYPE_nvar]: if isinstance(args, mparser.StringNode): assert isinstance(args.value, str) return [args.value] if not isinstance(args, collections.abc.Sequence): return [args] - result = [] # type: List[TYPE_nvar] + result = [] # type: T.List[TYPE_nvar] for a in args: if isinstance(a, list): rest = flatten(a) @@ -185,8 +185,8 @@ def disablerIfNotFound(f): class permittedKwargs: - def __init__(self, permitted: Set[str]) -> None: - self.permitted = permitted # type: Set[str] + def __init__(self, permitted: T.Set[str]) -> None: + self.permitted = permitted # type: T.Set[str] def __call__(self, f): @wraps(f) @@ -206,7 +206,7 @@ class FeatureCheckBase: # Class variable, shared across all instances # # Format: {subproject: {feature_version: set(feature_names)}} - feature_registry = {} # type: ClassVar[Dict[str, Dict[str, Set[str]]]] + feature_registry = {} # type: T.ClassVar[T.Dict[str, T.Dict[str, T.Set[str]]]] def __init__(self, feature_name: str, version: str) -> None: self.feature_name = feature_name # type: str @@ -293,7 +293,7 @@ class FeatureDeprecated(FeatureCheckBase): class FeatureCheckKwargsBase: - def __init__(self, feature_name: str, feature_version: str, kwargs: List[str]) -> None: + def __init__(self, feature_name: str, feature_version: str, kwargs: T.List[str]) -> None: self.feature_name = feature_name self.feature_version = feature_version self.kwargs = kwargs @@ -377,11 +377,11 @@ class InterpreterBase: def __init__(self, source_root: str, subdir: str, subproject: str) -> None: self.source_root = source_root - self.funcs = {} # type: Dict[str, Callable[[mparser.BaseNode, List[TYPE_nvar], Dict[str, TYPE_nvar]], TYPE_var]] - self.builtin = {} # type: Dict[str, InterpreterObject] + self.funcs = {} # type: T.Dict[str, T.Callable[[mparser.BaseNode, T.List[TYPE_nvar], T.Dict[str, TYPE_nvar]], TYPE_var]] + self.builtin = {} # type: T.Dict[str, InterpreterObject] self.subdir = subdir self.subproject = subproject - self.variables = {} # type: Dict[str, TYPE_var] + self.variables = {} # type: T.Dict[str, TYPE_var] self.argument_depth = 0 self.current_lineno = -1 # Current node set during a function call. This can be used as location @@ -403,7 +403,7 @@ class InterpreterBase: me.file = mesonfile raise me - def join_path_strings(self, args: Sequence[str]) -> str: + def join_path_strings(self, args: T.Sequence[str]) -> str: return os.path.join(*args).replace('\\', '/') def parse_project(self) -> None: @@ -430,7 +430,7 @@ class InterpreterBase: except SubdirDoneRequest: pass - def evaluate_codeblock(self, node: mparser.CodeBlockNode, start: int = 0, end: Optional[int] = None) -> None: + def evaluate_codeblock(self, node: mparser.CodeBlockNode, start: int = 0, end: T.Optional[int] = None) -> None: if node is None: return if not isinstance(node, mparser.CodeBlockNode): @@ -454,7 +454,7 @@ class InterpreterBase: raise e i += 1 # In THE FUTURE jump over blocks and stuff. - def evaluate_statement(self, cur: mparser.BaseNode) -> Optional[TYPE_var]: + def evaluate_statement(self, cur: mparser.BaseNode) -> T.Optional[TYPE_var]: if isinstance(cur, mparser.FunctionNode): return self.function_call(cur) elif isinstance(cur, mparser.AssignmentNode): @@ -512,10 +512,10 @@ class InterpreterBase: return arguments @FeatureNew('dict', '0.47.0') - def evaluate_dictstatement(self, cur: mparser.DictNode) -> Dict[str, Any]: + def evaluate_dictstatement(self, cur: mparser.DictNode) -> T.Dict[str, T.Any]: (arguments, kwargs) = self.reduce_arguments(cur.args, resolve_key_nodes=False) assert (not arguments) - result = {} # type: Dict[str, Any] + result = {} # type: T.Dict[str, T.Any] self.argument_depth += 1 for key, value in kwargs.items(): if not isinstance(key, mparser.StringNode): @@ -530,7 +530,7 @@ class InterpreterBase: self.argument_depth -= 1 return result - def evaluate_notstatement(self, cur: mparser.NotNode) -> Union[bool, Disabler]: + def evaluate_notstatement(self, cur: mparser.NotNode) -> T.Union[bool, Disabler]: v = self.evaluate_statement(cur.value) if isinstance(v, Disabler): return v @@ -538,7 +538,7 @@ class InterpreterBase: raise InterpreterException('Argument to "not" is not a boolean.') return not v - def evaluate_if(self, node: mparser.IfClauseNode) -> Optional[Disabler]: + def evaluate_if(self, node: mparser.IfClauseNode) -> T.Optional[Disabler]: assert(isinstance(node, mparser.IfClauseNode)) for i in node.ifs: result = self.evaluate_statement(i.condition) @@ -553,19 +553,19 @@ class InterpreterBase: self.evaluate_codeblock(node.elseblock) return None - def validate_comparison_types(self, val1: Any, val2: Any) -> bool: + def validate_comparison_types(self, val1: T.Any, val2: T.Any) -> bool: if type(val1) != type(val2): return False return True - def evaluate_in(self, val1: Any, val2: Any) -> bool: + def evaluate_in(self, val1: T.Any, val2: T.Any) -> bool: if not isinstance(val1, (str, int, float, ObjectHolder)): raise InvalidArguments('lvalue of "in" operator must be a string, integer, float, or object') if not isinstance(val2, (list, dict)): raise InvalidArguments('rvalue of "in" operator must be an array or a dict') return val1 in val2 - def evaluate_comparison(self, node: mparser.ComparisonNode) -> Union[bool, Disabler]: + def evaluate_comparison(self, node: mparser.ComparisonNode) -> T.Union[bool, Disabler]: val1 = self.evaluate_statement(node.left) if isinstance(val1, Disabler): return val1 @@ -610,7 +610,7 @@ The result of this is undefined and will become a hard error in a future Meson r else: raise InvalidCode('You broke my compare eval.') - def evaluate_andstatement(self, cur: mparser.AndNode) -> Union[bool, Disabler]: + def evaluate_andstatement(self, cur: mparser.AndNode) -> T.Union[bool, Disabler]: l = self.evaluate_statement(cur.left) if isinstance(l, Disabler): return l @@ -625,7 +625,7 @@ The result of this is undefined and will become a hard error in a future Meson r raise InterpreterException('Second argument to "and" is not a boolean.') return r - def evaluate_orstatement(self, cur: mparser.OrNode) -> Union[bool, Disabler]: + def evaluate_orstatement(self, cur: mparser.OrNode) -> T.Union[bool, Disabler]: l = self.evaluate_statement(cur.left) if isinstance(l, Disabler): return l @@ -640,7 +640,7 @@ The result of this is undefined and will become a hard error in a future Meson r raise InterpreterException('Second argument to "or" is not a boolean.') return r - def evaluate_uminusstatement(self, cur) -> Union[int, Disabler]: + def evaluate_uminusstatement(self, cur) -> T.Union[int, Disabler]: v = self.evaluate_statement(cur.value) if isinstance(v, Disabler): return v @@ -656,7 +656,7 @@ The result of this is undefined and will become a hard error in a future Meson r raise InvalidCode('The division operator can only append a string.') return self.join_path_strings((l, r)) - def evaluate_division(self, l: Any, r: Any) -> Union[int, str]: + def evaluate_division(self, l: T.Any, r: T.Any) -> T.Union[int, str]: if isinstance(l, str) or isinstance(r, str): return self.evaluate_path_join(l, r) if isinstance(l, int) and isinstance(r, int): @@ -665,7 +665,7 @@ The result of this is undefined and will become a hard error in a future Meson r return l // r raise InvalidCode('Division works only with strings or integers.') - def evaluate_arithmeticstatement(self, cur: mparser.ArithmeticNode) -> Union[int, str, dict, list, Disabler]: + def evaluate_arithmeticstatement(self, cur: mparser.ArithmeticNode) -> T.Union[int, str, dict, list, Disabler]: l = self.evaluate_statement(cur.left) if isinstance(l, Disabler): return l @@ -751,7 +751,7 @@ The result of this is undefined and will become a hard error in a future Meson r # Remember that all variables are immutable. We must always create a # full new variable and then assign it. old_variable = self.get_variable(varname) - new_value = None # type: Union[str, int, float, bool, dict, list] + new_value = None # type: T.Union[str, int, float, bool, dict, list] if isinstance(old_variable, str): if not isinstance(addition, str): raise InvalidArguments('The += operator requires a string on the right hand side if the variable on the left is a string') @@ -803,14 +803,14 @@ The result of this is undefined and will become a hard error in a future Meson r # We are already checking for the existance of __getitem__, so this should be save raise InterpreterException('Index %d out of bounds of array of size %d.' % (index, len(iobject))) # type: ignore - def function_call(self, node: mparser.FunctionNode) -> Optional[TYPE_var]: + def function_call(self, node: mparser.FunctionNode) -> T.Optional[TYPE_var]: func_name = node.func_name (posargs, kwargs) = self.reduce_arguments(node.args) if is_disabled(posargs, kwargs) and func_name != 'set_variable' and func_name != 'is_disabler': return Disabler() if func_name in self.funcs: func = self.funcs[func_name] - func_args = posargs # type: Any + func_args = posargs # type: T.Any if not getattr(func, 'no-args-flattening', False): func_args = flatten(posargs) @@ -859,7 +859,7 @@ The result of this is undefined and will become a hard error in a future Meson r obj.current_node = node return obj.method_call(method_name, args, self.kwargs_string_keys(kwargs)) - def bool_method_call(self, obj: bool, method_name: str, posargs: List[TYPE_nvar]) -> Union[str, int]: + def bool_method_call(self, obj: bool, method_name: str, posargs: T.List[TYPE_nvar]) -> T.Union[str, int]: if method_name == 'to_string': if not posargs: if obj: @@ -881,7 +881,7 @@ The result of this is undefined and will become a hard error in a future Meson r else: raise InterpreterException('Unknown method "%s" for a boolean.' % method_name) - def int_method_call(self, obj: int, method_name: str, posargs: List[TYPE_nvar]) -> Union[str, bool]: + def int_method_call(self, obj: int, method_name: str, posargs: T.List[TYPE_nvar]) -> T.Union[str, bool]: if method_name == 'is_even': if not posargs: return obj % 2 == 0 @@ -901,7 +901,7 @@ The result of this is undefined and will become a hard error in a future Meson r raise InterpreterException('Unknown method "%s" for an integer.' % method_name) @staticmethod - def _get_one_string_posarg(posargs: List[TYPE_nvar], method_name: str) -> str: + def _get_one_string_posarg(posargs: T.List[TYPE_nvar], method_name: str) -> str: if len(posargs) > 1: m = '{}() must have zero or one arguments' raise InterpreterException(m.format(method_name)) @@ -913,7 +913,7 @@ The result of this is undefined and will become a hard error in a future Meson r return s return None - def string_method_call(self, obj: str, method_name: str, posargs: List[TYPE_nvar]) -> Union[str, int, bool, List[str]]: + def string_method_call(self, obj: str, method_name: str, posargs: T.List[TYPE_nvar]) -> T.Union[str, int, bool, T.List[str]]: if method_name == 'strip': s1 = self._get_one_string_posarg(posargs, 'strip') if s1 is not None: @@ -962,7 +962,7 @@ The result of this is undefined and will become a hard error in a future Meson r return mesonlib.version_compare(obj, cmpr) raise InterpreterException('Unknown method "%s" for a string.' % method_name) - def format_string(self, templ: str, args: List[TYPE_nvar]) -> str: + def format_string(self, templ: str, args: T.List[TYPE_nvar]) -> str: arg_strings = [] for arg in args: if isinstance(arg, mparser.BaseNode): @@ -982,7 +982,7 @@ The result of this is undefined and will become a hard error in a future Meson r def unknown_function_called(self, func_name: str) -> None: raise InvalidCode('Unknown function "%s".' % func_name) - def array_method_call(self, obj: list, method_name: str, posargs: List[TYPE_nvar]) -> TYPE_var: + def array_method_call(self, obj: list, method_name: str, posargs: T.List[TYPE_nvar]) -> TYPE_var: if method_name == 'contains': def check_contains(el: list) -> bool: if len(posargs) != 1: @@ -1022,7 +1022,7 @@ The result of this is undefined and will become a hard error in a future Meson r m = 'Arrays do not have a method called {!r}.' raise InterpreterException(m.format(method_name)) - def dict_method_call(self, obj: dict, method_name: str, posargs: List[TYPE_nvar]) -> TYPE_var: + def dict_method_call(self, obj: dict, method_name: str, posargs: T.List[TYPE_nvar]) -> TYPE_var: if method_name in ('has_key', 'get'): if method_name == 'has_key': if len(posargs) != 1: @@ -1058,15 +1058,15 @@ The result of this is undefined and will become a hard error in a future Meson r raise InterpreterException('Dictionaries do not have a method called "%s".' % method_name) - def reduce_arguments(self, args: mparser.ArgumentNode, resolve_key_nodes: bool = True) -> Tuple[List[TYPE_nvar], TYPE_nkwargs]: + def reduce_arguments(self, args: mparser.ArgumentNode, resolve_key_nodes: bool = True) -> T.Tuple[T.List[TYPE_nvar], TYPE_nkwargs]: assert(isinstance(args, mparser.ArgumentNode)) if args.incorrect_order(): raise InvalidArguments('All keyword arguments must be after positional arguments.') self.argument_depth += 1 - reduced_pos = [self.evaluate_statement(arg) for arg in args.arguments] # type: List[TYPE_nvar] + reduced_pos = [self.evaluate_statement(arg) for arg in args.arguments] # type: T.List[TYPE_nvar] reduced_kw = {} # type: TYPE_nkwargs for key, val in args.kwargs.items(): - reduced_key = key # type: Union[str, mparser.BaseNode] + reduced_key = key # type: T.Union[str, mparser.BaseNode] reduced_val = val # type: TYPE_nvar if resolve_key_nodes and isinstance(key, mparser.IdNode): assert isinstance(key.value, str) @@ -1092,8 +1092,8 @@ The result of this is undefined and will become a hard error in a future Meson r kwargs[k] = v return kwargs - def kwargs_string_keys(self, kwargs: TYPE_nkwargs) -> Dict[str, TYPE_nvar]: - kw = {} # type: Dict[str, TYPE_nvar] + def kwargs_string_keys(self, kwargs: TYPE_nkwargs) -> T.Dict[str, TYPE_nvar]: + kw = {} # type: T.Dict[str, TYPE_nvar] for key, val in kwargs.items(): if not isinstance(key, str): raise InterpreterException('Key of kwargs is not a string') @@ -1137,7 +1137,7 @@ To specify a keyword argument, use : instead of =.''') return self.variables[varname] raise InvalidCode('Unknown variable "%s".' % varname) - def is_assignable(self, value: Any) -> bool: + def is_assignable(self, value: T.Any) -> bool: return isinstance(value, (InterpreterObject, dependencies.Dependency, str, int, list, dict, mesonlib.File)) diff --git a/mesonbuild/mparser.py b/mesonbuild/mparser.py index 9e6226e..d0e7525 100644 --- a/mesonbuild/mparser.py +++ b/mesonbuild/mparser.py @@ -17,11 +17,10 @@ import codecs import textwrap import types import typing as T -from typing import Dict, Generic, Generator, List, Tuple, TypeVar, Optional, Union, TYPE_CHECKING from .mesonlib import MesonException from . import mlog -if TYPE_CHECKING: +if T.TYPE_CHECKING: from .ast import AstVisitor # This is the regex for the supported escape sequences of a regular string @@ -77,16 +76,16 @@ class BlockParseException(MesonException): self.lineno = lineno self.colno = colno -TV_TokenTypes = TypeVar('TV_TokenTypes', int, str, bool) +TV_TokenTypes = T.TypeVar('TV_TokenTypes', int, str, bool) -class Token(Generic[TV_TokenTypes]): - def __init__(self, tid: str, filename: str, line_start: int, lineno: int, colno: int, bytespan: Tuple[int, int], value: TV_TokenTypes) -> None: +class Token(T.Generic[TV_TokenTypes]): + def __init__(self, tid: str, filename: str, line_start: int, lineno: int, colno: int, bytespan: T.Tuple[int, int], value: TV_TokenTypes) -> None: self.tid = tid # type: str self.filename = filename # type: str self.line_start = line_start # type: int self.lineno = lineno # type: int self.colno = colno # type: int - self.bytespan = bytespan # type: Tuple[int, int] + self.bytespan = bytespan # type: T.Tuple[int, int] self.value = value # type: TV_TokenTypes def __eq__(self, other) -> bool: @@ -150,7 +149,7 @@ class Lexer: col = 0 while loc < len(self.code): matched = False - value = None # type: Union[str, bool, int] + value = None # type: T.Union[str, bool, int] for (tid, reg) in self.token_specification: mo = reg.match(self.code, loc) if mo: @@ -227,7 +226,7 @@ class Lexer: raise ParseException('lexer', self.getline(line_start), lineno, col) class BaseNode: - def __init__(self, lineno: int, colno: int, filename: str, end_lineno: Optional[int] = None, end_colno: Optional[int] = None) -> None: + def __init__(self, lineno: int, colno: int, filename: str, end_lineno: T.Optional[int] = None, end_colno: T.Optional[int] = None) -> None: self.lineno = lineno # type: int self.colno = colno # type: int self.filename = filename # type: str @@ -246,11 +245,11 @@ class BaseNode: if callable(func): func(self) -class ElementaryNode(Generic[TV_TokenTypes], BaseNode): +class ElementaryNode(T.Generic[TV_TokenTypes], BaseNode): def __init__(self, token: Token[TV_TokenTypes]) -> None: super().__init__(token.lineno, token.colno, token.filename) self.value = token.value # type: TV_TokenTypes - self.bytespan = token.bytespan # type: Tuple[int, int] + self.bytespan = token.bytespan # type: T.Tuple[int, int] class BooleanNode(ElementaryNode[bool]): def __init__(self, token: Token[bool]) -> None: @@ -287,9 +286,9 @@ class BreakNode(ElementaryNode): class ArgumentNode(BaseNode): def __init__(self, token: Token[TV_TokenTypes]) -> None: super().__init__(token.lineno, token.colno, token.filename) - self.arguments = [] # type: List[BaseNode] - self.commas = [] # type: List[Token[TV_TokenTypes]] - self.kwargs = {} # type: Dict[BaseNode, BaseNode] + self.arguments = [] # type: T.List[BaseNode] + self.commas = [] # type: T.List[Token[TV_TokenTypes]] + self.kwargs = {} # type: T.Dict[BaseNode, BaseNode] self.order_error = False def prepend(self, statement: BaseNode) -> None: @@ -374,7 +373,7 @@ class NotNode(BaseNode): class CodeBlockNode(BaseNode): def __init__(self, token: Token[TV_TokenTypes]) -> None: super().__init__(token.lineno, token.colno, token.filename) - self.lines = [] # type: List[BaseNode] + self.lines = [] # type: T.List[BaseNode] class IndexNode(BaseNode): def __init__(self, iobject: BaseNode, index: BaseNode) -> None: @@ -412,9 +411,9 @@ class PlusAssignmentNode(BaseNode): self.value = value # type: BaseNode class ForeachClauseNode(BaseNode): - def __init__(self, token: Token, varnames: List[str], items: BaseNode, block: CodeBlockNode) -> None: + def __init__(self, token: Token, varnames: T.List[str], items: BaseNode, block: CodeBlockNode) -> None: super().__init__(token.lineno, token.colno, token.filename) - self.varnames = varnames # type: List[str] + self.varnames = varnames # type: T.List[str] self.items = items # type: BaseNode self.block = block # type: CodeBlockNode @@ -427,8 +426,8 @@ class IfNode(BaseNode): class IfClauseNode(BaseNode): def __init__(self, linenode: BaseNode) -> None: super().__init__(linenode.lineno, linenode.colno, linenode.filename) - self.ifs = [] # type: List[IfNode] - self.elseblock = EmptyNode(linenode.lineno, linenode.colno, linenode.filename) # type: Union[EmptyNode, CodeBlockNode] + self.ifs = [] # type: T.List[IfNode] + self.elseblock = EmptyNode(linenode.lineno, linenode.colno, linenode.filename) # type: T.Union[EmptyNode, CodeBlockNode] class UMinusNode(BaseNode): def __init__(self, current_location: Token, value: BaseNode): @@ -722,7 +721,7 @@ class Parser: self.expect('id') assert isinstance(t.value, str) varname = t - varnames = [t.value] # type: List[str] + varnames = [t.value] # type: T.List[str] if self.accept('comma'): t = self.current @@ -754,7 +753,7 @@ class Parser: b = self.codeblock() clause.ifs.append(IfNode(s, s, b)) - def elseblock(self) -> Optional[CodeBlockNode]: + def elseblock(self) -> T.Optional[CodeBlockNode]: if self.accept('else'): self.expect('eol') return self.codeblock() |