@pineforge/codegen-pyodide 0.9.0 → 0.10.1

package/pineforge_codegen/codegen/visit_expr.py

@@ -166,6 +166,21 @@ _BUILTIN_NAMESPACE_NAMES: frozenset[str] = frozenset({
 })
 
 
+# KI-71/KI-73: Pine relational comparisons (``==`` ``!=`` ``<`` ``>``
+# ``<=`` ``>=``) with an ``na`` operand evaluate *falsy*. Pine also treats
+# finite float operands at most 1e-10 apart as equal, independent of their
+# magnitude. Naive C++ relationals honour neither rule completely, so numeric
+# comparisons route through the shared lowering below.
+_RELATIONAL_OPS: frozenset[str] = frozenset({"==", "!=", "<", ">", "<=", ">="})
+
+# C++ scalar types carrying a detectable ``na`` sentinel via ``is_na``:
+# ``double`` -> NaN (IEEE), ``int``/``int64_t`` -> ``numeric_limits<T>::min()``.
+# Only these route through the na-aware relational lowering — ``is_na`` has no
+# overload for ``bool``/``std::string``/vector/UDT-value operands, and Pine's
+# na-bool is engine-indistinguishable from ``false`` (na<bool>() == false).
+_NA_SCALAR_CPP: frozenset[str] = frozenset({"int", "int64_t", "double"})
+
+
 class ExprVisitor:
     """Expression-level visitor methods shared across the codegen.
 
@@ -207,7 +222,21 @@ class ExprVisitor:
         if isinstance(node, Subscript):
             return self._visit_subscript(node)
         if isinstance(node, TupleLiteral):
-            elems = ", ".join(self._visit_expr(e) for e in node.elements)
+            elems = []
+            for element in node.elements:
+                element_spec = self._type_spec_from_expr(element)
+                element_target = None
+                if (element_spec is not None
+                        and element_spec.kind == "udt"
+                        and element_spec.name in DRAWING_TYPE_TO_CPP):
+                    element_target = self._type_spec_to_cpp(element_spec)
+                elems.append(
+                    self._visit_rhs_value(
+                        element,
+                        target_cpp_type=element_target,
+                    )
+                )
+            elems = ", ".join(elems)
             return f"std::make_tuple({elems})"
         return "/* unknown */"
 
@@ -219,34 +248,132 @@ class ExprVisitor:
         return (isinstance(node, NaLiteral)
                 or (isinstance(node, Identifier) and node.name == "na"))
 
-    def _drawing_na_default(self, target_name: str | None) -> str | None:
-        """If ``target_name`` is a drawing-handle variable (line/box/label/
-        linefill/chart.point), return its na default literal (e.g. ``Box{}`` —
-        a default-constructed handle whose id == -1 == na); otherwise None."""
+    def _drawing_target_cpp_type(
+        self,
+        target_name: str | None,
+        target_cpp_type: str | None,
+    ) -> str | None:
+        """Resolve a drawing target without leaking a shadowed global type.
+
+        An explicit contextual type always wins.  For reassignments, where the
+        caller may not have one, consult function-local and parameter types
+        before the analyzer's flat global drawing registry.  A same-named
+        scalar local/parameter must therefore block the global fallback.
+        """
+        if target_cpp_type is not None:
+            return (
+                target_cpp_type
+                if target_cpp_type in DRAWING_TYPE_TO_CPP.values()
+                else None
+            )
+        if not target_name:
+            return None
+        if target_name in self._lexical_drawing_types:
+            return self._lexical_drawing_types[target_name]
+        param_spec = getattr(self, "_current_func_param_specs", {}).get(
+            target_name
+        )
+        if (param_spec is not None
+                and param_spec.kind == "udt"
+                and param_spec.name in DRAWING_TYPE_TO_CPP):
+            return DRAWING_TYPE_TO_CPP[param_spec.name]
+        for scoped_types in (
+            getattr(self, "_current_func_local_types", {}),
+            getattr(self, "_current_func_param_types", {}),
+        ):
+            if target_name in scoped_types:
+                scoped_type = scoped_types[target_name].removesuffix("&")
+                return (
+                    scoped_type
+                    if scoped_type in DRAWING_TYPE_TO_CPP.values()
+                    else None
+                )
+        # Only declarations already emitted into the current lexical path may
+        # shadow a global.  Scanning the whole future function body makes a
+        # later local declaration pre-shadow earlier statements.  Exact
+        # top-level types are captured separately because the analyzer's flat
+        # raw-name registry can be overwritten by a same-named local.
+        return self._global_drawing_cpp_types.get(target_name)
+
+    def _udt_target_cpp_type(
+        self,
+        *,
+        target_name: str | None = None,
+        target_node=None,
+        type_hint: str | None = None,
+    ) -> str | None:
+        """Return the exact authored UDT type for a contextual RHS target.
+
+        Pine's bare ``na`` is target typed.  Arbitrary UDTs represent their na
+        ID with a default-constructed ``T{}``, just as generated drawing
+        handles do, but the drawing-only registry cannot safely answer for
+        same-spelled ordinary UDT declarations in sibling blocks/functions.
+        Prefer explicit/node context, then the source-ordered lexical map, and
+        consult legacy raw-name metadata only when no lexical binding exists.
+        """
+        spec = self._type_spec_from_hint_name(type_hint) if type_hint else None
+        if spec is None and target_node is not None:
+            spec = self._type_spec_from_expr(target_node)
+        if spec is not None and spec.kind == "udt" and spec.name in self._udt_defs:
+            return spec.name
         if not target_name:
             return None
-        udt = self._udt_var_types.get(target_name)
-        if udt in DRAWING_TYPE_TO_CPP:
-            return f"{DRAWING_TYPE_TO_CPP[udt]}{{}}"
-        return None
+        udt_name = self._identifier_udt_type(target_name)
+        return udt_name if udt_name in self._udt_defs else None
 
     def _visit_rhs_value(self, value_node, target_name: str | None = None,
                          target_cpp_type: str | None = None) -> str:
         """Visit an assignment / declaration RHS.
 
         A bare ``na`` lowers to a type-appropriate initializer for the target
