Coverage for /var/srv/projects/api.amasfac.comuna18.com/tmp/venv/lib/python3.9/site-packages/jinja2/idtracking.py: 20%
213 statements
« prev ^ index » next coverage.py v6.4.4, created at 2023-07-17 14:22 -0600
1import typing as t
3from . import nodes
4from .visitor import NodeVisitor
6VAR_LOAD_PARAMETER = "param"
7VAR_LOAD_RESOLVE = "resolve"
8VAR_LOAD_ALIAS = "alias"
9VAR_LOAD_UNDEFINED = "undefined"
12def find_symbols(
13 nodes: t.Iterable[nodes.Node], parent_symbols: t.Optional["Symbols"] = None
14) -> "Symbols":
15 sym = Symbols(parent=parent_symbols)
16 visitor = FrameSymbolVisitor(sym)
17 for node in nodes:
18 visitor.visit(node)
19 return sym
22def symbols_for_node(
23 node: nodes.Node, parent_symbols: t.Optional["Symbols"] = None
24) -> "Symbols":
25 sym = Symbols(parent=parent_symbols)
26 sym.analyze_node(node)
27 return sym
30class Symbols:
31 def __init__(
32 self, parent: t.Optional["Symbols"] = None, level: t.Optional[int] = None
33 ) -> None:
34 if level is None:
35 if parent is None:
36 level = 0
37 else:
38 level = parent.level + 1
40 self.level: int = level
41 self.parent = parent
42 self.refs: t.Dict[str, str] = {}
43 self.loads: t.Dict[str, t.Any] = {}
44 self.stores: t.Set[str] = set()
46 def analyze_node(self, node: nodes.Node, **kwargs: t.Any) -> None:
47 visitor = RootVisitor(self)
48 visitor.visit(node, **kwargs)
50 def _define_ref(
51 self, name: str, load: t.Optional[t.Tuple[str, t.Optional[str]]] = None
52 ) -> str:
53 ident = f"l_{self.level}_{name}"
54 self.refs[name] = ident
55 if load is not None:
56 self.loads[ident] = load
57 return ident
59 def find_load(self, target: str) -> t.Optional[t.Any]:
60 if target in self.loads:
61 return self.loads[target]
63 if self.parent is not None:
64 return self.parent.find_load(target)
66 return None
68 def find_ref(self, name: str) -> t.Optional[str]:
69 if name in self.refs:
70 return self.refs[name]
72 if self.parent is not None:
73 return self.parent.find_ref(name)
75 return None
77 def ref(self, name: str) -> str:
78 rv = self.find_ref(name)
79 if rv is None:
80 raise AssertionError(
81 "Tried to resolve a name to a reference that was"
82 f" unknown to the frame ({name!r})"
83 )
84 return rv
86 def copy(self) -> "Symbols":
87 rv = object.__new__(self.__class__)
88 rv.__dict__.update(self.__dict__)
89 rv.refs = self.refs.copy()
90 rv.loads = self.loads.copy()
91 rv.stores = self.stores.copy()
92 return rv
94 def store(self, name: str) -> None:
95 self.stores.add(name)
97 # If we have not see the name referenced yet, we need to figure
98 # out what to set it to.
99 if name not in self.refs:
100 # If there is a parent scope we check if the name has a
101 # reference there. If it does it means we might have to alias
102 # to a variable there.
103 if self.parent is not None:
104 outer_ref = self.parent.find_ref(name)
105 if outer_ref is not None:
106 self._define_ref(name, load=(VAR_LOAD_ALIAS, outer_ref))
107 return
109 # Otherwise we can just set it to undefined.
110 self._define_ref(name, load=(VAR_LOAD_UNDEFINED, None))
112 def declare_parameter(self, name: str) -> str:
113 self.stores.add(name)
114 return self._define_ref(name, load=(VAR_LOAD_PARAMETER, None))
116 def load(self, name: str) -> None:
117 if self.find_ref(name) is None:
118 self._define_ref(name, load=(VAR_LOAD_RESOLVE, name))
120 def branch_update(self, branch_symbols: t.Sequence["Symbols"]) -> None:
121 stores: t.Dict[str, int] = {}
122 for branch in branch_symbols:
123 for target in branch.stores:
124 if target in self.stores:
125 continue
126 stores[target] = stores.get(target, 0) + 1
128 for sym in branch_symbols:
129 self.refs.update(sym.refs)
130 self.loads.update(sym.loads)
131 self.stores.update(sym.stores)
133 for name, branch_count in stores.items():
134 if branch_count == len(branch_symbols):
135 continue
137 target = self.find_ref(name) # type: ignore
138 assert target is not None, "should not happen"
140 if self.parent is not None:
141 outer_target = self.parent.find_ref(name)
142 if outer_target is not None:
143 self.loads[target] = (VAR_LOAD_ALIAS, outer_target)
144 continue
145 self.loads[target] = (VAR_LOAD_RESOLVE, name)
147 def dump_stores(self) -> t.Dict[str, str]:
148 rv: t.Dict[str, str] = {}
149 node: t.Optional["Symbols"] = self
151 while node is not None:
152 for name in sorted(node.stores):
153 if name not in rv:
154 rv[name] = self.find_ref(name) # type: ignore
156 node = node.parent
158 return rv
160 def dump_param_targets(self) -> t.Set[str]:
161 rv = set()
162 node: t.Optional["Symbols"] = self
164 while node is not None:
165 for target, (instr, _) in self.loads.items():
166 if instr == VAR_LOAD_PARAMETER:
167 rv.add(target)
169 node = node.parent
171 return rv
174class RootVisitor(NodeVisitor):
175 def __init__(self, symbols: "Symbols") -> None:
176 self.sym_visitor = FrameSymbolVisitor(symbols)
178 def _simple_visit(self, node: nodes.Node, **kwargs: t.Any) -> None:
179 for child in node.iter_child_nodes():
180 self.sym_visitor.visit(child)
182 visit_Template = _simple_visit
183 visit_Block = _simple_visit
184 visit_Macro = _simple_visit
185 visit_FilterBlock = _simple_visit
186 visit_Scope = _simple_visit
187 visit_If = _simple_visit
188 visit_ScopedEvalContextModifier = _simple_visit
190 def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) -> None:
191 for child in node.body:
192 self.sym_visitor.visit(child)
194 def visit_CallBlock(self, node: nodes.CallBlock, **kwargs: t.Any) -> None:
195 for child in node.iter_child_nodes(exclude=("call",)):
196 self.sym_visitor.visit(child)
198 def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any) -> None:
199 for child in node.body:
200 self.sym_visitor.visit(child)
202 def visit_For(
203 self, node: nodes.For, for_branch: str = "body", **kwargs: t.Any
204 ) -> None:
205 if for_branch == "body":
206 self.sym_visitor.visit(node.target, store_as_param=True)
207 branch = node.body
208 elif for_branch == "else":
209 branch = node.else_
210 elif for_branch == "test":
211 self.sym_visitor.visit(node.target, store_as_param=True)
212 if node.test is not None:
213 self.sym_visitor.visit(node.test)
214 return
215 else:
216 raise RuntimeError("Unknown for branch")
218 if branch:
219 for item in branch:
220 self.sym_visitor.visit(item)
222 def visit_With(self, node: nodes.With, **kwargs: t.Any) -> None:
223 for target in node.targets:
224 self.sym_visitor.visit(target)
225 for child in node.body:
226 self.sym_visitor.visit(child)
228 def generic_visit(self, node: nodes.Node, *args: t.Any, **kwargs: t.Any) -> None:
229 raise NotImplementedError(f"Cannot find symbols for {type(node).__name__!r}")
232class FrameSymbolVisitor(NodeVisitor):
233 """A visitor for `Frame.inspect`."""
235 def __init__(self, symbols: "Symbols") -> None:
236 self.symbols = symbols
238 def visit_Name(
239 self, node: nodes.Name, store_as_param: bool = False, **kwargs: t.Any
240 ) -> None:
241 """All assignments to names go through this function."""
242 if store_as_param or node.ctx == "param":
243 self.symbols.declare_parameter(node.name)
244 elif node.ctx == "store":
245 self.symbols.store(node.name)
246 elif node.ctx == "load":
247 self.symbols.load(node.name)
249 def visit_NSRef(self, node: nodes.NSRef, **kwargs: t.Any) -> None:
250 self.symbols.load(node.name)
252 def visit_If(self, node: nodes.If, **kwargs: t.Any) -> None:
253 self.visit(node.test, **kwargs)
254 original_symbols = self.symbols
256 def inner_visit(nodes: t.Iterable[nodes.Node]) -> "Symbols":
257 self.symbols = rv = original_symbols.copy()
259 for subnode in nodes:
260 self.visit(subnode, **kwargs)
262 self.symbols = original_symbols
263 return rv
265 body_symbols = inner_visit(node.body)
266 elif_symbols = inner_visit(node.elif_)
267 else_symbols = inner_visit(node.else_ or ())
268 self.symbols.branch_update([body_symbols, elif_symbols, else_symbols])
270 def visit_Macro(self, node: nodes.Macro, **kwargs: t.Any) -> None:
271 self.symbols.store(node.name)
273 def visit_Import(self, node: nodes.Import, **kwargs: t.Any) -> None:
274 self.generic_visit(node, **kwargs)
275 self.symbols.store(node.target)
277 def visit_FromImport(self, node: nodes.FromImport, **kwargs: t.Any) -> None:
278 self.generic_visit(node, **kwargs)
280 for name in node.names:
281 if isinstance(name, tuple):
282 self.symbols.store(name[1])
283 else:
284 self.symbols.store(name)
286 def visit_Assign(self, node: nodes.Assign, **kwargs: t.Any) -> None:
287 """Visit assignments in the correct order."""
288 self.visit(node.node, **kwargs)
289 self.visit(node.target, **kwargs)
291 def visit_For(self, node: nodes.For, **kwargs: t.Any) -> None:
292 """Visiting stops at for blocks. However the block sequence
293 is visited as part of the outer scope.
294 """
295 self.visit(node.iter, **kwargs)
297 def visit_CallBlock(self, node: nodes.CallBlock, **kwargs: t.Any) -> None:
298 self.visit(node.call, **kwargs)
300 def visit_FilterBlock(self, node: nodes.FilterBlock, **kwargs: t.Any) -> None:
301 self.visit(node.filter, **kwargs)
303 def visit_With(self, node: nodes.With, **kwargs: t.Any) -> None:
304 for target in node.values:
305 self.visit(target)
307 def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) -> None:
308 """Stop visiting at block assigns."""
309 self.visit(node.target, **kwargs)
311 def visit_Scope(self, node: nodes.Scope, **kwargs: t.Any) -> None:
312 """Stop visiting at scopes."""
314 def visit_Block(self, node: nodes.Block, **kwargs: t.Any) -> None:
315 """Stop visiting at blocks."""
317 def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any) -> None:
318 """Do not visit into overlay scopes."""