@pineforge/codegen-pyodide 0.8.0 → 0.9.0

package/pineforge_codegen/codegen/ta.py

@@ -28,7 +28,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from ..ast_nodes import (
-    Assignment, BinOp, ExprStmt, FuncCall, Ternary, UnaryOp, VarDecl,
+    Assignment, BinOp, BoolLiteral, ColorLiteral, ExprStmt, FuncCall,
+    Identifier, MemberAccess, NaLiteral, NumberLiteral, StringLiteral,
+    Subscript, Ternary, TupleLiteral, UnaryOp, VarDecl,
 )
 from .tables import TA_IMPLICIT_APPEND, TA_IMPLICIT_COMPUTE_FULL
 
@@ -221,6 +223,90 @@ class TaSiteHelper:
 
         return ""
 
+    # ------------------------------------------------------------------
+    # Precalculation safety
+    # ------------------------------------------------------------------
+
+    _PRECALC_BAR_IDENTIFIERS = {
+        "open", "high", "low", "close", "volume",
+        "hl2", "hlc3", "ohlc4", "hlcc4",
+        "time", "time_close", "bar_index",
+    }
+
+    def _is_precalc_replayed_source_var(self, name: str) -> bool:
+        """True for top-level ``x = input.source(...)`` variables replayed in
+        ``precalculate()``.
+
+        The precompute loop explicitly advances native source series and then
+        replays those source-input assignments before computing static TA
+        sites. Other user aliases, even when they are statically derived from
+        bar data (``src = close`` / ``ha_close = close``), are not replayed
+        there and must therefore use the normal per-bar TA path."""
+        ast = getattr(self.ctx, "ast", None)
+        for stmt in getattr(ast, "body", ()):
+            if (
+                isinstance(stmt, VarDecl)
+                and stmt.name == name
+                and isinstance(stmt.value, FuncCall)
+                and self._is_source_input(stmt.value)
+            ):
+                return True
+        return False
+
+    def _expr_safe_for_ta_precalc(self, expr) -> bool:
+        if expr is None:
+            return True
+        if isinstance(expr, (NumberLiteral, StringLiteral, BoolLiteral, NaLiteral, ColorLiteral)):
+            return True
+        if isinstance(expr, Identifier):
+            if expr.name in self._PRECALC_BAR_IDENTIFIERS:
+                return True
+            if self._is_precalc_replayed_source_var(expr.name):
+                return True
+            if expr.name in getattr(self.ctx, "series_vars", set()):
+                return False
+            return expr.name in getattr(self, "_static_vars", set())
+        if isinstance(expr, MemberAccess):
+            if isinstance(expr.object, Identifier) and (
+                expr.object.name.startswith("input") or expr.object.name in getattr(self, "_enum_defs", {})
+            ):
+                return True
+            return self._expr_safe_for_ta_precalc(expr.object)
+        if isinstance(expr, BinOp):
+            return self._expr_safe_for_ta_precalc(expr.left) and self._expr_safe_for_ta_precalc(expr.right)
+        if isinstance(expr, UnaryOp):
+            return self._expr_safe_for_ta_precalc(expr.operand)
+        if isinstance(expr, Ternary):
+            return (
+                self._expr_safe_for_ta_precalc(expr.condition)
+                and self._expr_safe_for_ta_precalc(expr.true_val)
+                and self._expr_safe_for_ta_precalc(expr.false_val)
+            )
+        if isinstance(expr, Subscript):
+            return self._expr_safe_for_ta_precalc(expr.object) and self._expr_safe_for_ta_precalc(expr.index)
+        if isinstance(expr, TupleLiteral):
+            return all(self._expr_safe_for_ta_precalc(elem) for elem in expr.elements)
+        if isinstance(expr, FuncCall):
+            if isinstance(expr.callee, MemberAccess) and isinstance(expr.callee.object, Identifier):
+                if expr.callee.object.name in ("math", "str", "color"):
+                    return all(self._expr_safe_for_ta_precalc(arg) for arg in expr.args)
+            return False
+        return False
+
+    def _ta_site_uses_precalc(self, site: "TACallSite") -> bool:
+        """Whether a static TA site can safely read from ``_precalc_*``.
+
+        Static-ness from the analyzer means the expression can be represented
+        from bar data and constants, but the standalone precompute loop only
+        replays a narrow subset of per-bar assignments. A user alias such as
+        ``ha_close = close`` is static in that analyzer sense, yet its Series is
+        empty during precompute, so ``ta.stdev(ha_close, 20)`` precalculates as
+        all-``na``. Opting that site out preserves correctness; it simply uses
+        the ordinary stateful TA object during ``on_bar``."""
+        if not getattr(site, "is_static", False):
+            return False
+        return all(self._expr_safe_for_ta_precalc(arg) for arg in site.compute_args)
+
     def _security_ta_compute_args_for_site(
         self,
         sec_id: int,

package/pineforge_codegen/codegen/tables.py

@@ -55,7 +55,7 @@ def tz_time_field_lambda(field_expr: str, ts_arg: str, tz_arg: str) -> str:
     """
     return (
         "[&]() -> int { "
-        f"std::string _tz = ({tz_arg}); "
+        f"std::string _tz = pineforge::normalize_timezone_for_posix(({tz_arg})); "
         f"time_t _secs = (time_t)(({ts_arg}) / 1000); "
         "struct tm tm_buf; "
         "if (_tz.empty() || _tz == \"UTC\" || _tz == \"Etc/UTC\") { "
@@ -76,11 +76,11 @@ def tz_time_field_lambda(field_expr: str, ts_arg: str, tz_arg: str) -> str:
 
 
 BAR_BUILTINS = {
-    "bar_index": "bar_index_",
+    "bar_index": "pine_bar_index()",
     "time": "current_bar_.timestamp",
     "time_close": "time_close()",
     "timenow": "current_bar_.timestamp",
-    "last_bar_index": "last_bar_index_",
+    "last_bar_index": "pine_last_bar_index()",
     "last_bar_time": "last_bar_time_",
     # time_tradingday: Unix-ms of the session-open of the trading day that
     # contains the current bar. Backed by pine_time_tradingday() in the engine.
@@ -96,10 +96,12 @@ BAR_BUILTINS = {
     # ``_bar_hour()`` helpers. For UTC-exchange data (the crypto corpus,
     # SymInfo's constructor default) the lambda takes the gmtime_r fast
     # path and is value-identical to the old emission.
+    # Route through the engine's cached pine_hour/pine_minute/... (session_time.hpp)
+    # instead of an inline per-call setenv+tzset lambda — the lambda's TZ churn
+    # caused a macOS tzset()->notifyd IPC storm (KI-35). The engine helpers are
+    # value-identical (same tm fields + Pine offsets) but tzset-churn-free.
     **{
-        name: tz_time_field_lambda(
-            TIME_FIELD_EXPRS[name], "current_bar_.timestamp", "syminfo_.timezone"
-        )
+        name: f"pine_{name}(current_bar_.timestamp, syminfo_.timezone)"
         for name in ("hour", "minute", "second", "dayofmonth", "dayofweek",
                      "month", "year", "weekofyear")
     },
@@ -113,7 +115,27 @@ BAR_SERIES_PUSH = {
     "ohlc4": "((current_bar_.open + current_bar_.high + current_bar_.low + current_bar_.close) / 4.0)",
 }
 
-# OHLCV identifiers that refer to the *security* (HTF) bar inside ``request.security()``.
+# Bar identifiers that refer to the *security* (HTF) bar inside
+# ``request.security()``. ``time`` is the HTF bar-open timestamp.
+SECURITY_BAR_FIELD_EXPRS = {
+    "open": "bar.open",
+    "high": "bar.high",
+    "low": "bar.low",
+    "close": "bar.close",
+    "volume": "bar.volume",
+    "time": "bar.timestamp",
+}
+SECURITY_BAR_FIELD_TYPES = {
+    "open": "double",
+    "high": "double",
+    "low": "double",
+    "close": "double",
+    "volume": "double",
+    "time": "int64_t",
+}
+SECURITY_BAR_FIELDS = frozenset(SECURITY_BAR_FIELD_EXPRS)
+
+# Backwards-compatible name for consumers that only need the OHLCV subset.
 SECURITY_OHLC_BAR_FIELDS = frozenset({"open", "high", "low", "close", "volume"})
 
 # Generated C++ runtime function names referenced by the codegen as string
@@ -255,7 +277,12 @@ TA_TUPLE_FIELDS = {
 # must be promoted to ``int64_t`` so the ``na`` sentinel (``INT64_MIN``)
 # survives — narrowing to 32-bit ``int`` collapses it to ``0`` and breaks
 # ``is_na<int>`` detection.
-INT64_BUILTINS = {"time", "time_close", "timestamp", "time_tradingday"}
+INT64_BUILTINS = {"time", "time_close", "timenow", "timestamp", "time_tradingday"}
+
+# Subset of INT64_BUILTINS spelled as a bare identifier (no call args) in Pine.
+# ``entryTime := time`` parses the RHS as an ``Identifier`` named ``time`` (not a
+# ``FuncCall``), so int64 promotion must match these by identifier name too.
+INT64_BUILTIN_IDENTIFIERS = {"time", "time_close", "timenow"}
 
 PINE_TYPE_TO_CPP = {
     "int": "int", "float": "double", "bool": "bool", "string": "std::string",
@@ -263,15 +290,66 @@ PINE_TYPE_TO_CPP = {
     PineType.STRING: "std::string", PineType.NA: "double",
     PineType.UNKNOWN: "double", PineType.VOID: "double",
     PineType.COLOR: "int",
+    # Drawing-objects-as-data: the value-view handle structs (see
+    # drawing.hpp). Explicit-hint decls (``var line x``), UDT-method drawing
+    # params, and ``_type_for_decl`` resolve through here.
+    "line": "Line", "box": "Box", "label": "Label",
+    "linefill": "Linefill", "chart.point": "ChartPoint",
 }
 
+# ---------------------------------------------------------------------------
+# Drawing-objects-as-data (spec §4.1)
+# ---------------------------------------------------------------------------
+# Pine drawing type name -> C++ handle struct (pineforge/drawing.hpp).
+# ``table`` / ``polyline`` are DELIBERATELY absent — they stay 100% no-op
+# (kept in SKIP_NAMESPACES / SKIP_VAR_TYPES / _DRAWING_TYPES_INIT).
+DRAWING_TYPE_TO_CPP = {
+    "line": "Line", "box": "Box", "label": "Label",
+    "linefill": "Linefill", "chart.point": "ChartPoint",
+}
+# Function-call namespaces routed to the per-type arena dispatch.
+DRAWING_NS = {"line", "box", "label", "linefill"}
+# Constant member reads (``line.style_solid`` -> "0"). chart.point/linefill
+# carry no style constants.
+DRAWING_STYLE_NS = {"line", "box", "label"}
+# Per-type arena member name on the generated strategy.
+DRAWING_ARENA = {
+    "line": "_pf_lines_", "box": "_pf_boxes_",
+    "label": "_pf_labels_", "linefill": "_pf_linefills_",
+}
+
+# Pine typed array constructors for drawing handles — ``array.new_line(...)``
+# is the typed alias of ``array.new<line>(...)`` (and likewise for box/label/
+# linefill). Maps the constructor name to the drawing element type name, so the
+# element TypeSpec resolves to the C++ handle struct (Line/Box/Label/Linefill).
+ARRAY_DRAWING_NEW_CTORS = {
+    "new_line": "line", "new_box": "box",
+    "new_label": "label", "new_linefill": "linefill",
+}
+# Pine array methods whose C++ lowering is void (or a non-scalar iterator) and
+# whose Pine semantics is mutate-in-place: a function whose body ends in one of
+# these returns void, so the codegen must emit it as a statement + default
+# return rather than ``return arr.clear();`` / ``return arr.insert(...);``.
+ARRAY_VOID_METHODS = frozenset({
+    "push", "unshift", "insert", "clear", "set", "fill",
+    "sort", "reverse", "concat",
+})
+# All recognised ``array.new_*`` scalar+drawing constructor names (``new`` itself
+# is template-form and handled separately).
+ARRAY_NEW_CTORS = frozenset(
+    {"new_float", "new_int", "new_bool", "new_string"} | set(ARRAY_DRAWING_NEW_CTORS)
+)
+
 SKIP_FUNC_NAMES = {
     "plot", "plotshape", "plotchar", "plotcandle", "plotbar", "plotarrow",
     "fill", "hline", "barcolor", "bgcolor", "alert", "alertcondition",
 }
+# line / box / label / linefill REMOVED — they now route to real drawing
+# codegen (gated on _uses_drawing). table / polyline / chart / display / size
+# / position stay no-op.
 SKIP_NAMESPACES = {
-    "table", "label", "line", "box", "polyline", "chart",
-    "linefill", "display", "size", "position",
+    "table", "polyline", "chart",
+    "display", "size", "position",
 }
 SKIP_VAR_TYPES = {"table"}
 
@@ -578,6 +656,33 @@ MATRIX_METHODS = {
 # Math / String dispatch
 # ---------------------------------------------------------------------------
 
+def _math_minmax_na_expr(func_name: str, args: list[str]) -> str:
+    """Emit Pine-compatible math.min/math.max with na propagation.
+
+    ``std::min``/``std::max`` do not propagate NaN consistently because their
+    comparison is specified in terms of ``operator<``. Pine math.min/max return
+    ``na`` when any operand is ``na``, so generated clamp-style expressions
+    like ``math.max(-1, math.min(1, na))`` must stay ``na``.
+    """
+    if not args:
+        return "na<double>()"
+    if len(args) == 1:
+        return f"(double)({args[0]})"
+    op = "std::max" if func_name == "max" else "std::min"
+    decls = " ".join(
+        f"double _v{i} = (double)({arg});" for i, arg in enumerate(args)
+    )
+    guard = " || ".join(f"is_na(_v{i})" for i in range(len(args)))
+    updates = " ".join(
+        f"_out = {op}(_out, _v{i});" for i in range(1, len(args))
+    )
+    return (
+        f"([&]() -> double {{ {decls} "
+        f"if ({guard}) return na<double>(); "
+        f"double _out = _v0; {updates} return _out; }}())"
+    )
+
+
 MATH_FUNC_MAP = {
     "abs": "std::abs", "max": "std::max", "min": "std::min",
     "ceil": "std::ceil", "floor": "std::floor", "round": "std::round",