@pineforge/codegen-pyodide 0.10.4 → 1.0.0-rc.1

package/pineforge_codegen/codegen/constant_fold.py

@@ -0,0 +1,131 @@
+"""Bounded numeric folding for constructor expressions, without Python execution.
+
+``ast`` only parses syntax here. No expression-supplied object, attribute or
+callable is resolved: even ``math.sin`` is a fixed spelling in a local table.
+Unsupported or non-finite expressions remain on the existing runtime/error path.
+"""
+
+from __future__ import annotations
+
+import ast
+import math
+import operator
+from collections.abc import Mapping
+
+
+_BINARY = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.Mod: operator.mod,
+}
+_UNARY = {ast.UAdd: operator.pos, ast.USub: operator.neg}
+_FUNCTIONS = {
+    "abs": abs,
+    "round": round,
+    "math.abs": abs,
+    # Keep the existing folder's rounding behavior; this repair does not
+    # change numeric semantics to match a different rounding convention.
+    "math.round": round,
+    # sqrt/ceil/floor previously took a failed import rewrite and did not
+    # fold. Keep that domain unchanged: newly admitting sqrt under Python's
+    # round, for example, can disagree with the existing C++ runtime round.
+    "math.pow": math.pow,
+    "math.exp": math.exp,
+    "math.log": math.log,
+    "math.log10": math.log10,
+    "math.sin": math.sin,
+    "math.cos": math.cos,
+    "math.tan": math.tan,
+    "math.asin": math.asin,
+    "math.acos": math.acos,
+    "math.atan": math.atan,
+}
+_CONSTANTS = {"math.pi": math.pi, "math.e": math.e}
+
+# Folding is optional. Bound parser work, tree traversal and integer growth;
+# rejection retains the original expression for the caller's existing guard.
+_MAX_SOURCE_LENGTH = 8192
+_MAX_NODES = 512
+_MAX_DEPTH = 64
+_MAX_INTEGER_BITS = 1024
+_MAX_ROUND_DIGITS = 1024
+
+
+def _numeric(value: object) -> int | float | bool:
+    if type(value) is bool:
+        return value
+    if type(value) is int and value.bit_length() <= _MAX_INTEGER_BITS:
+        return value
+    if type(value) is float and math.isfinite(value):
+        return value
+    raise ValueError("not a bounded numeric constant")
+
+
+def _spelling(node: ast.AST) -> str:
+    if isinstance(node, ast.Name):
+        return node.id
+    if (isinstance(node, ast.Attribute)
+            and isinstance(node.value, ast.Name)
+            and node.value.id == "math"):
+        return f"math.{node.attr}"
+    raise ValueError("not an allowed numeric spelling")
+
+
+def fold_numeric_expression(
+    expression: str, known_values: Mapping[str, object],
+) -> int | float | bool | None:
+    """Return a numeric constant, or None when the syntax cannot be folded.
+
+    Names resolve only to caller-provided primitive numbers. Calls resolve
+    only to the fixed functions above and accept positional numeric arguments.
+    Attribute chains, indexing, containers, comprehensions, lambda expressions,
+    arbitrary call targets and keyword/unpacked arguments are never evaluated.
+    """
+    if len(expression) > _MAX_SOURCE_LENGTH:
+        return None
+
+    def visit(node: ast.AST, depth: int = 0) -> int | float | bool:
+        if depth > _MAX_DEPTH:
+            raise ValueError("numeric expression is too deep")
+        if isinstance(node, ast.Constant):
+            return _numeric(node.value)
+        if isinstance(node, ast.Name):
+            return _numeric(known_values[node.id])
+        if isinstance(node, ast.Attribute):
+            return _CONSTANTS[_spelling(node)]
+        if isinstance(node, ast.UnaryOp) and type(node.op) in _UNARY:
+            return _numeric(_UNARY[type(node.op)](visit(node.operand, depth + 1)))
+        if isinstance(node, ast.BinOp) and type(node.op) in _BINARY:
+            return _numeric(_BINARY[type(node.op)](
+                visit(node.left, depth + 1), visit(node.right, depth + 1),
+            ))
+        if isinstance(node, ast.Call) and not node.keywords:
+            spelling = _spelling(node.func)
+            if spelling.split(".", 1)[0] in known_values:
+                raise ValueError("numeric function name is shadowed")
+            function = _FUNCTIONS[spelling]
+            args = [visit(arg, depth + 1) for arg in node.args]
+            if spelling in ("round", "math.round"):
+                # CPython's integer round builds 10**(-ndigits). A small
+                # integer operand can still request enormous work, so bound
+                # this argument BEFORE dispatch, not only the returned value.
+                if not 1 <= len(args) <= 2:
+                    raise ValueError("unsupported round argument count")
+                if len(args) == 2 and (
+                    type(args[1]) not in (int, bool)
+                    or abs(args[1]) > _MAX_ROUND_DIGITS
+                ):
+                    raise ValueError("round precision is not bounded")
+            return _numeric(function(*args))
+        raise ValueError("not numeric expression syntax")
+
+    try:
+        tree = ast.parse(expression, mode="eval")
+        if sum(1 for _ in ast.walk(tree)) > _MAX_NODES:
+            return None
+        return visit(tree.body)
+    except (SyntaxError, ValueError, TypeError, KeyError, ArithmeticError,
+            RecursionError):
+        return None

