Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/jinja2/idtracking.py: 26%

1import typing as t 

2 

3from . import nodes 

4from .visitor import NodeVisitor 

5 

6VAR_LOAD_PARAMETER = "param" 

7VAR_LOAD_RESOLVE = "resolve" 

8VAR_LOAD_ALIAS = "alias" 

9VAR_LOAD_UNDEFINED = "undefined" 

10 

11 

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 

20 

21 

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 

28 

29 

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 

39 

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() 

45 

46 def analyze_node(self, node: nodes.Node, **kwargs: t.Any) -> None: 

47 visitor = RootVisitor(self) 

48 visitor.visit(node, **kwargs) 

49 

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 

58 

59 def find_load(self, target: str) -> t.Optional[t.Any]: 

60 if target in self.loads: 

61 return self.loads[target] 

62 

63 if self.parent is not None: 

64 return self.parent.find_load(target) 

65 

66 return None 

67 

68 def find_ref(self, name: str) -> t.Optional[str]: 

69 if name in self.refs: 

70 return self.refs[name] 

71 

72 if self.parent is not None: 

73 return self.parent.find_ref(name) 

74 

75 return None 

76 

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 

85 

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 

93 

94 def store(self, name: str) -> None: 

95 self.stores.add(name) 

96 

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 

108 

109 # Otherwise we can just set it to undefined. 

110 self._define_ref(name, load=(VAR_LOAD_UNDEFINED, None)) 

111 

112 def declare_parameter(self, name: str) -> str: 

113 self.stores.add(name) 

114 return self._define_ref(name, load=(VAR_LOAD_PARAMETER, None)) 

115 

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)) 

119 

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 

127 

128 for sym in branch_symbols: 

129 self.refs.update(sym.refs) 

130 self.loads.update(sym.loads) 

131 self.stores.update(sym.stores) 

132 

133 for name, branch_count in stores.items(): 

134 if branch_count == len(branch_symbols): 

135 continue 

136 

137 target = self.find_ref(name) # type: ignore 

138 assert target is not None, "should not happen" 

139 

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) 

146 

147 def dump_stores(self) -> t.Dict[str, str]: 

148 rv: t.Dict[str, str] = {} 

149 node: t.Optional["Symbols"] = self 

150 

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 

155 

156 node = node.parent 

157 

158 return rv 

159 

160 def dump_param_targets(self) -> t.Set[str]: 

161 rv = set() 

162 node: t.Optional["Symbols"] = self 

163 

164 while node is not None: 

165 for target, (instr, _) in self.loads.items(): 

166 if instr == VAR_LOAD_PARAMETER: 

167 rv.add(target) 

168 

169 node = node.parent 

170 

171 return rv 

172 

173 

174class RootVisitor(NodeVisitor): 

175 def __init__(self, symbols: "Symbols") -> None: 

176 self.sym_visitor = FrameSymbolVisitor(symbols) 

177 

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) 

181 

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 

189 

190 def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) -> None: 

191 for child in node.body: 

192 self.sym_visitor.visit(child) 

193 

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) 

197 

198 def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any) -> None: 

199 for child in node.body: 

200 self.sym_visitor.visit(child) 

201 

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") 

217 

218 if branch: 

219 for item in branch: 

220 self.sym_visitor.visit(item) 

221 

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) 

227 

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}") 

230 

231 

232class FrameSymbolVisitor(NodeVisitor): 

233 """A visitor for `Frame.inspect`.""" 

234 

235 def __init__(self, symbols: "Symbols") -> None: 

236 self.symbols = symbols 

237 

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) 

248 

249 def visit_NSRef(self, node: nodes.NSRef, **kwargs: t.Any) -> None: 

250 self.symbols.load(node.name) 

251 

252 def visit_If(self, node: nodes.If, **kwargs: t.Any) -> None: 

253 self.visit(node.test, **kwargs) 

254 original_symbols = self.symbols 

255 

256 def inner_visit(nodes: t.Iterable[nodes.Node]) -> "Symbols": 

257 self.symbols = rv = original_symbols.copy() 

258 

259 for subnode in nodes: 

260 self.visit(subnode, **kwargs) 

261 

262 self.symbols = original_symbols 

263 return rv 

264 

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]) 

269 

270 def visit_Macro(self, node: nodes.Macro, **kwargs: t.Any) -> None: 

271 self.symbols.store(node.name) 

272 

273 def visit_Import(self, node: nodes.Import, **kwargs: t.Any) -> None: 

274 self.generic_visit(node, **kwargs) 

275 self.symbols.store(node.target) 

276 

277 def visit_FromImport(self, node: nodes.FromImport, **kwargs: t.Any) -> None: 

278 self.generic_visit(node, **kwargs) 

279 

280 for name in node.names: 

281 if isinstance(name, tuple): 

282 self.symbols.store(name[1]) 

283 else: 

284 self.symbols.store(name) 

285 

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) 

290 

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) 

296 

297 def visit_CallBlock(self, node: nodes.CallBlock, **kwargs: t.Any) -> None: 

298 self.visit(node.call, **kwargs) 

299 

300 def visit_FilterBlock(self, node: nodes.FilterBlock, **kwargs: t.Any) -> None: 

301 self.visit(node.filter, **kwargs) 

302 

303 def visit_With(self, node: nodes.With, **kwargs: t.Any) -> None: 

304 for target in node.values: 

305 self.visit(target) 

306 

307 def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) -> None: 

308 """Stop visiting at block assigns.""" 

309 self.visit(node.target, **kwargs) 

310 

311 def visit_Scope(self, node: nodes.Scope, **kwargs: t.Any) -> None: 

312 """Stop visiting at scopes.""" 

313 

314 def visit_Block(self, node: nodes.Block, **kwargs: t.Any) -> None: 

315 """Stop visiting at blocks.""" 

316 

317 def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any) -> None: 

318 """Do not visit into overlay scopes."""