Lines Matching refs:self
45 self: "CodeGenerator", node: nodes.Expr, frame: "Frame", **kwargs: t.Any
48 if self.optimizer is not None and not frame.eval_ctx.volatile:
49 new_node = self.optimizer.visit(node, frame.eval_ctx)
52 return self.visit(new_node, frame)
54 return f(self, node, frame, **kwargs)
61 def visitor(self: "CodeGenerator", node: nodes.BinExpr, frame: Frame) -> None:
63 self.environment.sandboxed
64 and op in self.environment.intercepted_binops # type: ignore
66 self.write(f"environment.call_binop(context, {op!r}, ")
67 self.visit(node.left, frame)
68 self.write(", ")
69 self.visit(node.right, frame)
71 self.write("(")
72 self.visit(node.left, frame)
73 self.write(f" {op} ")
74 self.visit(node.right, frame)
76 self.write(")")
85 def visitor(self: "CodeGenerator", node: nodes.UnaryExpr, frame: Frame) -> None:
87 self.environment.sandboxed
88 and op in self.environment.intercepted_unops # type: ignore
90 self.write(f"environment.call_unop(context, {op!r}, ")
91 self.visit(node.node, frame)
93 self.write("(" + op)
94 self.visit(node.node, frame)
96 self.write(")")
158 def __init__(self, node: t.Union[nodes.Macro, nodes.CallBlock]) -> None:
159 self.node = node
160 self.accesses_caller = False
161 self.accesses_kwargs = False
162 self.accesses_varargs = False
169 self,
174 self.eval_ctx = eval_ctx
177 self.parent = parent
180 self.symbols = Symbols(level=level)
184 self.require_output_check = False
190 self.buffer: t.Optional[str] = None
193 self.block: t.Optional[str] = None
196 self.symbols = Symbols(parent.symbols, level=level)
197 self.require_output_check = parent.require_output_check
198 self.buffer = parent.buffer
199 self.block = parent.block
202 self.toplevel = False
207 self.rootlevel = False
211 self.loop_frame = False
212 self.block_frame = False
217 self.soft_frame = False
219 def copy(self) -> "Frame":
221 rv = object.__new__(self.__class__)
222 rv.__dict__.update(self.__dict__)
223 rv.symbols = self.symbols.copy()
226 def inner(self, isolated: bool = False) -> "Frame":
229 return Frame(self.eval_ctx, level=self.symbols.level + 1)
230 return Frame(self.eval_ctx, self)
232 def soft(self) -> "Frame":
240 rv = self.copy()
255 def __init__(self) -> None:
256 self.filters: t.Set[str] = set()
257 self.tests: t.Set[str] = set()
259 def visit_Filter(self, node: nodes.Filter) -> None:
260 self.generic_visit(node)
261 self.filters.add(node.name)
263 def visit_Test(self, node: nodes.Test) -> None:
264 self.generic_visit(node)
265 self.tests.add(node.name)
267 def visit_Block(self, node: nodes.Block) -> None:
277 def __init__(self, names: t.Iterable[str]) -> None:
278 self.names = set(names)
279 self.undeclared: t.Set[str] = set()
281 def visit_Name(self, node: nodes.Name) -> None:
282 if node.ctx == "load" and node.name in self.names:
283 self.undeclared.add(node.name)
284 if self.undeclared == self.names:
287 self.names.discard(node.name)
289 def visit_Block(self, node: nodes.Block) -> None:
302 self,
312 self.environment = environment
313 self.name = name
314 self.filename = filename
315 self.stream = stream
316 self.created_block_context = False
317 self.defer_init = defer_init
318 self.optimizer: t.Optional[Optimizer] = None
321 self.optimizer = Optimizer(environment)
324 self.import_aliases: t.Dict[str, str] = {}
328 self.blocks: t.Dict[str, nodes.Block] = {}
331 self.extends_so_far = 0
336 self.has_known_extends = False
339 self.code_lineno = 1
342 self.tests: t.Dict[str, str] = {}
343 self.filters: t.Dict[str, str] = {}
346 self.debug_info: t.List[t.Tuple[int, int]] = []
347 self._write_debug_info: t.Optional[int] = None
350 self._new_lines = 0
353 self._last_line = 0
356 self._first_write = True
360 self._last_identifier = 0
363 self._indentation = 0
366 self._assign_stack: t.List[t.Set[str]] = []
369 self._param_def_block: t.List[t.Set[str]] = []
372 self._context_reference_stack = ["context"]
375 def optimized(self) -> bool:
376 return self.optimizer is not None
380 def fail(self, msg: str, lineno: int) -> "te.NoReturn":
382 raise TemplateAssertionError(msg, lineno, self.name, self.filename)
384 def temporary_identifier(self) -> str:
386 self._last_identifier += 1
387 return f"t_{self._last_identifier}"
389 def buffer(self, frame: Frame) -> None:
391 frame.buffer = self.temporary_identifier()
392 self.writeline(f"{frame.buffer} = []")
395 self, frame: Frame, force_unescaped: bool = False
400 self.writeline("if context.eval_ctx.autoescape:")
401 self.indent()
402 self.writeline(f"return Markup(concat({frame.buffer}))")
403 self.outdent()
404 self.writeline("else:")
405 self.indent()
406 self.writeline(f"return concat({frame.buffer})")
407 self.outdent()
410 self.writeline(f"return Markup(concat({frame.buffer}))")
412 self.writeline(f"return concat({frame.buffer})")
414 def indent(self) -> None:
416 self._indentation += 1
418 def outdent(self, step: int = 1) -> None:
420 self._indentation -= step
422 def start_write(self, frame: Frame, node: t.Optional[nodes.Node] = None) -> None:
425 self.writeline("yield ", node)
427 self.writeline(f"{frame.buffer}.append(", node)
429 def end_write(self, frame: Frame) -> None:
432 self.write(")")
435 self, s: str, frame: Frame, node: t.Optional[nodes.Node] = None
438 self.start_write(frame, node)
439 self.write(s)
440 self.end_write(frame)
442 def blockvisit(self, nodes: t.Iterable[nodes.Node], frame: Frame) -> None:
447 self.writeline("pass")
449 self.visit(node, frame)
453 def write(self, x: str) -> None:
455 if self._new_lines:
456 if not self._first_write:
457 self.stream.write("\n" * self._new_lines)
458 self.code_lineno += self._new_lines
459 if self._write_debug_info is not None:
460 self.debug_info.append((self._write_debug_info, self.code_lineno))
461 self._write_debug_info = None
462 self._first_write = False
463 self.stream.write(" " * self._indentation)
464 self._new_lines = 0
465 self.stream.write(x)
468 self, x: str, node: t.Optional[nodes.Node] = None, extra: int = 0
471 self.newline(node, extra)
472 self.write(x)
474 def newline(self, node: t.Optional[nodes.Node] = None, extra: int = 0) -> None:
476 self._new_lines = max(self._new_lines, 1 + extra)
477 if node is not None and node.lineno != self._last_line:
478 self._write_debug_info = node.lineno
479 self._last_line = node.lineno
482 self,
501 self.write(", ")
502 self.visit(arg, frame)
506 self.write(", ")
507 self.visit(kwarg, frame)
510 self.write(f", {key}={value}")
512 self.write(", *")
513 self.visit(node.dyn_args, frame)
517 self.write(", **dict({")
519 self.write(", **{")
521 self.write(f"{kwarg.key!r}: ")
522 self.visit(kwarg.value, frame)
523 self.write(", ")
526 self.write(f"{key!r}: {value}, ")
528 self.write("}, **")
529 self.visit(node.dyn_kwargs, frame)
530 self.write(")")
532 self.write("}")
535 self.write(", **")
536 self.visit(node.dyn_kwargs, frame)
538 def pull_dependencies(self, nodes: t.Iterable[nodes.Node]) -> None:
554 for id_map, names, dependency in (self.filters, visitor.filters, "filters"), (
555 self.tests,
561 id_map[name] = self.temporary_identifier()
565 self.writeline("try:")
566 self.indent()
567 self.writeline(f"{id_map[name]} = environment.{dependency}[{name!r}]")
568 self.outdent()
569 self.writeline("except KeyError:")
570 self.indent()
571 self.writeline("@internalcode")
572 self.writeline(f"def {id_map[name]}(*unused):")
573 self.indent()
574 self.writeline(
578 self.outdent()
579 self.outdent()
581 def enter_frame(self, frame: Frame) -> None:
587 self.writeline(f"{target} = {self.get_resolve_func()}({param!r})")
589 self.writeline(f"{target} = {param}")
595 self.writeline(f"{' = '.join(undefs)} = missing")
597 def leave_frame(self, frame: Frame, with_python_scope: bool = False) -> None:
603 self.writeline(f"{' = '.join(undefs)} = missing")
605 def choose_async(self, async_value: str = "async ", sync_value: str = "") -> str:
606 return async_value if self.environment.is_async else sync_value
608 def func(self, name: str) -> str:
609 return f"{self.choose_async()}def {name}"
612 self, node: t.Union[nodes.Macro, nodes.CallBlock], frame: Frame
643 self.fail(
662 self.writeline(f"{self.func('macro')}({', '.join(args)}):", node)
663 self.indent()
665 self.buffer(frame)
666 self.enter_frame(frame)
668 self.push_parameter_definitions(frame)
671 self.writeline(f"if {ref} is missing:")
672 self.indent()
676 self.writeline(
681 self.writeline(f"{ref} = ")
682 self.visit(default, frame)
683 self.mark_parameter_stored(ref)
684 self.outdent()
685 self.pop_parameter_definitions()
687 self.blockvisit(node.body, frame)
688 self.return_buffer_contents(frame, force_unescaped=True)
689 self.leave_frame(frame, with_python_scope=True)
690 self.outdent()
694 def macro_def(self, macro_ref: MacroRef, frame: Frame) -> None:
700 self.write(
706 def position(self, node: nodes.Node) -> str:
709 if self.name is not None:
710 rv = f"{rv} in {self.name!r}"
713 def dump_local_context(self, frame: Frame) -> str:
720 def write_commons(self) -> None:
725 self.writeline("resolve = context.resolve_or_missing")
726 self.writeline("undefined = environment.undefined")
727 self.writeline("concat = environment.concat")
730 self.writeline("cond_expr_undefined = Undefined")
731 self.writeline("if 0: yield None")
733 def push_parameter_definitions(self, frame: Frame) -> None:
740 self._param_def_block.append(frame.symbols.dump_param_targets())
742 def pop_parameter_definitions(self) -> None:
744 self._param_def_block.pop()
746 def mark_parameter_stored(self, target: str) -> None:
750 if self._param_def_block:
751 self._param_def_block[-1].discard(target)
753 def push_context_reference(self, target: str) -> None:
754 self._context_reference_stack.append(target)
756 def pop_context_reference(self) -> None:
757 self._context_reference_stack.pop()
759 def get_context_ref(self) -> str:
760 return self._context_reference_stack[-1]
762 def get_resolve_func(self) -> str:
763 target = self._context_reference_stack[-1]
768 def derive_context(self, frame: Frame) -> str:
769 return f"{self.get_context_ref()}.derived({self.dump_local_context(frame)})"
771 def parameter_is_undeclared(self, target: str) -> bool:
773 if not self._param_def_block:
775 return target in self._param_def_block[-1]
777 def push_assign_tracking(self) -> None:
779 self._assign_stack.append(set())
781 def pop_assign_tracking(self, frame: Frame) -> None:
785 vars = self._assign_stack.pop()
798 self.writeline(f"_loop_vars[{name!r}] = {ref}")
801 self.writeline(f"_block_vars[{name!r}] = {ref}")
803 self.writeline(f"context.vars[{name!r}] = {ref}")
806 self.writeline("_loop_vars.update({")
808 self.writeline("_block_vars.update({")
810 self.writeline("context.vars.update({")
813 self.write(", ")
815 self.write(f"{name!r}: {ref}")
816 self.write("})")
819 self.writeline(f"context.exported_vars.add({public_names[0]!r})")
822 self.writeline(f"context.exported_vars.update(({names_str}))")
827 self, node: nodes.Template, frame: t.Optional[Frame] = None
830 eval_ctx = EvalContext(self.environment, self.name)
834 if self.environment.is_async:
839 self.writeline("from jinja2.runtime import " + ", ".join(exported_names))
843 envenv = "" if self.defer_init else ", environment=environment"
851 if block.name in self.blocks:
852 self.fail(f"block {block.name!r} defined twice", block.lineno)
853 self.blocks[block.name] = block
857 if import_.importname not in self.import_aliases:
859 self.import_aliases[imp] = alias = self.temporary_identifier()
862 self.writeline(f"from {module} import {obj} as {alias}")
864 self.writeline(f"import {imp} as {alias}")
867 self.writeline(f"name = {self.name!r}")
870 self.writeline(
871 f"{self.func('root')}(context, missing=missing{envenv}):", extra=1
873 self.indent()
874 self.write_commons()
878 if "self" in find_undeclared(node.body, ("self",)):
879 ref = frame.symbols.declare_parameter("self")
880 self.writeline(f"{ref} = TemplateReference(context)")
883 frame.require_output_check = have_extends and not self.has_known_extends
885 self.writeline("parent_template = None")
886 self.enter_frame(frame)
887 self.pull_dependencies(node.body)
888 self.blockvisit(node.body, frame)
889 self.leave_frame(frame, with_python_scope=True)
890 self.outdent()
894 if not self.has_known_extends:
895 self.indent()
896 self.writeline("if parent_template is not None:")
897 self.indent()
898 if not self.environment.is_async:
899 self.writeline("yield from parent_template.root_render_func(context)")
901 self.writeline(
904 self.indent()
905 self.writeline("yield event")
906 self.outdent()
907 self.outdent(1 + (not self.has_known_extends))
910 for name, block in self.blocks.items():
911 self.writeline(
912 f"{self.func('block_' + name)}(context, missing=missing{envenv}):",
916 self.indent()
917 self.write_commons()
923 undeclared = find_undeclared(block.body, ("self", "super"))
924 if "self" in undeclared:
925 ref = block_frame.symbols.declare_parameter("self")
926 self.writeline(f"{ref} = TemplateReference(context)")
929 self.writeline(f"{ref} = context.super({name!r}, block_{name})")
932 self.writeline("_block_vars = {}")
933 self.enter_frame(block_frame)
934 self.pull_dependencies(block.body)
935 self.blockvisit(block.body, block_frame)
936 self.leave_frame(block_frame, with_python_scope=True)
937 self.outdent()
939 blocks_kv_str = ", ".join(f"{x!r}: block_{x}" for x in self.blocks)
940 self.writeline(f"blocks = {{{blocks_kv_str}}}", extra=1)
941 debug_kv_str = "&".join(f"{k}={v}" for k, v in self.debug_info)
942 self.writeline(f"debug_info = {debug_kv_str!r}")
944 def visit_Block(self, node: nodes.Block, frame: Frame) -> None:
950 if self.has_known_extends:
952 if self.extends_so_far > 0:
953 self.writeline("if parent_template is None:")
954 self.indent()
958 context = self.derive_context(frame)
960 context = self.get_context_ref()
963 self.writeline(f"if len(context.blocks[{node.name!r}]) <= 1:", node)
964 self.indent()
965 self.writeline(
969 self.outdent()
971 if not self.environment.is_async and frame.buffer is None:
972 self.writeline(
976 self.writeline(
977 f"{self.choose_async()}for event in"
981 self.indent()
982 self.simple_write("event", frame)
983 self.outdent()
985 self.outdent(level)
987 def visit_Extends(self, node: nodes.Extends, frame: Frame) -> None:
990 self.fail("cannot use extend from a non top-level scope", node.lineno)
995 if self.extends_so_far > 0:
1000 if not self.has_known_extends:
1001 self.writeline("if parent_template is not None:")
1002 self.indent()
1003 self.writeline('raise TemplateRuntimeError("extended multiple times")')
1007 if self.has_known_extends:
1010 self.outdent()
1012 self.writeline("parent_template = environment.get_template(", node)
1013 self.visit(node.template, frame)
1014 self.write(f", {self.name!r})")
1015 self.writeline("for name, parent_block in parent_template.blocks.items():")
1016 self.indent()
1017 self.writeline("context.blocks.setdefault(name, []).append(parent_block)")
1018 self.outdent()
1024 self.has_known_extends = True
1027 self.extends_so_far += 1
1029 def visit_Include(self, node: nodes.Include, frame: Frame) -> None:
1032 self.writeline("try:")
1033 self.indent()
1044 self.writeline(f"template = environment.{func_name}(", node)
1045 self.visit(node.template, frame)
1046 self.write(f", {self.name!r})")
1048 self.outdent()
1049 self.writeline("except TemplateNotFound:")
1050 self.indent()
1051 self.writeline("pass")
1052 self.outdent()
1053 self.writeline("else:")
1054 self.indent()
1058 self.writeline(
1059 f"{self.choose_async()}for event in template.root_render_func("
1061 f" {self.dump_local_context(frame)})):"
1063 elif self.environment.is_async:
1064 self.writeline(
1069 self.writeline("yield from template._get_default_module()._body_stream")
1073 self.indent()
1074 self.simple_write("event", frame)
1075 self.outdent()
1078 self.outdent()
1081 self, node: t.Union[nodes.Import, nodes.FromImport], frame: Frame
1083 self.write(f"{self.choose_async('await ')}environment.get_template(")
1084 self.visit(node.template, frame)
1085 self.write(f", {self.name!r}).")
1088 f_name = f"make_module{self.choose_async('_async')}"
1089 self.write(
1090 f"{f_name}(context.get_all(), True, {self.dump_local_context(frame)})"
1093 self.write(f"_get_default_module{self.choose_async('_async')}(context)")
1095 def visit_Import(self, node: nodes.Import, frame: Frame) -> None:
1097 self.writeline(f"{frame.symbols.ref(node.target)} = ", node)
1099 self.write(f"context.vars[{node.target!r}] = ")
1101 self._import_common(node, frame)
1104 self.writeline(f"context.exported_vars.discard({node.target!r})")
1106 def visit_FromImport(self, node: nodes.FromImport, frame: Frame) -> None:
1108 self.newline(node)
1109 self.write("included_template = ")
1110 self._import_common(node, frame)
1118 self.writeline(
1122 self.writeline(f"if {frame.symbols.ref(alias)} is missing:")
1123 self.indent()
1126 f" (imported on {self.position(node)})"
1129 self.writeline(
1132 self.outdent()
1141 self.writeline(f"context.vars[{name!r}] = {frame.symbols.ref(name)}")
1146 self.writeline(f"context.vars.update({{{names_kv}}})")
1149 self.writeline(f"context.exported_vars.discard({discarded_names[0]!r})")
1152 self.writeline(
1156 def visit_For(self, node: nodes.For, frame: Frame) -> None:
1181 loop_filter_func = self.temporary_identifier()
1183 self.writeline(f"{self.func(loop_filter_func)}(fiter):", node.test)
1184 self.indent()
1185 self.enter_frame(test_frame)
1186 self.writeline(self.choose_async("async for ", "for "))
1187 self.visit(node.target, loop_frame)
1188 self.write(" in ")
1189 self.write(self.choose_async("auto_aiter(fiter)", "fiter"))
1190 self.write(":")
1191 self.indent()
1192 self.writeline("if ", node.test)
1193 self.visit(node.test, test_frame)
1194 self.write(":")
1195 self.indent()
1196 self.writeline("yield ")
1197 self.visit(node.target, loop_frame)
1198 self.outdent(3)
1199 self.leave_frame(test_frame, with_python_scope=True)
1205 self.writeline(
1206 f"{self.func('loop')}(reciter, loop_render_func, depth=0):", node
1208 self.indent()
1209 self.buffer(loop_frame)
1217 self.writeline(f"{loop_ref} = missing")
1221 self.fail(
1227 iteration_indicator = self.temporary_identifier()
1228 self.writeline(f"{iteration_indicator} = 1")
1230 self.writeline(self.choose_async("async for ", "for "), node)
1231 self.visit(node.target, loop_frame)
1233 self.write(f", {loop_ref} in {self.choose_async('Async')}LoopContext(")
1235 self.write(" in ")
1238 self.write(f"{loop_filter_func}(")
1240 self.write("reciter")
1242 if self.environment.is_async and not extended_loop:
1243 self.write("auto_aiter(")
1244 self.visit(node.iter, frame)
1245 if self.environment.is_async and not extended_loop:
1246 self.write(")")
1248 self.write(")")
1251 self.write(", undefined, loop_render_func, depth):")
1253 self.write(", undefined):" if extended_loop else ":")
1255 self.indent()
1256 self.enter_frame(loop_frame)
1258 self.writeline("_loop_vars = {}")
1259 self.blockvisit(node.body, loop_frame)
1261 self.writeline(f"{iteration_indicator} = 0")
1262 self.outdent()
1263 self.leave_frame(
1268 self.writeline(f"if {iteration_indicator}:")
1269 self.indent()
1270 self.enter_frame(else_frame)
1271 self.blockvisit(node.else_, else_frame)
1272 self.leave_frame(else_frame)
1273 self.outdent()
1278 self.return_buffer_contents(loop_frame)
1279 self.outdent()
1280 self.start_write(frame, node)
1281 self.write(f"{self.choose_async('await ')}loop(")
1282 if self.environment.is_async:
1283 self.write("auto_aiter(")
1284 self.visit(node.iter, frame)
1285 if self.environment.is_async:
1286 self.write(")")
1287 self.write(", loop)")
1288 self.end_write(frame)
1292 if self._assign_stack:
1293 self._assign_stack[-1].difference_update(loop_frame.symbols.stores)
1295 def visit_If(self, node: nodes.If, frame: Frame) -> None:
1297 self.writeline("if ", node)
1298 self.visit(node.test, if_frame)
1299 self.write(":")
1300 self.indent()
1301 self.blockvisit(node.body, if_frame)
1302 self.outdent()
1304 self.writeline("elif ", elif_)
1305 self.visit(elif_.test, if_frame)
1306 self.write(":")
1307 self.indent()
1308 self.blockvisit(elif_.body, if_frame)
1309 self.outdent()
1311 self.writeline("else:")
1312 self.indent()
1313 self.blockvisit(node.else_, if_frame)
1314 self.outdent()
1316 def visit_Macro(self, node: nodes.Macro, frame: Frame) -> None:
1317 macro_frame, macro_ref = self.macro_body(node, frame)
1318 self.newline()
1321 self.write(f"context.exported_vars.add({node.name!r})")
1322 self.writeline(f"context.vars[{node.name!r}] = ")
1323 self.write(f"{frame.symbols.ref(node.name)} = ")
1324 self.macro_def(macro_ref, macro_frame)
1326 def visit_CallBlock(self, node: nodes.CallBlock, frame: Frame) -> None:
1327 call_frame, macro_ref = self.macro_body(node, frame)
1328 self.writeline("caller = ")
1329 self.macro_def(macro_ref, call_frame)
1330 self.start_write(frame, node)
1331 self.visit_Call(node.call, frame, forward_caller=True)
1332 self.end_write(frame)
1334 def visit_FilterBlock(self, node: nodes.FilterBlock, frame: Frame) -> None:
1337 self.enter_frame(filter_frame)
1338 self.buffer(filter_frame)
1339 self.blockvisit(node.body, filter_frame)
1340 self.start_write(frame, node)
1341 self.visit_Filter(node.filter, filter_frame)
1342 self.end_write(frame)
1343 self.leave_frame(filter_frame)
1345 def visit_With(self, node: nodes.With, frame: Frame) -> None:
1348 self.enter_frame(with_frame)
1350 self.newline()
1351 self.visit(target, with_frame)
1352 self.write(" = ")
1353 self.visit(expr, frame)
1354 self.blockvisit(node.body, with_frame)
1355 self.leave_frame(with_frame)
1357 def visit_ExprStmt(self, node: nodes.ExprStmt, frame: Frame) -> None:
1358 self.newline(node)
1359 self.visit(node.node, frame)
1375 def _make_finalize(self) -> _FinalizeInfo:
1388 if self._finalize is not None:
1389 return self._finalize
1392 finalize = default = self._default_finalize
1395 if self.environment.finalize:
1397 env_finalize = self.environment.finalize
1418 return default(env_finalize(self.environment, value))
1420 self._finalize = self._FinalizeInfo(finalize, src)
1421 return self._finalize
1423 def _output_const_repr(self, group: t.Iterable[t.Any]) -> str:
1431 self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
1452 self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
1458 self.write("(escape if context.eval_ctx.autoescape else str)(")
1460 self.write("escape(")
1462 self.write("str(")
1465 self.write(finalize.src)
1468 self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
1473 self.write(")")
1476 self.write(")")
1478 def visit_Output(self, node: nodes.Output, frame: Frame) -> None:
1482 if self.has_known_extends:
1485 self.writeline("if parent_template is None:")
1486 self.indent()
1488 finalize = self._make_finalize()
1506 const = self._output_child_to_const(child, frame, finalize)
1521 self.writeline(f"{frame.buffer}.append(")
1523 self.writeline(f"{frame.buffer}.extend((")
1525 self.indent()
1530 val = self._output_const_repr(item)
1533 self.writeline("yield " + val)
1535 self.writeline(val + ",")
1538 self.writeline("yield ", item)
1540 self.newline(item)
1543 self._output_child_pre(item, frame, finalize)
1544 self.visit(item, frame)
1545 self._output_child_post(item, frame, finalize)
1548 self.write(",")
1551 self.outdent()
1552 self.writeline(")" if len(body) == 1 else "))")
1555 self.outdent()
1557 def visit_Assign(self, node: nodes.Assign, frame: Frame) -> None:
1558 self.push_assign_tracking()
1559 self.newline(node)
1560 self.visit(node.target, frame)
1561 self.write(" = ")
1562 self.visit(node.node, frame)
1563 self.pop_assign_tracking(frame)
1565 def visit_AssignBlock(self, node: nodes.AssignBlock, frame: Frame) -> None:
1566 self.push_assign_tracking()
1573 self.enter_frame(block_frame)
1574 self.buffer(block_frame)
1575 self.blockvisit(node.body, block_frame)
1576 self.newline(node)
1577 self.visit(node.target, frame)
1578 self.write(" = (Markup if context.eval_ctx.autoescape else identity)(")
1580 self.visit_Filter(node.filter, block_frame)
1582 self.write(f"concat({block_frame.buffer})")
1583 self.write(")")
1584 self.pop_assign_tracking(frame)
1585 self.leave_frame(block_frame)
1589 def visit_Name(self, node: nodes.Name, frame: Frame) -> None:
1593 if self._assign_stack:
1594 self._assign_stack[-1].add(node.name)
1605 and not self.parameter_is_undeclared(ref)
1607 self.write(
1612 self.write(ref)
1614 def visit_NSRef(self, node: nodes.NSRef, frame: Frame) -> None:
1619 self.writeline(f"if not isinstance({ref}, Namespace):")
1620 self.indent()
1621 self.writeline(
1625 self.outdent()
1626 self.writeline(f"{ref}[{node.attr!r}]")
1628 def visit_Const(self, node: nodes.Const, frame: Frame) -> None:
1631 self.write(str(val))
1633 self.write(repr(val))
1635 def visit_TemplateData(self, node: nodes.TemplateData, frame: Frame) -> None:
1637 self.write(repr(node.as_const(frame.eval_ctx)))
1639 self.write(
1643 def visit_Tuple(self, node: nodes.Tuple, frame: Frame) -> None:
1644 self.write("(")
1648 self.write(", ")
1649 self.visit(item, frame)
1650 self.write(",)" if idx == 0 else ")")
1652 def visit_List(self, node: nodes.List, frame: Frame) -> None:
1653 self.write("[")
1656 self.write(", ")
1657 self.visit(item, frame)
1658 self.write("]")
1660 def visit_Dict(self, node: nodes.Dict, frame: Frame) -> None:
1661 self.write("{")
1664 self.write(", ")
1665 self.visit(item.key, frame)
1666 self.write(": ")
1667 self.visit(item.value, frame)
1668 self.write("}")
1684 def visit_Concat(self, node: nodes.Concat, frame: Frame) -> None:
1691 self.write(f"{func_name}((")
1693 self.visit(arg, frame)
1694 self.write(", ")
1695 self.write("))")
1698 def visit_Compare(self, node: nodes.Compare, frame: Frame) -> None:
1699 self.write("(")
1700 self.visit(node.expr, frame)
1702 self.visit(op, frame)
1703 self.write(")")
1705 def visit_Operand(self, node: nodes.Operand, frame: Frame) -> None:
1706 self.write(f" {operators[node.op]} ")
1707 self.visit(node.expr, frame)
1710 def visit_Getattr(self, node: nodes.Getattr, frame: Frame) -> None:
1711 if self.environment.is_async:
1712 self.write("(await auto_await(")
1714 self.write("environment.getattr(")
1715 self.visit(node.node, frame)
1716 self.write(f", {node.attr!r})")
1718 if self.environment.is_async:
1719 self.write("))")
1722 def visit_Getitem(self, node: nodes.Getitem, frame: Frame) -> None:
1725 self.visit(node.node, frame)
1726 self.write("[")
1727 self.visit(node.arg, frame)
1728 self.write("]")
1730 if self.environment.is_async:
1731 self.write("(await auto_await(")
1733 self.write("environment.getitem(")
1734 self.visit(node.node, frame)
1735 self.write(", ")
1736 self.visit(node.arg, frame)
1737 self.write(")")
1739 if self.environment.is_async:
1740 self.write("))")
1742 def visit_Slice(self, node: nodes.Slice, frame: Frame) -> None:
1744 self.visit(node.start, frame)
1745 self.write(":")
1747 self.visit(node.stop, frame)
1749 self.write(":")
1750 self.visit(node.step, frame)
1754 self, node: t.Union[nodes.Filter, nodes.Test], frame: Frame, is_filter: bool
1756 if self.environment.is_async:
1757 self.write("(await auto_await(")
1760 self.write(f"{self.filters[node.name]}(")
1761 func = self.environment.filters.get(node.name)
1763 self.write(f"{self.tests[node.name]}(")
1764 func = self.environment.tests.get(node.name)
1771 self.fail(f"No {type_name} named {node.name!r}.", node.lineno)
1782 self.write(f"{pass_arg}, ")
1788 self.signature(node, frame)
1789 self.write(")")
1791 if self.environment.is_async:
1792 self.write("))")
1795 def visit_Filter(self, node: nodes.Filter, frame: Frame) -> None:
1796 with self._filter_test_common(node, frame, True):
1800 self.visit(node.node, frame)
1802 self.write(
1807 self.write(f"Markup(concat({frame.buffer}))")
1809 self.write(f"concat({frame.buffer})")
1812 def visit_Test(self, node: nodes.Test, frame: Frame) -> None:
1813 with self._filter_test_common(node, frame, False):
1814 self.visit(node.node, frame)
1817 def visit_CondExpr(self, node: nodes.CondExpr, frame: Frame) -> None:
1822 self.visit(node.expr2, frame)
1825 self.write(
1827 f" {self.position(node)} evaluated to false and no else"
1831 self.write("(")
1832 self.visit(node.expr1, frame)
1833 self.write(" if ")
1834 self.visit(node.test, frame)
1835 self.write(" else ")
1837 self.write(")")
1841 self, node: nodes.Call, frame: Frame, forward_caller: bool = False
1843 if self.environment.is_async:
1844 self.write("(await auto_await(")
1845 if self.environment.sandboxed:
1846 self.write("environment.call(context, ")
1848 self.write("context.call(")
1849 self.visit(node.node, frame)
1857 self.signature(node, frame, extra_kwargs)
1858 self.write(")")
1859 if self.environment.is_async:
1860 self.write("))")
1862 def visit_Keyword(self, node: nodes.Keyword, frame: Frame) -> None:
1863 self.write(node.key + "=")
1864 self.visit(node.value, frame)
1868 def visit_MarkSafe(self, node: nodes.MarkSafe, frame: Frame) -> None:
1869 self.write("Markup(")
1870 self.visit(node.expr, frame)
1871 self.write(")")
1874 self, node: nodes.MarkSafeIfAutoescape, frame: Frame
1876 self.write("(Markup if context.eval_ctx.autoescape else identity)(")
1877 self.visit(node.expr, frame)
1878 self.write(")")
1881 self, node: nodes.EnvironmentAttribute, frame: Frame
1883 self.write("environment." + node.name)
1886 self, node: nodes.ExtensionAttribute, frame: Frame
1888 self.write(f"environment.extensions[{node.identifier!r}].{node.name}")
1890 def visit_ImportedName(self, node: nodes.ImportedName, frame: Frame) -> None:
1891 self.write(self.import_aliases[node.importname])
1893 def visit_InternalName(self, node: nodes.InternalName, frame: Frame) -> None:
1894 self.write(node.name)
1897 self, node: nodes.ContextReference, frame: Frame
1899 self.write("context")
1902 self, node: nodes.DerivedContextReference, frame: Frame
1904 self.write(self.derive_context(frame))
1906 def visit_Continue(self, node: nodes.Continue, frame: Frame) -> None:
1907 self.writeline("continue", node)
1909 def visit_Break(self, node: nodes.Break, frame: Frame) -> None:
1910 self.writeline("break", node)
1912 def visit_Scope(self, node: nodes.Scope, frame: Frame) -> None:
1915 self.enter_frame(scope_frame)
1916 self.blockvisit(node.body, scope_frame)
1917 self.leave_frame(scope_frame)
1919 def visit_OverlayScope(self, node: nodes.OverlayScope, frame: Frame) -> None:
1920 ctx = self.temporary_identifier()
1921 self.writeline(f"{ctx} = {self.derive_context(frame)}")
1922 self.writeline(f"{ctx}.vars = ")
1923 self.visit(node.context, frame)
1924 self.push_context_reference(ctx)
1928 self.enter_frame(scope_frame)
1929 self.blockvisit(node.body, scope_frame)
1930 self.leave_frame(scope_frame)
1931 self.pop_context_reference()
1934 self, node: nodes.EvalContextModifier, frame: Frame
1937 self.writeline(f"context.eval_ctx.{keyword.key} = ")
1938 self.visit(keyword.value, frame)
1947 self, node: nodes.ScopedEvalContextModifier, frame: Frame
1949 old_ctx_name = self.temporary_identifier()
1951 self.writeline(f"{old_ctx_name} = context.eval_ctx.save()")
1952 self.visit_EvalContextModifier(node, frame)
1954 self.visit(child, frame)
1956 self.writeline(f"context.eval_ctx.revert({old_ctx_name})")