package/pineforge_codegen/codegen/drawing.py

@@ -19,6 +19,8 @@ reads only attributes established by ``CodeGen.__init__`` (``_uses_drawing``,
 
 from __future__ import annotations
 
+import re
+
 from ..ast_nodes import FuncCall, Identifier, MemberAccess
 from ..symbols import method_receiver_type_name
 from .tables import (
@@ -30,6 +32,74 @@ from .tables import (
 
 _MAP_VOID_METHODS = frozenset({"clear", "put_all"})
 
+# Builtin calls Pine types as void, each lowering to a void C++ statement. A
+# user function or selection arm ending in one returns no value, so it must be
+# emitted as a statement, never as ``return strategy_exit(...)``.
+_VOID_BUILTIN_CALLS = frozenset({
+    ("strategy", "entry"), ("strategy", "order"), ("strategy", "exit"),
+    ("strategy", "close"), ("strategy", "close_all"),
+    ("strategy", "cancel"), ("strategy", "cancel_all"),
+    ("log", "info"), ("log", "warning"), ("log", "error"),
+    ("runtime", "error"),
+})
+
+# TradingView's drawing lifetime, emitted once per drawing TU after
+# ``using namespace pineforge;``. The engine's arena keeps a deleted record
+# readable and evicts at exactly the cap; TradingView does neither (lane
+# CG-W9-MISC tapes, tests/fixtures/drawing_lifetime). The generated arenas are
+# therefore unbounded (``_PF_DRAWING_UNBOUNDED``), every getter and setter goes
+# through the liveness check below, and ``_pf_collect_<kind>s_`` (a member of
+# the strategy, which knows its variables) runs the collection.
+DRAWING_LIFETIME_CPP = """\
+// TradingView's drawing lifetime. A deleted or collected drawing reads like a
+// na handle: every getter returns na, every setter does nothing and na() is
+// true. A new line, box or label that makes its kind's live count reach
+// max_<kind>_count + 6 deletes the oldest drawings of that kind that no var,
+// varip or history-read variable holds, until max_<kind>_count remain; one
+// held only by an array, a map, an object field, a local or a plain non-var
+// variable is collectable. Linefills are never collected.
+constexpr int _PF_DRAWING_UNBOUNDED = 2147483647;
+template <class T> struct _PFDrawingArg { using type = T; };
+template <class R, class Rec, class H, class... A>
+inline R _pf_drawing_get(R (*get)(DrawingArena<Rec>&, H, A...),
+                         typename _PFDrawingArg<DrawingArena<Rec>&>::type arena,
+                         typename _PFDrawingArg<H>::type h,
+                         typename _PFDrawingArg<A>::type... args) {
+    return arena.alive(h.id) ? get(arena, h, args...) : na<R>();
+}
+template <class Rec, class H, class... A>
+inline void _pf_drawing_set(void (*set)(DrawingArena<Rec>&, H, A...),
+                            typename _PFDrawingArg<DrawingArena<Rec>&>::type arena,
+                            typename _PFDrawingArg<H>::type h,
+                            typename _PFDrawingArg<A>::type... args) {
+    if (arena.alive(h.id)) set(arena, h, args...);
+}
+template <class Rec, class H>
+inline bool _pf_drawing_na(const DrawingArena<Rec>& arena, H h) {
+    return !arena.alive(h.id);
+}
+template <class Rec>
+inline void _pf_collect_drawings(DrawingArena<Rec>& arena, int keep,
+                                 const int32_t* pins, std::size_t pin_count) {
+    const std::size_t excess = arena.order().size() - static_cast<std::size_t>(keep);
+    std::vector<int32_t> doomed;
+    for (int32_t id : arena.order()) {
+        if (doomed.size() == excess) break;
+        if (std::find(pins, pins + pin_count, id) == pins + pin_count) doomed.push_back(id);
+    }
+    for (int32_t id : doomed) arena.erase(id);
+}
+"""
+
+# Drawing kinds TradingView collects, with their member collector.
+DRAWING_COLLECTED = {
+    "line": "_pf_collect_lines_",
+    "box": "_pf_collect_boxes_",
+    "label": "_pf_collect_labels_",
+}
+# TradingView keeps up to max_<kind>_count + 5 live drawings of a kind.
+DRAWING_COLLECTION_SLACK = 6
+
 # ---------------------------------------------------------------------------
 # Canonical Pine v6 constructor param-name lists (positional order).
 # Only the GEOMETRY names are consumed downstream; every other (visual) name is
@@ -197,7 +267,16 @@ class DrawingVisitor:
                 return True
         return False
 
+    @staticmethod
+    def _collected(dtype: str, handle: str) -> str:
+        """A new drawing of a collected kind passes through its collector."""
+        collector = DRAWING_COLLECTED.get(dtype)
+        return f"{collector}({handle})" if collector else handle
+
     def _emit_drawing_ctor(self, dtype: str, node: FuncCall) -> str:
+        return self._collected(dtype, self._emit_drawing_alloc(dtype, node))
+
+    def _emit_drawing_alloc(self, dtype: str, node: FuncCall) -> str:
         arena = DRAWING_ARENA[dtype]
         if dtype == "linefill":
             vals = self._merge_drawing_args(node, ["line1", "line2", "color"])
@@ -219,8 +298,10 @@ class DrawingVisitor:
             y1 = self._visit_expr(vals.get("y1"))
             x2 = self._visit_expr(vals.get("x2"))
             y2 = self._visit_expr(vals.get("y2"))
-            return (f"pf_line_new({arena}, (int64_t)({x1}), (double)({y1}), "
-                    f"(int64_t)({x2}), (double)({y2}), {xloc}, {el}, {er})")
+            x1 = self._coerce_int_slot_with_cast(x1, vals.get("x1"), "int64_t")
+            x2 = self._coerce_int_slot_with_cast(x2, vals.get("x2"), "int64_t")
+            return (f"pf_line_new({arena}, {x1}, (double)({y1}), "
+                    f"{x2}, (double)({y2}), {xloc}, {el}, {er})")
 
         if dtype == "box":
             vals = self._merge_drawing_args(node, _BOX_CTOR_PTS if use_pts else _BOX_CTOR)
@@ -233,8 +314,10 @@ class DrawingVisitor:
             top = self._visit_expr(vals.get("top"))
             right = self._visit_expr(vals.get("right"))
             bottom = self._visit_expr(vals.get("bottom"))
-            return (f"pf_box_new({arena}, (int64_t)({left}), (double)({top}), "
-                    f"(int64_t)({right}), (double)({bottom}), {xloc})")
+            left = self._coerce_int_slot_with_cast(left, vals.get("left"), "int64_t")
+            right = self._coerce_int_slot_with_cast(right, vals.get("right"), "int64_t")
+            return (f"pf_box_new({arena}, {left}, (double)({top}), "
+                    f"{right}, (double)({bottom}), {xloc})")
 
         if dtype == "label":
             vals = self._merge_drawing_args(node, _LABEL_CTOR_PTS if use_pts else _LABEL_CTOR)
@@ -247,7 +330,8 @@ class DrawingVisitor:
             x = self._visit_expr(vals.get("x"))
             y = self._visit_expr(vals.get("y"))
             xloc = self._lower_xloc(vals.get("xloc"))
-            return (f"pf_label_new({arena}, (int64_t)({x}), (double)({y}), "
+            x = self._coerce_int_slot_with_cast(x, vals.get("x"), "int64_t")
+            return (f"pf_label_new({arena}, {x}, (double)({y}), "
                     f"{text}, {xloc}, {yloc})")
 
         return "0"  # unreachable
@@ -269,20 +353,24 @@ class DrawingVisitor:
             vals = self._merge_drawing_args(node, ["index", "price"])
             idx = self._visit_expr(vals.get("index"))
             price = self._visit_expr(vals.get("price"))
-            return (f"ChartPoint{{ .index=(int64_t)({idx}), .time=na<int64_t>(), "
+            idx = self._coerce_int_slot_with_cast(idx, vals.get("index"), "int64_t")
+            return (f"ChartPoint{{ .index={idx}, .time=na<int64_t>(), "
                     f".price=({price}) }}")
         if func_name == "from_time":
             vals = self._merge_drawing_args(node, ["time", "price"])
             tm = self._visit_expr(vals.get("time"))
             price = self._visit_expr(vals.get("price"))
-            return (f"ChartPoint{{ .index=na<int64_t>(), .time=(int64_t)({tm}), "
+            tm = self._coerce_int_slot_with_cast(tm, vals.get("time"), "int64_t")
+            return (f"ChartPoint{{ .index=na<int64_t>(), .time={tm}, "
                     f".price=({price}) }}")
         if func_name == "new":
             vals = self._merge_drawing_args(node, ["time", "index", "price"])
             tm = self._visit_expr(vals.get("time"))
             idx = self._visit_expr(vals.get("index"))
             price = self._visit_expr(vals.get("price"))
-            return (f"ChartPoint{{ .index=(int64_t)({idx}), .time=(int64_t)({tm}), "
+            idx = self._coerce_int_slot_with_cast(idx, vals.get("index"), "int64_t")
+            tm = self._coerce_int_slot_with_cast(tm, vals.get("time"), "int64_t")
+            return (f"ChartPoint{{ .index={idx}, .time={tm}, "
                     f".price=({price}) }}")
         return "ChartPoint{}"
 
@@ -319,106 +407,88 @@ class DrawingVisitor:
             return self._emit_linefill_method(method, arena, recv, av)
         return "0"
 
+    # Getters and setters reach the arena through ``_pf_drawing_get`` /
+    # ``_pf_drawing_set`` (DRAWING_LIFETIME_CPP): a deleted, collected or na
+    # handle reads na and ignores the write. Every argument is still evaluated.
+    @staticmethod
+    def _live_get(fn: str, a: str, r: str, *args: str) -> str:
+        extra = "".join(", " + x for x in args)
+        return f"_pf_drawing_get({fn}, {a}, {r}{extra})"
+
+    @staticmethod
+    def _live_set(fn: str, a: str, r: str, *args: str) -> str:
+        extra = "".join(", " + x for x in args)
+        return f"_pf_drawing_set({fn}, {a}, {r}{extra})"
+
     def _emit_line_method(self, m, a, r, av, raw) -> str:
-        if m == "get_x1":
-            return f"pf_line_get_x1({a}, {r})"
-        if m == "get_x2":
-            return f"pf_line_get_x2({a}, {r})"
-        if m == "get_y1":
-            return f"pf_line_get_y1({a}, {r})"
-        if m == "get_y2":
-            return f"pf_line_get_y2({a}, {r})"
+        get, put = self._live_get, self._live_set
+        if m in ("get_x1", "get_x2", "get_y1", "get_y2"):
+            return get(f"pf_line_{m}", a, r)
         if m == "get_price":
-            return f"pf_line_get_price({a}, {r}, (int64_t)({av[0]}))"
-        if m == "set_x1":
-            return f"pf_line_set_x1({a}, {r}, (int64_t)({av[0]}))"
-        if m == "set_x2":
-            return f"pf_line_set_x2({a}, {r}, (int64_t)({av[0]}))"
-        if m == "set_y1":
-            return f"pf_line_set_y1({a}, {r}, (double)({av[0]}))"
-        if m == "set_y2":
-            return f"pf_line_set_y2({a}, {r}, (double)({av[0]}))"
-        if m == "set_xy1":
-            return f"pf_line_set_xy1({a}, {r}, (int64_t)({av[0]}), (double)({av[1]}))"
-        if m == "set_xy2":
-            return f"pf_line_set_xy2({a}, {r}, (int64_t)({av[0]}), (double)({av[1]}))"
-        if m == "set_first_point":
-            return f"pf_line_set_first_point({a}, {r}, {av[0]})"
-        if m == "set_second_point":
-            return f"pf_line_set_second_point({a}, {r}, {av[0]})"
+            return get("pf_line_get_price", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'))
+        if m in ("set_x1", "set_x2"):
+            return put(f"pf_line_{m}", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'))
+        if m in ("set_y1", "set_y2"):
+            return put(f"pf_line_{m}", a, r, f"(double)({av[0]})")
+        if m in ("set_xy1", "set_xy2"):
+            return put(f"pf_line_{m}", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'), f"(double)({av[1]})")
+        if m in ("set_first_point", "set_second_point"):
+            return put(f"pf_line_{m}", a, r, av[0])
         if m == "set_xloc":
-            return f"pf_line_set_xloc({a}, {r}, (int64_t)({av[0]}), (int64_t)({av[1]}), {self._lower_xloc(raw[2])})"
+            return put("pf_line_set_xloc", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'), self._coerce_int_slot_with_cast(av[1], raw[1], 'int64_t'), self._lower_xloc(raw[2]))
         if m == "copy":
-            return f"pf_line_copy({a}, {r})"
+            return self._collected("line", f"pf_line_copy({a}, {r})")
         if m == "delete":
             return f"pf_line_delete({a}, {r})"
         return "0"
 
     def _emit_box_method(self, m, a, r, av, raw) -> str:
-        if m == "get_left":
-            return f"pf_box_get_left({a}, {r})"
-        if m == "get_right":
-            return f"pf_box_get_right({a}, {r})"
-        if m == "get_top":
-            return f"pf_box_get_top({a}, {r})"
-        if m == "get_bottom":
-            return f"pf_box_get_bottom({a}, {r})"
-        if m == "set_left":
-            return f"pf_box_set_left({a}, {r}, (int64_t)({av[0]}))"
-        if m == "set_right":
-            return f"pf_box_set_right({a}, {r}, (int64_t)({av[0]}))"
-        if m == "set_top":
-            return f"pf_box_set_top({a}, {r}, (double)({av[0]}))"
-        if m == "set_bottom":
-            return f"pf_box_set_bottom({a}, {r}, (double)({av[0]}))"
-        if m == "set_lefttop":
-            return f"pf_box_set_lefttop({a}, {r}, (int64_t)({av[0]}), (double)({av[1]}))"
-        if m == "set_rightbottom":
-            return f"pf_box_set_rightbottom({a}, {r}, (int64_t)({av[0]}), (double)({av[1]}))"
-        if m == "set_top_left_point":
-            return f"pf_box_set_top_left_point({a}, {r}, {av[0]})"
-        if m == "set_bottom_right_point":
-            return f"pf_box_set_bottom_right_point({a}, {r}, {av[0]})"
+        get, put = self._live_get, self._live_set
+        if m in ("get_left", "get_right", "get_top", "get_bottom"):
+            return get(f"pf_box_{m}", a, r)
+        if m in ("set_left", "set_right"):
+            return put(f"pf_box_{m}", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'))
+        if m in ("set_top", "set_bottom"):
+            return put(f"pf_box_{m}", a, r, f"(double)({av[0]})")
+        if m in ("set_lefttop", "set_rightbottom"):
+            return put(f"pf_box_{m}", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'), f"(double)({av[1]})")
+        if m in ("set_top_left_point", "set_bottom_right_point"):
+            return put(f"pf_box_{m}", a, r, av[0])
         if m == "set_xloc":
-            return f"pf_box_set_xloc({a}, {r}, (int64_t)({av[0]}), (int64_t)({av[1]}), {self._lower_xloc(raw[2])})"
+            return put("pf_box_set_xloc", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'), self._coerce_int_slot_with_cast(av[1], raw[1], 'int64_t'), self._lower_xloc(raw[2]))
         if m == "copy":
-            return f"pf_box_copy({a}, {r})"
+            return self._collected("box", f"pf_box_copy({a}, {r})")
         if m == "delete":
             return f"pf_box_delete({a}, {r})"
         return "0"
 
     def _emit_label_method(self, m, a, r, av, raw) -> str:
-        if m == "get_x":
-            return f"pf_label_get_x({a}, {r})"
-        if m == "get_y":
-            return f"pf_label_get_y({a}, {r})"
-        if m == "get_text":
-            return f"pf_label_get_text({a}, {r})"
+        get, put = self._live_get, self._live_set
+        if m in ("get_x", "get_y", "get_text"):
+            return get(f"pf_label_{m}", a, r)
         if m == "set_x":
-            return f"pf_label_set_x({a}, {r}, (int64_t)({av[0]}))"
+            return put("pf_label_set_x", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'))
         if m == "set_y":
-            return f"pf_label_set_y({a}, {r}, (double)({av[0]}))"
+            return put("pf_label_set_y", a, r, f"(double)({av[0]})")
         if m == "set_xy":
-            return f"pf_label_set_xy({a}, {r}, (int64_t)({av[0]}), (double)({av[1]}))"
+            return put("pf_label_set_xy", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'), f"(double)({av[1]})")
         if m == "set_point":
-            return f"pf_label_set_point({a}, {r}, {av[0]})"
+            return put("pf_label_set_point", a, r, av[0])
         if m == "set_xloc":
-            return f"pf_label_set_xloc({a}, {r}, (int64_t)({av[0]}), {self._lower_xloc(raw[1])})"
+            return put("pf_label_set_xloc", a, r, self._coerce_int_slot_with_cast(av[0], raw[0], 'int64_t'), self._lower_xloc(raw[1]))
         if m == "set_yloc":
-            return f"pf_label_set_yloc({a}, {r}, {self._lower_yloc(raw[0])})"
+            return put("pf_label_set_yloc", a, r, self._lower_yloc(raw[0]))
         if m == "set_text":
-            return f"pf_label_set_text({a}, {r}, {av[0]})"
+            return put("pf_label_set_text", a, r, av[0])
         if m == "copy":
-            return f"pf_label_copy({a}, {r})"
+            return self._collected("label", f"pf_label_copy({a}, {r})")
         if m == "delete":
             return f"pf_label_delete({a}, {r})"
         return "0"
 
     def _emit_linefill_method(self, m, a, r, av) -> str:
-        if m == "get_line1":
-            return f"pf_linefill_get_line1({a}, {r})"
-        if m == "get_line2":
-            return f"pf_linefill_get_line2({a}, {r})"
+        if m in ("get_line1", "get_line2"):
+            return self._live_get(f"pf_linefill_{m}", a, r)
         if m == "delete":
             return f"pf_linefill_delete({a}, {r})"
         return "0"
@@ -516,6 +586,16 @@ class DrawingVisitor:
 
         if self._drawing_call_is_void(node):
             return True
+        receiver = node.callee.object
+        if (isinstance(receiver, Identifier)
+                and (receiver.name, method) in _VOID_BUILTIN_CALLS):
+            return True
+        if (isinstance(receiver, MemberAccess)
+                and isinstance(receiver.object, Identifier)
+                and receiver.object.name == "strategy"
+                and receiver.member == "risk"):
+            # strategy.risk.* setters are statements (see _visit_stmt).
+            return True
         _fn, ns = self._resolve_callee(node.callee)
 
         if method in _MATRIX_VOID_METHODS:
@@ -571,6 +651,68 @@ class DrawingVisitor:
         recv_spec = param_spec or self._type_spec_from_expr(node.callee.object)
         return recv_spec is not None and recv_spec.kind == "map"
 
+    # ------------------------------------------------------------------
+    # Drawing lifetime: na(), the collection and its pins
+    # ------------------------------------------------------------------
+    def _drawing_na_expr(self, arg) -> str | None:
+        """``na(<line|box|label|linefill>)`` asks the arena, which knows a
+        deleted or collected drawing; ``is_na`` sees only a na handle."""
+        if not getattr(self, "_uses_drawing", False):
+            return None
+        spec = self._type_spec_from_expr(arg)
+        if spec is None or spec.kind != "udt" or spec.name not in DRAWING_ARENA:
+            return None
+        return f"_pf_drawing_na({DRAWING_ARENA[spec.name]}, {self._visit_expr(arg)})"
+
+    _DRAWING_PIN_DECL = re.compile(
+        r"^    (?:Series<(Line|Box|Label)>|(Line|Box|Label)) (\w+)\b")
+
+    @classmethod
+    def _drawing_pin_members(cls, declarations: list[str]) -> dict[str, list[str]]:
+        """The current value of every drawing-typed pinning variable, per kind.
+
+        ``declarations`` are the generated member lines of the ``var`` /
+        ``varip`` variables (global, block and callable, with their
+        per-call-site and fresh clones) and of the non-var variables whose
+        history is read. TradingView keeps a drawing one of them holds. A
+        drawing held only by an array, an object field, a local or a plain
+        non-var variable is collectable, as is one a ``var`` held before it
+        was reassigned (tests/fixtures/drawing_lifetime ``w9dg-pin-*``).
+        """
+        kinds = {"Line": "line", "Box": "box", "Label": "label"}
+        pins: dict[str, list[str]] = {kind: [] for kind in kinds.values()}
+        for line in declarations:
+            match = cls._DRAWING_PIN_DECL.match(line)
+            if match is None:
+                continue
+            series, plain, name = match.groups()
+            current = f"this->{name}[0]" if series else f"this->{name}"
+            pins[kinds[series or plain]].append(f"{current}.id")
+        return pins
+
+    def _emit_drawing_collectors(self, lines: list[str]) -> None:
+        """One collector per collected kind: a new drawing passes through it,
+        and the one that makes the kind's live count reach its
+        max_<kind>_count + 6 deletes the oldest drawings no pinning variable
+        (``_drawing_pin_members``) holds."""
+        pins = getattr(self, "_drawing_pins", None) or {}
+        caps = self._drawing_caps or {}
+        for dtype, collector in DRAWING_COLLECTED.items():
+            handle = DRAWING_TYPE_TO_CPP[dtype]
+            arena = DRAWING_ARENA[dtype]
+            keep = caps.get(dtype, 50)
+            held = ", ".join(["_pf_new.id", *pins.get(dtype, ())])
+            lines.extend([
+                f"    {handle} {collector}({handle} _pf_new) {{",
+                f"        if ((int)this->{arena}.order().size() >= {keep + DRAWING_COLLECTION_SLACK}) {{",
+                f"            const int32_t _pf_held[] = {{{held}}};",
+                f"            _pf_collect_drawings(this->{arena}, {keep}, _pf_held,",
+                "                                 sizeof(_pf_held) / sizeof(_pf_held[0]));",
+                "        }",
+                "        return _pf_new;",
+                "    }",
+            ])
+
     # ------------------------------------------------------------------
     # _uses_drawing detection + arena caps
     # ------------------------------------------------------------------