aboutsummaryrefslogtreecommitdiff
path: root/mesonbuild/ast
diff options
context:
space:
mode:
Diffstat (limited to 'mesonbuild/ast')
-rw-r--r--mesonbuild/ast/interpreter.py104
-rw-r--r--mesonbuild/ast/introspection.py104
-rw-r--r--mesonbuild/ast/postprocess.py29
-rw-r--r--mesonbuild/ast/printer.py76
-rw-r--r--mesonbuild/ast/visitor.py57
5 files changed, 200 insertions, 170 deletions
diff --git a/mesonbuild/ast/interpreter.py b/mesonbuild/ast/interpreter.py
index 5f47ad3..25dfb80 100644
--- a/mesonbuild/ast/interpreter.py
+++ b/mesonbuild/ast/interpreter.py
@@ -19,19 +19,27 @@ from .visitor import AstVisitor
from .. import interpreterbase, mparser, mesonlib
from .. import environment
-from ..interpreterbase import InvalidArguments, BreakRequest, ContinueRequest
+from ..interpreterbase import InvalidArguments, BreakRequest, ContinueRequest, TYPE_nvar, TYPE_nkwargs
from ..mparser import (
+ AndNode,
ArgumentNode,
ArithmeticNode,
ArrayNode,
AssignmentNode,
BaseNode,
+ ComparisonNode,
ElementaryNode,
EmptyNode,
+ ForeachClauseNode,
IdNode,
+ IfClauseNode,
+ IndexNode,
MethodNode,
+ OrNode,
PlusAssignmentNode,
+ StringNode,
TernaryNode,
+ UMinusNode,
)
import os, sys
@@ -59,13 +67,13 @@ ADD_SOURCE = 0
REMOVE_SOURCE = 1
class AstInterpreter(interpreterbase.InterpreterBase):
- def __init__(self, source_root: str, subdir: str, visitors: T.Optional[T.List[AstVisitor]] = None):
- super().__init__(source_root, subdir)
+ def __init__(self, source_root: str, subdir: str, subproject: str, visitors: T.Optional[T.List[AstVisitor]] = None):
+ super().__init__(source_root, subdir, subproject)
self.visitors = visitors if visitors is not None else []
- self.visited_subdirs = {}
- self.assignments = {}
- self.assign_vals = {}
- self.reverse_assignment = {}
+ self.visited_subdirs = {} # type: T.Dict[str, bool]
+ self.assignments = {} # type: T.Dict[str, BaseNode]
+ self.assign_vals = {} # type: T.Dict[str, T.Any]
+ self.reverse_assignment = {} # type: T.Dict[str, BaseNode]
self.funcs.update({'project': self.func_do_nothing,
'test': self.func_do_nothing,
'benchmark': self.func_do_nothing,
@@ -122,15 +130,15 @@ class AstInterpreter(interpreterbase.InterpreterBase):
'summary': self.func_do_nothing,
})
- def func_do_nothing(self, node, args, kwargs):
+ def func_do_nothing(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> bool:
return True
- def load_root_meson_file(self):
+ def load_root_meson_file(self) -> None:
super().load_root_meson_file()
for i in self.visitors:
self.ast.accept(i)
- def func_subdir(self, node, args, kwargs):
+ def func_subdir(self, node: BaseNode, args: T.List[TYPE_nvar], kwargs: T.Dict[str, TYPE_nvar]) -> None:
args = self.flatten_args(args)
if len(args) != 1 or not isinstance(args[0], str):
sys.stderr.write('Unable to evaluate subdir({}) in AstInterpreter --> Skipping\n'.format(args))
@@ -165,64 +173,69 @@ class AstInterpreter(interpreterbase.InterpreterBase):
self.evaluate_codeblock(codeblock)
self.subdir = prev_subdir
- def method_call(self, node):
+ def method_call(self, node: BaseNode) -> bool:
return True
- def evaluate_arithmeticstatement(self, cur):
+ def evaluate_arithmeticstatement(self, cur: ArithmeticNode) -> int:
self.evaluate_statement(cur.left)
self.evaluate_statement(cur.right)
return 0
- def evaluate_uminusstatement(self, cur):
+ def evaluate_uminusstatement(self, cur: UMinusNode) -> int:
self.evaluate_statement(cur.value)
return 0
- def evaluate_ternary(self, node):
+ def evaluate_ternary(self, node: TernaryNode) -> None:
assert(isinstance(node, TernaryNode))
self.evaluate_statement(node.condition)
self.evaluate_statement(node.trueblock)
self.evaluate_statement(node.falseblock)
- def evaluate_plusassign(self, node):
+ def evaluate_plusassign(self, node: PlusAssignmentNode) -> None:
assert(isinstance(node, PlusAssignmentNode))
- if node.var_name not in self.assignments:
- self.assignments[node.var_name] = []
- self.assign_vals[node.var_name] = []
- self.assignments[node.var_name] += [node.value] # Save a reference to the value node
- if hasattr(node.value, 'ast_id'):
+ # Cheat by doing a reassignment
+ self.assignments[node.var_name] = node.value # Save a reference to the value node
+ if node.value.ast_id:
self.reverse_assignment[node.value.ast_id] = node
- self.assign_vals[node.var_name] += [self.evaluate_statement(node.value)]
+ self.assign_vals[node.var_name] = self.evaluate_statement(node.value)
- def evaluate_indexing(self, node):
+ def evaluate_indexing(self, node: IndexNode) -> int:
return 0
- def unknown_function_called(self, func_name):
+ def unknown_function_called(self, func_name: str) -> None:
pass
- def reduce_arguments(self, args):
+ def reduce_arguments(self, args: ArgumentNode, resolve_key_nodes: bool = True) -> T.Tuple[T.List[TYPE_nvar], TYPE_nkwargs]:
if isinstance(args, ArgumentNode):
+ kwargs = {} # type: T.Dict[T.Union[str, BaseNode], TYPE_nvar]
+ for key, val in args.kwargs.items():
+ if isinstance(key, (StringNode, IdNode)):
+ assert isinstance(key.value, str)
+ kwargs[key.value] = val
+ else:
+ kwargs[key] = val
if args.incorrect_order():
raise InvalidArguments('All keyword arguments must be after positional arguments.')
- return self.flatten_args(args.arguments), args.kwargs
+ return self.flatten_args(args.arguments), kwargs
else:
return self.flatten_args(args), {}
- def evaluate_comparison(self, node):
+ def evaluate_comparison(self, node: ComparisonNode) -> bool:
self.evaluate_statement(node.left)
self.evaluate_statement(node.right)
return False
- def evaluate_andstatement(self, cur):
+ def evaluate_andstatement(self, cur: AndNode) -> bool:
self.evaluate_statement(cur.left)
self.evaluate_statement(cur.right)
return False
- def evaluate_orstatement(self, cur):
+ def evaluate_orstatement(self, cur: OrNode) -> bool:
self.evaluate_statement(cur.left)
self.evaluate_statement(cur.right)
return False
- def evaluate_foreach(self, node):
+ def evaluate_foreach(self, node: ForeachClauseNode) -> None:
try:
self.evaluate_codeblock(node.block)
except ContinueRequest:
@@ -230,30 +243,31 @@ class AstInterpreter(interpreterbase.InterpreterBase):
except BreakRequest:
pass
- def evaluate_if(self, node):
+ def evaluate_if(self, node: IfClauseNode) -> None:
for i in node.ifs:
self.evaluate_codeblock(i.block)
if not isinstance(node.elseblock, EmptyNode):
self.evaluate_codeblock(node.elseblock)
- def get_variable(self, varname):
+ def get_variable(self, varname: str) -> int:
return 0
- def assignment(self, node):
+ def assignment(self, node: AssignmentNode) -> None:
assert(isinstance(node, AssignmentNode))
- self.assignments[node.var_name] = [node.value] # Save a reference to the value node
- if hasattr(node.value, 'ast_id'):
+ self.assignments[node.var_name] = node.value # Save a reference to the value node
+ if node.value.ast_id:
self.reverse_assignment[node.value.ast_id] = node
- self.assign_vals[node.var_name] = [self.evaluate_statement(node.value)] # Evaluate the value just in case
+ self.assign_vals[node.var_name] = self.evaluate_statement(node.value) # Evaluate the value just in case
def resolve_node(self, node: BaseNode, include_unknown_args: bool = False, id_loop_detect: T.Optional[T.List[str]] = None) -> T.Optional[T.Any]:
def quick_resolve(n: BaseNode, loop_detect: T.Optional[T.List[str]] = None) -> T.Any:
if loop_detect is None:
loop_detect = []
if isinstance(n, IdNode):
+ assert isinstance(n.value, str)
if n.value in loop_detect or n.value not in self.assignments:
return []
- return quick_resolve(self.assignments[n.value][0], loop_detect = loop_detect + [n.value])
+ return quick_resolve(self.assignments[n.value], loop_detect = loop_detect + [n.value])
elif isinstance(n, ElementaryNode):
return n.value
else:
@@ -266,7 +280,7 @@ class AstInterpreter(interpreterbase.InterpreterBase):
if not isinstance(node, BaseNode):
return None
- assert(hasattr(node, 'ast_id'))
+ assert node.ast_id
if node.ast_id in id_loop_detect:
return None # Loop detected
id_loop_detect += [node.ast_id]
@@ -296,7 +310,7 @@ class AstInterpreter(interpreterbase.InterpreterBase):
elif isinstance(node, MethodNode):
src = quick_resolve(node.source_object)
- margs = self.flatten_args(node.args, include_unknown_args, id_loop_detect)
+ margs = self.flatten_args(node.args.arguments, include_unknown_args, id_loop_detect)
try:
if isinstance(src, str):
result = self.string_method_call(src, node.name, margs)
@@ -315,7 +329,7 @@ class AstInterpreter(interpreterbase.InterpreterBase):
if isinstance(result, BaseNode):
result = self.resolve_node(result, include_unknown_args, id_loop_detect)
elif isinstance(result, list):
- new_res = []
+ new_res = [] # type: T.List[TYPE_nvar]
for i in result:
if isinstance(i, BaseNode):
resolved = self.resolve_node(i, include_unknown_args, id_loop_detect)
@@ -327,12 +341,14 @@ class AstInterpreter(interpreterbase.InterpreterBase):
return result
- def flatten_args(self, args: T.Any, include_unknown_args: bool = False, id_loop_detect: T.Optional[T.List[str]] = None) -> T.List[T.Any]:
+ def flatten_args(self, args_raw: T.Union[TYPE_nvar, T.Sequence[TYPE_nvar]], include_unknown_args: bool = False, id_loop_detect: T.Optional[T.List[str]] = None) -> T.List[TYPE_nvar]:
# Make sure we are always dealing with lists
- if not isinstance(args, list):
- args = [args]
+ if isinstance(args_raw, list):
+ args = args_raw
+ else:
+ args = [args_raw]
- flattend_args = []
+ flattend_args = [] # type: T.List[TYPE_nvar]
# Resolve the contents of args
for i in args:
@@ -346,7 +362,7 @@ class AstInterpreter(interpreterbase.InterpreterBase):
flattend_args += [i]
return flattend_args
- def flatten_kwargs(self, kwargs: object, include_unknown_args: bool = False):
+ def flatten_kwargs(self, kwargs: T.Dict[str, TYPE_nvar], include_unknown_args: bool = False) -> T.Dict[str, TYPE_nvar]:
flattend_kwargs = {}
for key, val in kwargs.items():
if isinstance(val, BaseNode):
diff --git a/mesonbuild/ast/introspection.py b/mesonbuild/ast/introspection.py
index 709dbac..c9a51bf 100644
--- a/mesonbuild/ast/introspection.py
+++ b/mesonbuild/ast/introspection.py
@@ -15,30 +15,40 @@
# This class contains the basic functionality needed to run any interpreter
# or an interpreter-based tool
-from . import AstInterpreter
+from .interpreter import AstInterpreter
+from .visitor import AstVisitor
from .. import compilers, environment, mesonlib, optinterpreter
from .. import coredata as cdata
from ..mesonlib import MachineChoice
-from ..interpreterbase import InvalidArguments
+from ..interpreterbase import InvalidArguments, TYPE_nvar
from ..build import Executable, Jar, SharedLibrary, SharedModule, StaticLibrary
from ..mparser import BaseNode, ArithmeticNode, ArrayNode, ElementaryNode, IdNode, FunctionNode, StringNode
+import typing as T
import os
build_target_functions = ['executable', 'jar', 'library', 'shared_library', 'shared_module', 'static_library', 'both_libraries']
class IntrospectionHelper:
# mimic an argparse namespace
- def __init__(self, cross_file):
- self.cross_file = cross_file
- self.native_file = None
- self.cmd_line_options = {}
+ def __init__(self, cross_file: str):
+ self.cross_file = cross_file # type: str
+ self.native_file = None # type: str
+ self.cmd_line_options = {} # type: T.Dict[str, str]
class IntrospectionInterpreter(AstInterpreter):
# Interpreter to detect the options without a build directory
# Most of the code is stolen from interpreter.Interpreter
- def __init__(self, source_root, subdir, backend, visitors=None, cross_file=None, subproject='', subproject_dir='subprojects', env=None):
+ def __init__(self,
+ source_root: str,
+ subdir: str,
+ backend: str,
+ visitors: T.Optional[T.List[AstVisitor]] = None,
+ cross_file: T.Optional[str] = None,
+ subproject: str = '',
+ subproject_dir: str = 'subprojects',
+ env: T.Optional[environment.Environment] = None):
visitors = visitors if visitors is not None else []
- super().__init__(source_root, subdir, visitors=visitors)
+ super().__init__(source_root, subdir, subproject, visitors=visitors)
options = IntrospectionHelper(cross_file)
self.cross_file = cross_file
@@ -46,16 +56,15 @@ class IntrospectionInterpreter(AstInterpreter):
self.environment = environment.Environment(source_root, None, options)
else:
self.environment = env
- self.subproject = subproject
self.subproject_dir = subproject_dir
self.coredata = self.environment.get_coredata()
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 = {}
- self.targets = []
- self.dependencies = []
- self.project_node = None
+ 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({
'add_languages': self.func_add_languages,
@@ -70,7 +79,7 @@ class IntrospectionInterpreter(AstInterpreter):
'both_libraries': self.func_both_lib,
})
- def func_project(self, node, args, kwargs):
+ 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
@@ -99,7 +108,8 @@ class IntrospectionInterpreter(AstInterpreter):
if not self.is_subproject() and 'subproject_dir' in kwargs:
spdirname = kwargs['subproject_dir']
- if isinstance(spdirname, ElementaryNode):
+ if isinstance(spdirname, StringNode):
+ assert isinstance(spdirname.value, str)
self.subproject_dir = spdirname.value
if not self.is_subproject():
self.project_data['subprojects'] = []
@@ -115,7 +125,7 @@ class IntrospectionInterpreter(AstInterpreter):
self.coredata.set_options(options)
self.func_add_languages(None, proj_langs, None)
- def do_subproject(self, dirname):
+ def do_subproject(self, dirname: str) -> None:
subproject_dir_abs = os.path.join(self.environment.get_source_dir(), self.subproject_dir)
subpr = os.path.join(subproject_dir_abs, dirname)
try:
@@ -126,15 +136,20 @@ class IntrospectionInterpreter(AstInterpreter):
except (mesonlib.MesonException, RuntimeError):
return
- def func_add_languages(self, node, args, kwargs):
+ 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):
+ if isinstance(lang, StringNode):
+ assert isinstance(lang.value, str)
+ lang = lang.value
+ if not isinstance(lang, str):
+ continue
lang = lang.lower()
if lang not in self.coredata.compilers[for_machine]:
self.environment.detect_compiler_for(lang, for_machine)
- def func_dependency(self, node, args, kwargs):
+ 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:
@@ -145,7 +160,6 @@ class IntrospectionInterpreter(AstInterpreter):
version = kwargs.get('version', [])
if not isinstance(version, list):
version = [version]
- condition_level = node.condition_level if hasattr(node, 'condition_level') else 0
if isinstance(required, ElementaryNode):
required = required.value
if not isinstance(required, bool):
@@ -155,24 +169,24 @@ class IntrospectionInterpreter(AstInterpreter):
'required': required,
'version': version,
'has_fallback': has_fallback,
- 'conditional': condition_level > 0,
- 'node': node,
+ 'conditional': node.condition_level > 0,
+ 'node': node
}]
- def build_target(self, node, args, kwargs, targetclass):
+ 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
+ return None
name = args[0]
srcqueue = [node]
# Process the sources BEFORE flattening the kwargs, to preserve the original nodes
- if 'sources' in kwargs:
- srcqueue += mesonlib.listify(kwargs['sources'])
+ if 'sources' in kwargs_raw:
+ srcqueue += mesonlib.listify(kwargs_raw['sources'])
- kwargs = self.flatten_kwargs(kwargs, True)
+ kwargs = self.flatten_kwargs(kwargs_raw, True)
- source_nodes = []
+ source_nodes = [] # type: T.List[BaseNode]
while srcqueue:
curr = srcqueue.pop(0)
arg_node = None
@@ -183,9 +197,10 @@ class IntrospectionInterpreter(AstInterpreter):
arg_node = curr.args
elif isinstance(curr, IdNode):
# Try to resolve the ID and append the node to the queue
+ assert isinstance(curr.value, str)
var_name = curr.value
- if var_name in self.assignments and self.assignments[var_name]:
- tmp_node = self.assignments[var_name][0]
+ if var_name in self.assignments:
+ tmp_node = self.assignments[var_name]
if isinstance(tmp_node, (ArrayNode, IdNode, FunctionNode)):
srcqueue += [tmp_node]
elif isinstance(curr, ArithmeticNode):
@@ -206,8 +221,9 @@ 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 = []
- empty_sources = [] # Passing the unresolved sources list causes errors
+ 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)
new_target = {
@@ -227,7 +243,7 @@ class IntrospectionInterpreter(AstInterpreter):
self.targets += [new_target]
return new_target
- def build_library(self, node, args, kwargs):
+ 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)
@@ -235,31 +251,32 @@ class IntrospectionInterpreter(AstInterpreter):
return self.build_target(node, args, kwargs, StaticLibrary)
elif default_library == 'both':
return self.build_target(node, args, kwargs, SharedLibrary)
+ return None
- def func_executable(self, node, args, kwargs):
+ 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, args, kwargs):
+ 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, args, kwargs):
+ 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, args, kwargs):
+ 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, args, kwargs):
+ 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, args, kwargs):
+ 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, args, kwargs):
+ 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, args, kwargs):
+ 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
+ return None
target_type = kwargs.pop('target_type')
if isinstance(target_type, ElementaryNode):
target_type = target_type.value
@@ -275,11 +292,12 @@ class IntrospectionInterpreter(AstInterpreter):
return self.build_library(node, args, kwargs)
elif target_type == 'jar':
return self.build_target(node, args, kwargs, Jar)
+ return None
- def is_subproject(self):
+ def is_subproject(self) -> bool:
return self.subproject != ''
- def analyze(self):
+ def analyze(self) -> None:
self.load_root_meson_file()
self.sanity_check_ast()
self.parse_project()
diff --git a/mesonbuild/ast/postprocess.py b/mesonbuild/ast/postprocess.py
index 8e8732f..35fe1d3 100644
--- a/mesonbuild/ast/postprocess.py
+++ b/mesonbuild/ast/postprocess.py
@@ -17,48 +17,49 @@
from . import AstVisitor
from .. import mparser
+import typing as T
class AstIndentationGenerator(AstVisitor):
def __init__(self):
self.level = 0
- def visit_default_func(self, node: mparser.BaseNode):
+ def visit_default_func(self, node: mparser.BaseNode) -> None:
# Store the current level in the node
node.level = self.level
- def visit_ArrayNode(self, node: mparser.ArrayNode):
+ def visit_ArrayNode(self, node: mparser.ArrayNode) -> None:
self.visit_default_func(node)
self.level += 1
node.args.accept(self)
self.level -= 1
- def visit_DictNode(self, node: mparser.DictNode):
+ def visit_DictNode(self, node: mparser.DictNode) -> None:
self.visit_default_func(node)
self.level += 1
node.args.accept(self)
self.level -= 1
- def visit_MethodNode(self, node: mparser.MethodNode):
+ def visit_MethodNode(self, node: mparser.MethodNode) -> None:
self.visit_default_func(node)
node.source_object.accept(self)
self.level += 1
node.args.accept(self)
self.level -= 1
- def visit_FunctionNode(self, node: mparser.FunctionNode):
+ def visit_FunctionNode(self, node: mparser.FunctionNode) -> None:
self.visit_default_func(node)
self.level += 1
node.args.accept(self)
self.level -= 1
- def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode):
+ def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode) -> None:
self.visit_default_func(node)
self.level += 1
node.items.accept(self)
node.block.accept(self)
self.level -= 1
- def visit_IfClauseNode(self, node: mparser.IfClauseNode):
+ def visit_IfClauseNode(self, node: mparser.IfClauseNode) -> None:
self.visit_default_func(node)
for i in node.ifs:
i.accept(self)
@@ -67,7 +68,7 @@ class AstIndentationGenerator(AstVisitor):
node.elseblock.accept(self)
self.level -= 1
- def visit_IfNode(self, node: mparser.IfNode):
+ def visit_IfNode(self, node: mparser.IfNode) -> None:
self.visit_default_func(node)
self.level += 1
node.condition.accept(self)
@@ -76,9 +77,9 @@ class AstIndentationGenerator(AstVisitor):
class AstIDGenerator(AstVisitor):
def __init__(self):
- self.counter = {}
+ self.counter = {} # type: T.Dict[str, int]
- def visit_default_func(self, node: mparser.BaseNode):
+ def visit_default_func(self, node: mparser.BaseNode) -> None:
name = type(node).__name__
if name not in self.counter:
self.counter[name] = 0
@@ -89,17 +90,17 @@ class AstConditionLevel(AstVisitor):
def __init__(self):
self.condition_level = 0
- def visit_default_func(self, node: mparser.BaseNode):
+ def visit_default_func(self, node: mparser.BaseNode) -> None:
node.condition_level = self.condition_level
- def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode):
+ def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode) -> None:
self.visit_default_func(node)
self.condition_level += 1
node.items.accept(self)
node.block.accept(self)
self.condition_level -= 1
- def visit_IfClauseNode(self, node: mparser.IfClauseNode):
+ def visit_IfClauseNode(self, node: mparser.IfClauseNode) -> None:
self.visit_default_func(node)
for i in node.ifs:
i.accept(self)
@@ -108,7 +109,7 @@ class AstConditionLevel(AstVisitor):
node.elseblock.accept(self)
self.condition_level -= 1
- def visit_IfNode(self, node: mparser.IfNode):
+ def visit_IfNode(self, node: mparser.IfNode) -> None:
self.visit_default_func(node)
self.condition_level += 1
node.condition.accept(self)
diff --git a/mesonbuild/ast/printer.py b/mesonbuild/ast/printer.py
index f245a36..39e2cca 100644
--- a/mesonbuild/ast/printer.py
+++ b/mesonbuild/ast/printer.py
@@ -36,114 +36,111 @@ class AstPrinter(AstVisitor):
self.is_newline = True
self.last_level = 0
- def post_process(self):
+ def post_process(self) -> None:
self.result = re.sub(r'\s+\n', '\n', self.result)
- def append(self, data: str, node: mparser.BaseNode):
- level = 0
- if node and hasattr(node, 'level'):
- level = node.level
- else:
- level = self.last_level
- self.last_level = level
+ def append(self, data: str, node: mparser.BaseNode) -> None:
+ self.last_level = node.level
if self.is_newline:
- self.result += ' ' * (level * self.indent)
+ self.result += ' ' * (node.level * self.indent)
self.result += data
self.is_newline = False
- def append_padded(self, data: str, node: mparser.BaseNode):
+ def append_padded(self, data: str, node: mparser.BaseNode) -> None:
if self.result[-1] not in [' ', '\n']:
data = ' ' + data
self.append(data + ' ', node)
- def newline(self):
+ def newline(self) -> None:
self.result += '\n'
self.is_newline = True
- def visit_BooleanNode(self, node: mparser.BooleanNode):
+ def visit_BooleanNode(self, node: mparser.BooleanNode) -> None:
self.append('true' if node.value else 'false', node)
- def visit_IdNode(self, node: mparser.IdNode):
+ def visit_IdNode(self, node: mparser.IdNode) -> None:
+ assert isinstance(node.value, str)
self.append(node.value, node)
- def visit_NumberNode(self, node: mparser.NumberNode):
+ def visit_NumberNode(self, node: mparser.NumberNode) -> None:
self.append(str(node.value), node)
- def visit_StringNode(self, node: mparser.StringNode):
+ def visit_StringNode(self, node: mparser.StringNode) -> None:
+ assert isinstance(node.value, str)
self.append("'" + node.value + "'", node)
- def visit_ContinueNode(self, node: mparser.ContinueNode):
+ def visit_ContinueNode(self, node: mparser.ContinueNode) -> None:
self.append('continue', node)
- def visit_BreakNode(self, node: mparser.BreakNode):
+ def visit_BreakNode(self, node: mparser.BreakNode) -> None:
self.append('break', node)
- def visit_ArrayNode(self, node: mparser.ArrayNode):
+ def visit_ArrayNode(self, node: mparser.ArrayNode) -> None:
self.append('[', node)
node.args.accept(self)
self.append(']', node)
- def visit_DictNode(self, node: mparser.DictNode):
+ def visit_DictNode(self, node: mparser.DictNode) -> None:
self.append('{', node)
node.args.accept(self)
self.append('}', node)
- def visit_OrNode(self, node: mparser.OrNode):
+ def visit_OrNode(self, node: mparser.OrNode) -> None:
node.left.accept(self)
self.append_padded('or', node)
node.right.accept(self)
- def visit_AndNode(self, node: mparser.AndNode):
+ def visit_AndNode(self, node: mparser.AndNode) -> None:
node.left.accept(self)
self.append_padded('and', node)
node.right.accept(self)
- def visit_ComparisonNode(self, node: mparser.ComparisonNode):
+ def visit_ComparisonNode(self, node: mparser.ComparisonNode) -> None:
node.left.accept(self)
self.append_padded(node.ctype, node)
node.right.accept(self)
- def visit_ArithmeticNode(self, node: mparser.ArithmeticNode):
+ def visit_ArithmeticNode(self, node: mparser.ArithmeticNode) -> None:
node.left.accept(self)
self.append_padded(arithmic_map[node.operation], node)
node.right.accept(self)
- def visit_NotNode(self, node: mparser.NotNode):
+ def visit_NotNode(self, node: mparser.NotNode) -> None:
self.append_padded('not', node)
node.value.accept(self)
- def visit_CodeBlockNode(self, node: mparser.CodeBlockNode):
+ def visit_CodeBlockNode(self, node: mparser.CodeBlockNode) -> None:
for i in node.lines:
i.accept(self)
self.newline()
- def visit_IndexNode(self, node: mparser.IndexNode):
+ def visit_IndexNode(self, node: mparser.IndexNode) -> None:
node.iobject.accept(self)
self.append('[', node)
node.index.accept(self)
self.append(']', node)
- def visit_MethodNode(self, node: mparser.MethodNode):
+ def visit_MethodNode(self, node: mparser.MethodNode) -> None:
node.source_object.accept(self)
self.append('.' + node.name + '(', node)
node.args.accept(self)
self.append(')', node)
- def visit_FunctionNode(self, node: mparser.FunctionNode):
+ def visit_FunctionNode(self, node: mparser.FunctionNode) -> None:
self.append(node.func_name + '(', node)
node.args.accept(self)
self.append(')', node)
- def visit_AssignmentNode(self, node: mparser.AssignmentNode):
+ def visit_AssignmentNode(self, node: mparser.AssignmentNode) -> None:
self.append(node.var_name + ' = ', node)
node.value.accept(self)
- def visit_PlusAssignmentNode(self, node: mparser.PlusAssignmentNode):
+ def visit_PlusAssignmentNode(self, node: mparser.PlusAssignmentNode) -> None:
self.append(node.var_name + ' += ', node)
node.value.accept(self)
- def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode):
- varnames = [x.value for x in node.varnames]
+ def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode) -> None:
+ varnames = [x for x in node.varnames]
self.append_padded('foreach', node)
self.append_padded(', '.join(varnames), node)
self.append_padded(':', node)
@@ -152,7 +149,7 @@ class AstPrinter(AstVisitor):
node.block.accept(self)
self.append('endforeach', node)
- def visit_IfClauseNode(self, node: mparser.IfClauseNode):
+ def visit_IfClauseNode(self, node: mparser.IfClauseNode) -> None:
prefix = ''
for i in node.ifs:
self.append_padded(prefix + 'if', node)
@@ -163,23 +160,23 @@ class AstPrinter(AstVisitor):
node.elseblock.accept(self)
self.append('endif', node)
- def visit_UMinusNode(self, node: mparser.UMinusNode):
+ def visit_UMinusNode(self, node: mparser.UMinusNode) -> None:
self.append_padded('-', node)
node.value.accept(self)
- def visit_IfNode(self, node: mparser.IfNode):
+ def visit_IfNode(self, node: mparser.IfNode) -> None:
node.condition.accept(self)
self.newline()
node.block.accept(self)
- def visit_TernaryNode(self, node: mparser.TernaryNode):
+ def visit_TernaryNode(self, node: mparser.TernaryNode) -> None:
node.condition.accept(self)
self.append_padded('?', node)
node.trueblock.accept(self)
self.append_padded(':', node)
node.falseblock.accept(self)
- def visit_ArgumentNode(self, node: mparser.ArgumentNode):
+ def visit_ArgumentNode(self, node: mparser.ArgumentNode) -> None:
break_args = (len(node.arguments) + len(node.kwargs)) > self.arg_newline_cutoff
for i in node.arguments + list(node.kwargs.values()):
if not isinstance(i, (mparser.ElementaryNode, mparser.IndexNode)):
@@ -192,10 +189,7 @@ class AstPrinter(AstVisitor):
if break_args:
self.newline()
for key, val in node.kwargs.items():
- if isinstance(key, str):
- self.append(key, node)
- else:
- key.accept(self)
+ key.accept(self)
self.append_padded(':', node)
val.accept(self)
self.append(', ', node)
diff --git a/mesonbuild/ast/visitor.py b/mesonbuild/ast/visitor.py
index de13dae..37be463 100644
--- a/mesonbuild/ast/visitor.py
+++ b/mesonbuild/ast/visitor.py
@@ -21,119 +21,120 @@ class AstVisitor:
def __init__(self):
pass
- def visit_default_func(self, node: mparser.BaseNode):
+ def visit_default_func(self, node: mparser.BaseNode) -> None:
pass
- def visit_BooleanNode(self, node: mparser.BooleanNode):
+ def visit_BooleanNode(self, node: mparser.BooleanNode) -> None:
self.visit_default_func(node)
- def visit_IdNode(self, node: mparser.IdNode):
+ def visit_IdNode(self, node: mparser.IdNode) -> None:
self.visit_default_func(node)
- def visit_NumberNode(self, node: mparser.NumberNode):
+ def visit_NumberNode(self, node: mparser.NumberNode) -> None:
self.visit_default_func(node)
- def visit_StringNode(self, node: mparser.StringNode):
+ def visit_StringNode(self, node: mparser.StringNode) -> None:
self.visit_default_func(node)
- def visit_ContinueNode(self, node: mparser.ContinueNode):
+ def visit_ContinueNode(self, node: mparser.ContinueNode) -> None:
self.visit_default_func(node)
- def visit_BreakNode(self, node: mparser.BreakNode):
+ def visit_BreakNode(self, node: mparser.BreakNode) -> None:
self.visit_default_func(node)
- def visit_ArrayNode(self, node: mparser.ArrayNode):
+ def visit_ArrayNode(self, node: mparser.ArrayNode) -> None:
self.visit_default_func(node)
node.args.accept(self)
- def visit_DictNode(self, node: mparser.DictNode):
+ def visit_DictNode(self, node: mparser.DictNode) -> None:
self.visit_default_func(node)
node.args.accept(self)
- def visit_EmptyNode(self, node: mparser.EmptyNode):
+ def visit_EmptyNode(self, node: mparser.EmptyNode) -> None:
self.visit_default_func(node)
- def visit_OrNode(self, node: mparser.OrNode):
+ def visit_OrNode(self, node: mparser.OrNode) -> None:
self.visit_default_func(node)
node.left.accept(self)
node.right.accept(self)
- def visit_AndNode(self, node: mparser.AndNode):
+ def visit_AndNode(self, node: mparser.AndNode) -> None:
self.visit_default_func(node)
node.left.accept(self)
node.right.accept(self)
- def visit_ComparisonNode(self, node: mparser.ComparisonNode):
+ def visit_ComparisonNode(self, node: mparser.ComparisonNode) -> None:
self.visit_default_func(node)
node.left.accept(self)
node.right.accept(self)
- def visit_ArithmeticNode(self, node: mparser.ArithmeticNode):
+ def visit_ArithmeticNode(self, node: mparser.ArithmeticNode) -> None:
self.visit_default_func(node)
node.left.accept(self)
node.right.accept(self)
- def visit_NotNode(self, node: mparser.NotNode):
+ def visit_NotNode(self, node: mparser.NotNode) -> None:
self.visit_default_func(node)
node.value.accept(self)
- def visit_CodeBlockNode(self, node: mparser.CodeBlockNode):
+ def visit_CodeBlockNode(self, node: mparser.CodeBlockNode) -> None:
self.visit_default_func(node)
for i in node.lines:
i.accept(self)
- def visit_IndexNode(self, node: mparser.IndexNode):
+ def visit_IndexNode(self, node: mparser.IndexNode) -> None:
self.visit_default_func(node)
node.iobject.accept(self)
node.index.accept(self)
- def visit_MethodNode(self, node: mparser.MethodNode):
+ def visit_MethodNode(self, node: mparser.MethodNode) -> None:
self.visit_default_func(node)
node.source_object.accept(self)
node.args.accept(self)
- def visit_FunctionNode(self, node: mparser.FunctionNode):
+ def visit_FunctionNode(self, node: mparser.FunctionNode) -> None:
self.visit_default_func(node)
node.args.accept(self)
- def visit_AssignmentNode(self, node: mparser.AssignmentNode):
+ def visit_AssignmentNode(self, node: mparser.AssignmentNode) -> None:
self.visit_default_func(node)
node.value.accept(self)
- def visit_PlusAssignmentNode(self, node: mparser.PlusAssignmentNode):
+ def visit_PlusAssignmentNode(self, node: mparser.PlusAssignmentNode) -> None:
self.visit_default_func(node)
node.value.accept(self)
- def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode):
+ def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode) -> None:
self.visit_default_func(node)
node.items.accept(self)
node.block.accept(self)
- def visit_IfClauseNode(self, node: mparser.IfClauseNode):
+ def visit_IfClauseNode(self, node: mparser.IfClauseNode) -> None:
self.visit_default_func(node)
for i in node.ifs:
i.accept(self)
if node.elseblock:
node.elseblock.accept(self)
- def visit_UMinusNode(self, node: mparser.UMinusNode):
+ def visit_UMinusNode(self, node: mparser.UMinusNode) -> None:
self.visit_default_func(node)
node.value.accept(self)
- def visit_IfNode(self, node: mparser.IfNode):
+ def visit_IfNode(self, node: mparser.IfNode) -> None:
self.visit_default_func(node)
node.condition.accept(self)
node.block.accept(self)
- def visit_TernaryNode(self, node: mparser.TernaryNode):
+ def visit_TernaryNode(self, node: mparser.TernaryNode) -> None:
self.visit_default_func(node)
node.condition.accept(self)
node.trueblock.accept(self)
node.falseblock.accept(self)
- def visit_ArgumentNode(self, node: mparser.ArgumentNode):
+ def visit_ArgumentNode(self, node: mparser.ArgumentNode) -> None:
self.visit_default_func(node)
for i in node.arguments:
i.accept(self)
- for val in node.kwargs.values():
+ for key, val in node.kwargs.items():
+ key.accept(self)
val.accept(self)
generated by cgit v1.1 at 2025-07-10 21:57:43 +0000