-        instead of ``na<double>()``: drawing handles brace-init to their na
-        handle (``Box{}`` / ``Line{}`` / …); ``std::string``/``int``/``int64_t``/
-        ``bool`` use ``na<T>()``. Without this, ``Box b = na;`` and
-        ``string s = na;`` would both emit ``na<double>()`` and fail to compile
-        (no viable ``operator=`` / conversion). Every other RHS lowers unchanged.
+        instead of ``na<double>()``: drawing and authored UDT handles
+        brace-init to their na object (``Box{}`` / ``State{}``), while
+        ``std::string``/``int``/``int64_t``/``bool`` use ``na<T>()``. Without
+        this, ``State s = na;`` and ``string x = na;`` would both emit
+        ``na<double>()`` and fail to compile (no viable assignment/conversion).
+        Every other RHS lowers unchanged.
         """
-        if target_name and self._is_na_expr(value_node):
-            draw_default = self._drawing_na_default(target_name)
-            if draw_default is not None:
-                return draw_default
+        drawing_target = self._drawing_target_cpp_type(
+            target_name,
+            target_cpp_type,
+        )
+        if self._is_na_expr(value_node):
+            if drawing_target is not None:
+                return f"{drawing_target}{{}}"
+            if target_cpp_type in self._udt_defs:
+                return f"{target_cpp_type}{{}}"
+            if self._is_nullable_collection_cpp_type(target_cpp_type):
+                # Maps and matrices use default construction for a typed
+                # ``na`` ID. Their ``*.new`` factories create a valid ID,
+                # including a valid empty collection.
+                return f"{target_cpp_type}{{}}"
             if target_cpp_type in ("std::string", "int", "int64_t", "bool"):
                 return f"na<{target_cpp_type}>()"
+        if (isinstance(value_node, Ternary)
+                and (self._is_nullable_collection_cpp_type(target_cpp_type)
+                     or drawing_target is not None
+                     or target_cpp_type in self._udt_defs)):
+            # C++ cannot deduce a common type for ``na<double>()`` and a
+            # collection/drawing handle. Pine's ternary is target typed, so
+            # propagate the exact declared/reassignment target into both arms.
+            # Arrays and scalar ternaries retain the established generic path;
+            # target typing is safe only for collections with nullable runtime
+            # representations.
+            branch_target = drawing_target or target_cpp_type
+            condition = self._visit_expr(value_node.condition)
+            true_value = self._visit_rhs_value(
+                value_node.true_val,
+                target_name,
+                target_cpp_type=branch_target,
+            )
+            false_value = self._visit_rhs_value(
+                value_node.false_val,
+                target_name,
+                target_cpp_type=branch_target,
+            )
+            return (
+                f"(({condition}) ? ({true_value}) : ({false_value}))"
+            )
         return self._visit_expr(value_node)
 
     def _visit_ident(self, node: Identifier) -> str:
@@ -254,6 +381,9 @@ class ExprVisitor:
         # Bare 'na' identifier → na<double>()
         if name == "na":
             return "na<double>()"
+        pending_outer = getattr(self, "_pending_decl_outer_alias", {})
+        if name in pending_outer:
+            return pending_outer[name]
         # Function parameters that are series — read current value
         if name in self._current_func_series_params:
             return f"{self._safe_name(name)}[0]"
@@ -267,7 +397,9 @@ class ExprVisitor:
         # Inline known constants (literals). Input-backed names are NOT inlined
         # because strategy_set_input() can override them at runtime; emit the
         # variable name and let get_input_*() produce the current value.
-        if name in self._known_vars and name not in self._input_backed_vars:
+        if (name in self._known_vars
+                and name not in self._input_backed_vars
+                and not self._known_var_is_lexically_shadowed(name)):
             val = self._known_vars[name]
             if isinstance(val, bool):
                 return "true" if val else "false"
@@ -302,7 +434,7 @@ class ExprVisitor:
         # Apply per-call-site var remap (for function-local vars)
         if self._active_var_remap and safe in self._active_var_remap:
             safe = self._active_var_remap[safe]
-        if name in self.ctx.series_vars:
+        if self._binding_is_series(name, safe):
             return f"{safe}[0]"
         # Safety net: by here the name resolved to none of the builtins,
         # constants, parameters, or declared variables handled above, so
@@ -363,6 +495,16 @@ class ExprVisitor:
             return True
         return False
 
+    def _visit_mutable_expr(self, node: ASTNode) -> str:
+        """Lower an assignment target with UDT journal capture enabled."""
+
+        previous = getattr(self, "_udt_mutable_expr_depth", 0)
+        self._udt_mutable_expr_depth = previous + 1
+        try:
+            return self._visit_expr(node)
+        finally:
+            self._udt_mutable_expr_depth = previous
+
     def _visit_member_access(self, node: MemberAccess) -> str:
         # UDT field whose type was a drawing primitive (label/line/box/
         # linefill/polyline/table/chart.point) — the field is dropped from
@@ -371,6 +513,34 @@ class ExprVisitor:
         # See: pineforge-codegen issue #10.
         if self._is_omitted_udt_field(node):
             return "/* drawing field omitted */ 0"
+
+        # User-defined objects are numeric handles into a per-type arena.  The
+        # arena lookup returns a real record lvalue, so this one lowering serves
+        # reads, assignment targets, nested field chains and method receivers.
+        owner_spec = self._type_spec_from_expr(node.object)
+        if (
+            owner_spec is not None
+            and owner_spec.kind == "udt"
+            and owner_spec.name in self._udt_defs
+        ):
+            owner = self._visit_expr(node.object)
+            arena = self._udt_arena_member_name(owner_spec.name)
+            field_spec = (
+                self._udt_field_type_specs.get(owner_spec.name, {}).get(
+                    node.member
+                )
+            )
+            mutable_collection = (
+                field_spec is not None
+                and field_spec.kind in {"array", "map", "matrix"}
+            )
+            access = (
+                "get"
+                if getattr(self, "_udt_mutable_expr_depth", 0)
+                or mutable_collection
+                else "read"
+            )
+            return f"{arena}.{access}({owner}).{node.member}"
         if isinstance(node.object, Identifier):
             ns = node.object.name
             if ns == "strategy":
@@ -750,16 +920,118 @@ class ExprVisitor:
                 safe = self._safe_name(name)
                 if self._active_var_remap and safe in self._active_var_remap:
                     safe = self._active_var_remap[safe]
-                # Pointer-aliased UDT local (BUG C, rebinding case): field access
-                # goes through ``->`` since the local holds ``UDT*``.
-                if name in self._udt_ptr_alias_locals:
-                    return f"{safe}->{node.member}"
                 return f"{safe}.{node.member}"
             if name not in self.ctx.series_vars:
                 # Unknown identifier — likely an enum value
                 return f'std::string("{node.member}")'
         return f"{obj}.{node.member}"
 
+    def _operand_na_kind(self, node, cpp_type: str) -> str | None:
+        """Classify a relational operand by the ``na`` sentinel it can carry.
+
+        Returns:
+
+        * ``"int"``   — an ``int``/``int64_t`` expression that can hold the
+          ``INT_MIN`` sentinel. Because that sentinel is a *finite* very-negative
+          integer (not NaN), naive C++ diverges from Pine's falsy-on-na rule for
+          EVERY relational — ordered (``<`` ``>`` ``<=`` ``>=``) and equality
+          (``==`` ``!=``) alike.
+        * ``"float"`` — a ``double`` expression that can hold NaN. IEEE already
+          yields ``false`` for ``==`` ``<`` ``>`` ``<=`` ``>=`` against NaN
+          (matching Pine's falsy), so the ONLY diverging float cell is ``!=``
+          (IEEE ``NaN != x`` is true; Pine is falsy).
+        * ``None``     — provably not na (numeric/bool literal, inlined
+          compile-time constant) or a non-scalar type with no ``is_na`` overload;
+          the naive emission is already correct.
+        """
+        if cpp_type not in _NA_SCALAR_CPP:
+            return None
+        # Literals are never na.
+        if isinstance(node, (NumberLiteral, BoolLiteral)):
+            return None
+        # A bare ``na`` lowers to ``na<double>()`` — a real NaN, i.e. it IS na.
+        if self._is_na_expr(node):
+            return "float"
+        # Inlined compile-time constants (non-input known vars) never hold na.
+        if (isinstance(node, Identifier)
+                and node.name in self._known_vars
+                and node.name not in self._input_backed_vars
+                and not self._known_var_is_lexically_shadowed(node.name)):
+            return None
+        return "int" if cpp_type in ("int", "int64_t") else "float"
+
+    def _emit_na_relational(self, op: str, left: str, right: str) -> str:
+        """Emit an na-aware relational: ``false`` when either operand is ``na``.
+
+        Mirrors the ``nz()`` lambda idiom (``visit_call``): each operand is
+        hoisted to a temporary so a stateful operand expression is evaluated
+        exactly once (no double-step), then compared only when neither side is
+        na. ``is_na`` resolves via the emitted ``using namespace pineforge;``
+        (``double`` -> ``isnan``; integral -> ``== numeric_limits<T>::min()``).
+        """
+        return (f"([&]{{ auto _pna_l = ({left}); auto _pna_r = ({right}); "
+                f"return !is_na(_pna_l) && !is_na(_pna_r) && "
+                f"(_pna_l {op} _pna_r); }}())")
+
+    def _emit_float_relational(self, op: str, left: str, right: str) -> str:
+        """Emit Pine's na-aware float comparator with its fixed equality band.
+
+        Pine evaluates each operand once, rejects ``na``, and converts an int
+        to float when paired with a float. TradingView oracle probes pin a
+        magnitude-independent comparison band: finite operands with
+        ``abs(left - right) <= 1e-10`` compare equal. Every ordered operator is
+        derived from that same predicate, so strict ``<``/``>`` are suppressed
+        inside the band while ``<=``/``>=`` accept it.
+
+        Exact equality is checked first so equal infinities remain equal;
+        opposite infinities and finite/infinite pairs remain normally ordered.
+        The subtraction can overflow only to infinity, which is safely outside
+        the equality band. The preceding ``is_na`` guard keeps every NaN
+        comparison falsy, including ``!=``.
+        """
+        compare = {
+            "==": "_pfc_eq",
+            "!=": "!_pfc_eq",
+            "<": "(_pfc_l < _pfc_r) && !_pfc_eq",
+            ">": "(_pfc_l > _pfc_r) && !_pfc_eq",
+            "<=": "(_pfc_l < _pfc_r) || _pfc_eq",
+            ">=": "(_pfc_l > _pfc_r) || _pfc_eq",
+        }[op]
+        return (
+            f"([&]{{ auto _pna_l = ({left}); auto _pna_r = ({right}); "
+            "double _pfc_l = static_cast<double>(_pna_l); "
+            "double _pfc_r = static_cast<double>(_pna_r); "
+            "bool _pfc_eq = (_pfc_l == _pfc_r) || "
+            "(std::isfinite(_pfc_l) && std::isfinite(_pfc_r) && "
+            "std::fabs(_pfc_l - _pfc_r) <= 1e-10); "
+            f"return !is_na(_pna_l) && !is_na(_pna_r) && "
+            f"({compare}); }}())"
+        )
+
+    def _lower_relational(self, op: str, left_node, right_node,
+                          left_cpp: str, right_cpp: str) -> str:
+        """Lower a Pine relational with Pine's na and float-precision rules.
+
+        Shared by ``_visit_binop`` and the ``request.security`` expression
+        builder so EVERY relational emission site honours Pine's rules. Any
+        numeric comparison involving an inferred float gets the fixed-band
+        wrapper for all six operators. Pure integer comparisons get the smaller
+        KI-71 wrapper only when an operand can carry the INT_MIN ``na`` sentinel.
+        Non-relational operators and nonnumeric operands fall through unchanged.
+        """
+        if op in _RELATIONAL_OPS:
+            lt = self._infer_type(left_node)
+            rt = self._infer_type(right_node)
+            if lt in _NA_SCALAR_CPP and rt in _NA_SCALAR_CPP:
+                if "double" in (lt, rt):
+                    return self._emit_float_relational(op, left_cpp, right_cpp)
+                lk = self._operand_na_kind(left_node, lt)
+                rk = self._operand_na_kind(right_node, rt)
+                int_na = "int" in (lk, rk)
+                if int_na:
+                    return self._emit_na_relational(op, left_cpp, right_cpp)
+        return f"({left_cpp} {op} {right_cpp})"
+
     def _visit_binop(self, node: BinOp) -> str:
         left = self._visit_expr(node.left)
         right = self._visit_expr(node.right)
@@ -786,7 +1058,7 @@ class ExprVisitor:
         # Ref: https://www.tradingview.com/pine-script-docs/concepts/operators/
         if node.op == "/":
             return f"((double)({left}) / (double)({right}))"
-        return f"({left} {op} {right})"
+        return self._lower_relational(op, node.left, node.right, left, right)
 
     def _visit_unaryop(self, node: UnaryOp) -> str:
         operand = self._visit_expr(node.operand)
@@ -807,16 +1079,17 @@ class ExprVisitor:
             if name in BAR_FIELDS or name in BAR_SERIES_PUSH:
                 # Index matches Pine: [0] current bar, [k] k bars ago (runtime Series deque).
                 return f"_s_{name}[{idx}]"
-            if name in self.ctx.series_vars:
-                safe = self._safe_name(name)
-                # Apply per-call-site var remap
-                if self._active_var_remap and safe in self._active_var_remap:
-                    safe = self._active_var_remap[safe]
+            safe = self._safe_name(name)
+            # Apply per-call-site / exact block-member remap before deciding
+            # whether the current lexical binding is a Series.
+            if self._active_var_remap and safe in self._active_var_remap:
+                safe = self._active_var_remap[safe]
+            if self._binding_is_series(name, safe):
                 # Same Pine [k] semantics as Series in runtime/series.hpp
                 return f"{safe}[{idx}]"
-            spec = self._collection_types.get(name)
+            spec = self._collection_spec_for_name(name)
             if spec is not None and spec.kind in ("array", "map"):
-                return f"{self._safe_name(name)}[{idx}]"
+                return f"{self._collection_receiver_expr(name)}[{idx}]"
         # Handle strategy.* history access (e.g., strategy.position_size[1])
         if isinstance(node.object, MemberAccess):
             if isinstance(node.object.object, Identifier):
@@ -843,9 +1116,57 @@ class ExprVisitor:
         if isinstance(node.object, FuncCall):
             inner = self._visit_expr(node.object)
             cpp_t = self._infer_type(node.object)
-            if cpp_t not in ("double", "int", "bool"):
+            if cpp_t not in ("double", "int", "int64_t", "bool"):
                 cpp_t = "double"
             member = self._inline_history_member("hist_call", node)
+            ta_site = self._get_ta_site(node.object)
+            ta_name = (
+                self._ta_name_from_site(ta_site)
+                if ta_site is not None
+                else ""
+            )
+            if (
+                ta_site is not None
+                and ta_name in {"highest", "lowest"}
+                and self._ta_site_uses_precalc(ta_site)
+            ):
+                # Static chart Highest/Lowest sites already advance in the
+                # full-bar precalculation pass, including when the source call
+                # sits behind a Pine-v6 lazy boolean edge. Their direct history
+                # operator must use that same chart-bar clock. Advancing only
+                # ``_hist_call`` when the lazy RHS is reached changes ``[1]``
+                # into "previous evaluation" and can permanently miss a first
+                # qualifying signal (Filter V2's source-bound v6 oracle).
+                #
+                # Keep evaluation lazy: this branch only reads the immutable
+                # precalculated result when the expression is reached. Dynamic
+                # runs, UDF sites, and non-precalculated calls retain the
+                # established call-local history fallback below.
+                ta_mem = self._ta_member_name(ta_site)
+                precalc = f"_precalc_{ta_mem}"
+                return (
+                    f"([&]() -> {cpp_t} {{ "
+                    f"if (_use_precalc) {{ "
+                    f"auto _pf_hist_offset_raw = ({idx}); "
+                    f"if (is_na(_pf_hist_offset_raw)) return na<{cpp_t}>(); "
+                    f"long double _pf_hist_offset_numeric = "
+                    f"static_cast<long double>(_pf_hist_offset_raw); "
+                    f"if (bar_index_ < 0 || _pf_hist_offset_numeric < 0.0L || "
+                    f"_pf_hist_offset_numeric > "
+                    f"static_cast<long double>(bar_index_)) "
+                    f"return na<{cpp_t}>(); "
+                    f"std::size_t _pf_hist_offset = "
+                    f"static_cast<std::size_t>(_pf_hist_offset_numeric); "
+                    f"std::size_t _pf_hist_bar = "
+                    f"static_cast<std::size_t>(bar_index_) - _pf_hist_offset; "
+                    f"if (_pf_hist_bar >= {precalc}.size()) "
+                    f"return na<{cpp_t}>(); "
+                    f"return {precalc}[(std::size_t)_pf_hist_bar]; }} "
+                    f"{cpp_t} _hv = ({inner}); "
+                    f"if (history_advances_new_bar()) {member}.push(_hv); "
+                    f"else {member}.update(_hv); "
+                    f"return {member}[(int)({idx})]; }}())"
+                )
             return (
                 f"([&]() -> {cpp_t} {{ "
                 f"{cpp_t} _hv = ({inner}); "