pineforge-codegen 0.9.0__tar.gz → 0.10.0__tar.gz

{pineforge_codegen-0.9.0 → pineforge_codegen-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineforge-codegen
-Version: 0.9.0
+Version: 0.10.0
 Summary: PineScript v6 to C++ transpiler that targets the pineforge-engine runtime.
 Project-URL: Homepage, https://github.com/pineforge-4pass/pineforge-codegen-oss
 Project-URL: Issues, https://github.com/pineforge-4pass/pineforge-codegen-oss/issues

pineforge_codegen-0.10.0/VERSION

@@ -0,0 +1 @@
+0.10.0

{pineforge_codegen-0.9.0 → pineforge_codegen-0.10.0}/pineforge_codegen/codegen/base.py

@@ -1262,6 +1262,11 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # First, find all variables that are reassigned anywhere in the AST.
         # These cannot be inlined as constants since their value changes at runtime.
         reassigned = self._find_reassigned_vars()
+        # Register never-reassigned ``var``/``varip`` scalars with a stable
+        # init FIRST — a later derived var (or a UDF body) may reference such a
+        # scalar as a stable length component, so it must be classified stable
+        # before those exprs are evaluated below.
+        self._collect_stable_var_scalars(reassigned)
         for stmt in self.ctx.ast.body:
             if isinstance(stmt, VarDecl) and stmt.name not in reassigned:
                 self._collect_known_var(stmt)
@@ -1274,6 +1279,48 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         # dependent reassignments are left untracked (rejected by the guard).
         self._collect_reassigned_stable_scalars(reassigned)
 
+    def _collect_stable_var_scalars(self, reassigned: set[str]) -> None:
+        """Track top-level ``var``/``varip`` scalars declared exactly once (never
+        reassigned) from a stable init expression.
+
+        A ``var`` scalar's one-shot initializer runs once and the value never
+        changes across bars, so a never-reassigned ``var`` over a stable init
+        (``var int _tfSec = timeframe.in_seconds()``) is a bar-invariant scalar —
+        safe to embed in a TA ctor runtime-reset expression. Recording it in
+        ``_derived_input_expr`` + ``_stable_runtime_vars`` lets the reset path
+        expand the name and lets ``_expr_is_stable`` classify it (the
+        ``_stable_runtime_vars`` check precedes the ``_var_names`` rejection).
+
+        A ``var`` that is reassigned anywhere (``:=`` in ``reassigned``), is a
+        series var, or is initialized from a non-stable value stays untracked —
+        so a TA length fed by genuinely-mutable persistent state is still
+        rejected by the constructor guard. Names are NOT folded into
+        ``_known_vars`` (no use-site inlining): only the length-analysis path is
+        affected, and the ``var`` member still emits and initializes normally.
+        """
+        for stmt in (self.ctx.ast.body or []):
+            if not isinstance(stmt, VarDecl):
+                continue
+            if not (stmt.is_var or stmt.is_varip):
+                continue
+            if stmt.name in reassigned:
+                continue
+            if stmt.name in self.ctx.series_vars:
+                continue
+            if stmt.value is None or not self._expr_is_stable(stmt.value):
+                continue
+            expr_str = self._arith_expr_to_str(stmt.value)
+            if expr_str is None:
+                continue
+            self._derived_input_expr[stmt.name] = expr_str
+            self._stable_runtime_vars.add(stmt.name)
+            # Mark input-backed iff the init references an input, so the reset
+            # emits override-aware get_input_*() reads for it.
+            import re as _re
+            toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", expr_str))
+            if any(t in self._input_backed_vars for t in toks):
+                self._input_backed_vars.add(stmt.name)
+
     def _collect_reassigned_stable_scalars(self, reassigned: set[str]) -> None:
         """Track class-scope scalars that are reassigned but only along stable
         if/elif paths (see ``test_stable_reassigned_class_scope_length``).
@@ -1438,7 +1485,117 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         "ismonthly", "isdwm", "isseconds", "in_seconds", "isticks",
     })
 
-    def _expr_is_stable(self, node) -> bool:
+    # Depth ceiling for inlining nested single-expression user functions while
+    # classifying a TA length's stability. Pine forbids recursion, so any real
+    # chain is shallow; the cap is a backstop against pathological input and is
+    # enforced together with a name-stack cycle guard.
+    _UDF_INLINE_MAX_DEPTH = 16
+
+    def _get_udf_def(self, name: str):
+        """Return the top-level single-name ``FuncDef`` for ``name`` (or None).
+
+        Built lazily and cached. UDT ``MethodDef``s are intentionally excluded —
+        only a free function can appear as a bare-name TA length call.
+        """
+        cache = getattr(self, "_udf_def_cache", None)
+        if cache is None:
+            cache = {}
+            for stmt in (self.ctx.ast.body or []):
+                if isinstance(stmt, FuncDef):
+                    # Last definition wins; a name map is all the length path needs.
+                    cache[stmt.name] = stmt
+            self._udf_def_cache = cache
+        return cache.get(name)
+
+    def _inline_single_expr_udf(self, node, _udf_stack: frozenset = frozenset(),
+                                _depth: int = 0):
+        """If ``node`` is a call to a user-defined SINGLE-EXPRESSION function,
+        return its body expression with each parameter substituted by the
+        corresponding call-argument node. Returns None when the call is not such
+        a function, the arity/kwargs do not match, the body is not a single
+        expression, the body contains a shape we do not clone, or the call would
+        recurse (cycle / depth-limit).
+
+        Purely structural: it does NOT judge stability (the caller does, via
+        ``_expr_is_stable`` on the returned node). The conservative None keeps
+        the TA-ctor guard intact.
+        """
+        if not isinstance(node, FuncCall):
+            return None
+        func_name, namespace = self._resolve_callee(node.callee)
+        if namespace is not None or func_name is None:
+            return None
+        if func_name in _udf_stack or _depth >= self._UDF_INLINE_MAX_DEPTH:
+            return None
+        fdef = self._get_udf_def(func_name)
+        if fdef is None:
+            return None
+        # A body that is exactly ONE expression statement is inlinable, whether
+        # written inline after ``=>`` (``is_single_expr=True``) or as a one-line
+        # indented block (``f(x) =>`` then a single indented expr, which the
+        # parser records as ``is_single_expr=False`` with a one-ExprStmt body —
+        # the gonzowiththewind-sisyphus ``f_bars`` shape). A multi-statement
+        # body (len != 1, or a non-ExprStmt) is conservatively refused.
+        body = fdef.body
+        if not body or len(body) != 1 or not isinstance(body[0], ExprStmt):
+            return None
+        # Require a plain positional call: one arg per param, no kwargs, no
+        # default-parameter fill-in — anything else is conservatively refused.
+        if node.kwargs or len(node.args) != len(fdef.params):
+            return None
+        subst = dict(zip(fdef.params, node.args))
+        return self._subst_params(body[0].expr, subst)
+
+    def _subst_params(self, node, subst: dict):
+        """Return a copy of ``node`` with every ``Identifier`` whose name is a
+        key in ``subst`` replaced by the mapped argument node. Returns None for
+        any node outside the small arithmetic/call grammar we fold (an
+        unrecognised construct — e.g. a history ``Subscript`` — conservatively
+        aborts the inline). ``dataclasses.replace`` preserves ``loc``/
+        ``annotations`` so diagnostics still point at real source spans."""
+        import dataclasses as _dc
+        if isinstance(node, (NumberLiteral, StringLiteral, BoolLiteral, NaLiteral)):
+            return node
+        if isinstance(node, Identifier):
+            return subst.get(node.name, node)
+        if isinstance(node, MemberAccess):
+            obj = self._subst_params(node.object, subst)
+            if obj is None:
+                return None
+            return _dc.replace(node, object=obj)
+        if isinstance(node, Ternary):
+            c = self._subst_params(node.condition, subst)
+            t = self._subst_params(node.true_val, subst)
+            f = self._subst_params(node.false_val, subst)
+            if c is None or t is None or f is None:
+                return None
+            return _dc.replace(node, condition=c, true_val=t, false_val=f)
+        if isinstance(node, BinOp):
+            l = self._subst_params(node.left, subst)
+            r = self._subst_params(node.right, subst)
+            if l is None or r is None:
+                return None
+            return _dc.replace(node, left=l, right=r)
+        if isinstance(node, UnaryOp):
+            o = self._subst_params(node.operand, subst)
+            if o is None:
+                return None
+            return _dc.replace(node, operand=o)
+        if isinstance(node, FuncCall):
+            if node.kwargs:
+                return None
+            new_args = []
+            for a in node.args:
+                sa = self._subst_params(a, subst)
+                if sa is None:
+                    return None
+                new_args.append(sa)
+            return _dc.replace(node, args=new_args)
+        # Subscript (history read) and anything else: not a stable-length shape.
+        return None
+
+    def _expr_is_stable(self, node, _udf_stack: frozenset = frozenset(),
+                        _depth: int = 0) -> bool:
         """True iff ``node``'s value is a bar-invariant scalar.
 
         A stable expression depends only on: literals, ``input.*`` values,
@@ -1496,13 +1653,14 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             # History read (``close[1]``) or indexed access — per-bar.
             return False
         if isinstance(node, Ternary):
-            return (self._expr_is_stable(node.condition)
-                    and self._expr_is_stable(node.true_val)
-                    and self._expr_is_stable(node.false_val))
+            return (self._expr_is_stable(node.condition, _udf_stack, _depth)
+                    and self._expr_is_stable(node.true_val, _udf_stack, _depth)
+                    and self._expr_is_stable(node.false_val, _udf_stack, _depth))
         if isinstance(node, BinOp):
-            return self._expr_is_stable(node.left) and self._expr_is_stable(node.right)
+            return (self._expr_is_stable(node.left, _udf_stack, _depth)
+                    and self._expr_is_stable(node.right, _udf_stack, _depth))
         if isinstance(node, UnaryOp):
-            return self._expr_is_stable(node.operand)
+            return self._expr_is_stable(node.operand, _udf_stack, _depth)
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
             if namespace == "ta":
@@ -1510,20 +1668,40 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
             if namespace == "math":
                 if func_name not in self._MATH_STABLE_MEMBERS:
                     return False
-                return all(self._expr_is_stable(a) for a in node.args)
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
             if namespace == "timeframe":
                 # ``timeframe.in_seconds()`` (and any other function-form
                 # timeframe member) is a stable per-run scalar — it reflects
                 # the script's resolution, not a per-bar value.
                 if func_name not in self._TF_STABLE_MEMBERS:
                     return False
-                return all(self._expr_is_stable(a) for a in node.args)
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
             if namespace == "input":
                 return True
             if namespace is None and func_name in ("int", "float", "bool", "string"):
-                return all(self._expr_is_stable(a) for a in node.args)
-            # Any other call (user functions, str.*, array.*, ...) — series
-            # by default; the conservative answer keeps the guard honest.
+                return all(self._expr_is_stable(a, _udf_stack, _depth)
+                           for a in node.args)
+            # A user-defined single-expression function is stable iff every
+            # argument is stable AND its body (with the params bound to those
+            # args) is stable — i.e. the body references only stable scalars
+            # (inputs / consts / timeframe.* / math.* / never-reassigned var
+            # scalars) and no series / strategy state / ta.* results. Inlining
+            # the body (params substituted by the arg nodes) lets the ordinary
+            # classifier decide; the name-stack + depth guard refuses recursion
+            # so a cyclic / malformed UDF is rejected, not looped forever.
+            if namespace is None and func_name is not None:
+                inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
+                if inlined is not None:
+                    if not all(self._expr_is_stable(a, _udf_stack, _depth)
+                               for a in node.args):
+                        return False
+                    return self._expr_is_stable(
+                        inlined, _udf_stack | {func_name}, _depth + 1)
+            # Any other call (multi-statement user functions, str.*, array.*,
+            # ...) — series by default; the conservative answer keeps the guard
+            # honest.
             return False
         return False
 
@@ -1536,22 +1714,28 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
     # re-parsed and lowered through the expression visitor).
     _ATOMIC_ARITH_NODES = (NumberLiteral, Identifier, MemberAccess, FuncCall)
 
-    def _arith_operand_to_str(self, node) -> str | None:
+    def _arith_operand_to_str(self, node, _udf_stack: frozenset = frozenset(),
+                              _depth: int = 0) -> str | None:
         """Serialize ``node`` for use as an operand: parenthesize it unless its
         serialized form is already self-delimiting, so grouping survives a
         round-trip through the parser."""
-        s = self._arith_expr_to_str(node)
+        s = self._arith_expr_to_str(node, _udf_stack, _depth)
         if s is None:
             return None
         if isinstance(node, self._ATOMIC_ARITH_NODES):
             return s
         return f"({s})"
 
-    def _arith_expr_to_str(self, node) -> str | None:
+    def _arith_expr_to_str(self, node, _udf_stack: frozenset = frozenset(),
+                           _depth: int = 0) -> str | None:
         """Render a numeric arithmetic-over-identifiers expression to a string
         that re-parses to the SAME tree (grouping preserved via
         ``_arith_operand_to_str``). Returns None for any node shape we don't
         fold (series subscripts, etc.) so the caller leaves the var untracked.
+
+        ``_udf_stack``/``_depth`` guard the single-expression-UDF inlining below
+        against recursion cycles (Pine forbids recursion, but a malformed source
+        must be refused, not looped forever).
         """
         if isinstance(node, NumberLiteral):
             v = node.value
@@ -1563,30 +1747,44 @@ class CodeGen(CallVisitor, ExprVisitor, StmtVisitor, TopLevelEmitter, SecurityEm
         if isinstance(node, MemberAccess) and isinstance(node.object, Identifier):
             return f"{node.object.name}.{node.member}"
         if isinstance(node, BinOp):
-            l = self._arith_operand_to_str(node.left)
-            r = self._arith_operand_to_str(node.right)
+            l = self._arith_operand_to_str(node.left, _udf_stack, _depth)
+            r = self._arith_operand_to_str(node.right, _udf_stack, _depth)
             if l is None or r is None:
                 return None
             return f"{l} {node.op} {r}"
         if isinstance(node, UnaryOp):
-            o = self._arith_operand_to_str(node.operand)
+            o = self._arith_operand_to_str(node.operand, _udf_stack, _depth)
             if o is None:
                 return None
             return f"{node.op}{o}"
         if isinstance(node, Ternary):
-            c = self._arith_operand_to_str(node.condition)
-            t = self._arith_operand_to_str(node.true_val)
-            f = self._arith_operand_to_str(node.false_val)
+            c = self._arith_operand_to_str(node.condition, _udf_stack, _depth)
+            t = self._arith_operand_to_str(node.true_val, _udf_stack, _depth)
+            f = self._arith_operand_to_str(node.false_val, _udf_stack, _depth)
             if c is None or t is None or f is None:
                 return None
             return f"{c} ? {t} : {f}"
         if isinstance(node, FuncCall):
-            callee = self._arith_expr_to_str(node.callee)
+            # A bare-name call to a single-expression user function has no C++
+            # counterpart at class scope — inline its body (params substituted
+            # by the arg expressions) so the rendered string is pure
+            # math/timeframe/input arithmetic the ctor-reset path can expand.
+            # Namespaced calls (math.*/timeframe.*/int(...)) fall through to the
+            # ordinary ``callee(args)`` rendering below. The stack/depth guard
+            # refuses a recursive UDF (returns None -> caller leaves it untracked
+            # -> the ctor guard rejects it loudly) instead of recursing forever.
+            fn, ns = self._resolve_callee(node.callee)
+            if ns is None and fn is not None and self._get_udf_def(fn) is not None:
+                inlined = self._inline_single_expr_udf(node, _udf_stack, _depth)
+                if inlined is None:
+                    return None
+                return self._arith_expr_to_str(inlined, _udf_stack | {fn}, _depth + 1)
+            callee = self._arith_expr_to_str(node.callee, _udf_stack, _depth)
             if callee is None:
                 return None
             parts = []
             for a in node.args:
-                s = self._arith_expr_to_str(a)
+                s = self._arith_expr_to_str(a, _udf_stack, _depth)
                 if s is None:
                     return None
                 parts.append(s)

{pineforge_codegen-0.9.0 → pineforge_codegen-0.10.0}/pineforge_codegen/codegen/emit_top.py

@@ -1216,6 +1216,11 @@ class TopLevelEmitter:
             if (is_drawing or is_udt) and isinstance(init_ast, NaLiteral):
                 continue
             init_cpp = self._visit_expr(init_ast)
+            # A bare-``na`` initializer for an int/int64_t/bool ``var`` member
+            # must be typed (``na<int>()``), mirroring the class-scope ctor
+            # init (``_typed_na_init`` at _emit_constructor); a raw ``na<double>()``
+            # NaN stored into an int member is UB and defeats is_na<T>().
+            init_cpp = self._typed_na_init(init_cpp, name, ptype)
             init_lines.append(f"        {target} = {init_cpp};")
         if not init_lines:
             return

{pineforge_codegen-0.9.0 → pineforge_codegen-0.10.0}/pineforge_codegen/codegen/security.py

@@ -140,42 +140,91 @@ class SecurityEmitter:
         : inputTf`` must be expanded to their source expression with direct
         ``get_input_*`` reads. Emitting the member name would register with its
         default-constructed value (usually an empty string).
+
+        Delegates to :meth:`_substitute_tf_input_reads`, which rewrites the
+        input-derived *leaves* of the expression tree — including leaves buried
+        inside a ternary CONDITION or any BinOp / UnaryOp / FuncCall — and then
+        renders the substituted tree through the normal expression visitor.
         """
         if node is None:
             return None
-        resolving = resolving or set()
-        if isinstance(node, StringLiteral):
-            return self._visit_expr(node)
+        substituted = self._substitute_tf_input_reads(node, resolving or set())
+        return self._visit_expr(substituted)
+
+    def _substitute_tf_input_reads(self, node, resolving: set[str]):
+        """Return ``node`` with input-derived leaves rewritten to expressions
+        that are valid at security-registration time (before ``on_bar()``
+        assigns members from their inputs):
+
+        * an input-backed var -> its ``input.*()`` source call (``get_input_*``);
+        * a ``timeframe.period`` alias var -> ``timeframe.period`` (``script_tf_``);
+        * a known compile-time string var -> that string literal;
+        * a global alias -> its defining expression, expanded recursively.
+
+        The walk descends through Ternary / BinOp / UnaryOp / FuncCall /
+        Subscript, so an input-backed identifier nested inside e.g. a ternary
+        condition (``mode == "15" ? "240" : "60"``) resolves to its input read
+        instead of the uninitialised member. A subtree containing no
+        input-derived leaf is returned unchanged (same object) so unaffected
+        timeframe expressions render byte-identically to before the fix.
+        MemberAccess and literals are left verbatim: ``timeframe.period`` is
+        already lowered to ``script_tf_`` by the expression visitor.
+        """
+        if not isinstance(node, ASTNode):
+            return node
         if isinstance(node, Identifier):
             name = node.name
             if name in self._timeframe_period_vars:
-                return "script_tf_"
+                return MemberAccess(object=Identifier(name="timeframe"), member="period")
             if name in self._input_backed_vars and name in self._input_var_to_call:
-                return self._visit_expr(self._input_var_to_call[name])
+                return self._input_var_to_call[name]
             if (name in self._known_vars and name not in self._input_backed_vars
                     and isinstance(self._known_vars[name], str)):
-                return self._visit_expr(StringLiteral(value=self._known_vars[name]))
+                return StringLiteral(value=self._known_vars[name])
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
             if name in global_expr_map and name not in resolving:
-                resolving.add(name)
-                out = self._security_tf_runtime_expr(global_expr_map[name], resolving)
-                resolving.remove(name)
-                return out
-            return self._visit_expr(node)
-        if (
-            isinstance(node, MemberAccess)
-            and isinstance(node.object, Identifier)
-            and node.object.name == "timeframe"
-            and node.member == "period"
-        ):
-            return "script_tf_"
+                return self._substitute_tf_input_reads(
+                    global_expr_map[name], resolving | {name})
+            return node
         if isinstance(node, Ternary):
-            cond = self._security_tf_runtime_expr(node.condition, resolving)
-            tv = self._security_tf_runtime_expr(node.true_val, resolving)
-            fv = self._security_tf_runtime_expr(node.false_val, resolving)
-            if cond is not None and tv is not None and fv is not None:
-                return f"(({cond}) ? ({tv}) : ({fv}))"
-        return self._visit_expr(node)
+            cond = self._substitute_tf_input_reads(node.condition, resolving)
+            tv = self._substitute_tf_input_reads(node.true_val, resolving)
+            fv = self._substitute_tf_input_reads(node.false_val, resolving)
+            if cond is node.condition and tv is node.true_val and fv is node.false_val:
+                return node
+            return Ternary(condition=cond, true_val=tv, false_val=fv)
+        if isinstance(node, BinOp):
+            left = self._substitute_tf_input_reads(node.left, resolving)
+            right = self._substitute_tf_input_reads(node.right, resolving)
+            if left is node.left and right is node.right:
+                return node
+            return BinOp(left=left, op=node.op, right=right)
+        if isinstance(node, UnaryOp):
+            operand = self._substitute_tf_input_reads(node.operand, resolving)
+            if operand is node.operand:
+                return node
+            return UnaryOp(op=node.op, operand=operand)
+        if isinstance(node, FuncCall):
+            new_args = [self._substitute_tf_input_reads(a, resolving) for a in node.args]
+            new_kwargs = {
+                k: (self._substitute_tf_input_reads(v, resolving)
+                    if isinstance(v, ASTNode) else v)
+                for k, v in node.kwargs.items()
+            }
+            unchanged = (
+                all(a is b for a, b in zip(new_args, node.args))
+                and all(new_kwargs[k] is node.kwargs[k] for k in node.kwargs)
+            )
+            if unchanged:
+                return node
+            return FuncCall(callee=node.callee, args=new_args, kwargs=new_kwargs)
+        if isinstance(node, Subscript):
+            obj = self._substitute_tf_input_reads(node.object, resolving)
+            idx = self._substitute_tf_input_reads(node.index, resolving)
+            if obj is node.object and idx is node.index:
+                return node
+            return Subscript(object=obj, index=idx)
+        return node
 
     def _resolve_param_tf_from_callsites(self, func_name: str, param_name: str):
         """For a ``request.security`` whose tf is function parameter ``param_name``
@@ -2226,7 +2275,10 @@ class SecurityEmitter:
             op = cpp_ops.get(expr_node.op, expr_node.op)
             if expr_node.op == "%":
                 return f"std::fmod((double)({left}), (double)({right}))"
-            return f"({left} {op} {right})"
+            # KI-71: honour Pine's falsy-on-na relational rule inside
+            # request.security expressions too (this builder is a second
+            # relational emission site independent of _visit_binop).
+            return self._lower_relational(op, expr_node.left, expr_node.right, left, right)
 
         if isinstance(expr_node, UnaryOp):
             operand = self._build_security_expr(

{pineforge_codegen-0.9.0 → pineforge_codegen-0.10.0}/pineforge_codegen/codegen/types.py

@@ -552,6 +552,59 @@ class TypeInferer:
             return True
         return name in self._int64_reassign_targets()
 
+    def _na_reassign_cpp_type(self, name: str) -> str | None:
+        """Declared scalar C++ type of a ``:=`` reassignment target ``name``, so a
+        bare-``na`` RHS (``x := na``) can be spelled ``na<T>()`` matching the
+        member/local type instead of the default ``na<double>()``.
+
+        Assigning a double quiet-NaN into an ``int``/``int64_t``/``bool`` member is
+        undefined behaviour (NaN->int is unspecified; on ARM64 it saturates to 0,
+        which is not the ``na<T>()`` sentinel) and defeats ``is_na<T>()``. Mirrors
+        the member-declaration type logic (``base._emit_class_members`` /
+        ``_typed_na_init``): ``PINE_TYPE_TO_CPP`` plus the int->int64_t epoch
+        promotion. Returns ``None`` for collections / UDT / drawing handles and
+        for ``double`` (already the default lowering), so those paths are
+        unchanged.
+        """
+        # Collections / UDT / drawing handles never take a scalar ``na<T>()``:
+        # leave them to the drawing-na / default lowering in _visit_rhs_value.
+        if (name in self._array_vars
+                or name in self._map_vars
+                or name in getattr(self, "_matrix_specs", {})
+                or name in self._udt_var_types):
+            return None
+        cpp_type: str | None = None
+        # 1. ``var`` member (class-scope OR function-local: both are recorded in
+        #    ctx.var_members). This is the authoritative declaration source.
+        for vname, ptype, _init in self.ctx.var_members:
+            if vname == name:
+                cpp_type = PINE_TYPE_TO_CPP.get(ptype, "double")
+                break
+        # 2. Function-local plain (non-``var``) scalar: its declared type was
+        #    remembered at the VarDecl (``_type_for_decl``).
+        if cpp_type is None:
+            cpp_type = getattr(self, "_current_func_local_types", {}).get(name)
+        # 3. Function parameter.
+        if cpp_type is None:
+            cpp_type = getattr(self, "_current_func_param_types", {}).get(name)
+        # 4. Global-scope non-``var`` class member.
+        if cpp_type is None:
+            for gname, gptype in self.ctx.global_var_decls:
+                if gname == name:
+                    cpp_type = PINE_TYPE_TO_CPP.get(gptype, "double")
+                    break
+        if cpp_type is None:
+            return None
+        # int -> int64_t promotion for epoch-ms builtins, mirroring the member
+        # declaration so the na sentinel width matches the storage width.
+        if cpp_type == "int" and self._is_int64_builtin_init(name):
+            cpp_type = "int64_t"
+        # Only the retypeable scalar types are meaningful; ``double`` already
+        # lowers to ``na<double>()`` and everything else is left untouched.
+        if cpp_type in ("int", "int64_t", "bool", "std::string"):
+            return cpp_type
+        return None
+
     # ------------------------------------------------------------------
     # BUG C: user-defined-UDT lvalue aliasing
     # ------------------------------------------------------------------

{pineforge_codegen-0.9.0 → pineforge_codegen-0.10.0}/pineforge_codegen/codegen/visit_expr.py

@@ -166,6 +166,20 @@ _BUILTIN_NAMESPACE_NAMES: frozenset[str] = frozenset({
 })
 
 
+# KI-71: Pine relational comparisons (``==`` ``!=`` ``<`` ``>`` ``<=`` ``>=``)
+# with an ``na`` operand evaluate *falsy*. Naive C++ relationals do not honour
+# this for the engine's na sentinels, so these ops route through na-aware
+# lowering when an operand can be na (see ``_visit_binop`` / ``_operand_na_kind``).
+_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.
 
@@ -760,6 +774,78 @@ class ExprVisitor:
                 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):
+            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 _lower_relational(self, op: str, left_node, right_node,
+                          left_cpp: str, right_cpp: str) -> str:
+        """Lower a Pine relational to C++, applying KI-71 na-aware wrapping.
+
+        Shared by ``_visit_binop`` and the ``request.security`` expression
+        builder so EVERY relational emission site honours Pine's falsy-on-na
+        rule. Wraps only the diverging cells: any na-capable *integer* operand
+        (the INT_MIN sentinel poisons all six operators) or a ``!=`` with an
+        na-capable *float* operand (the sole IEEE-diverging float cell). Pure
+        ``double`` ``==`` ``<`` ``>`` ``<=`` ``>=`` keep the naive emission —
+        IEEE is already falsy-on-NaN there, so wrapping would be a pure no-op.
+        Non-relational ``op`` (or non-scalar operands with no ``is_na``) fall
+        through to the naive ``(left op right)`` form 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:
+                lk = self._operand_na_kind(left_node, lt)
+                rk = self._operand_na_kind(right_node, rt)
+                int_na = "int" in (lk, rk)
+                float_na = "float" in (lk, rk)
+                if int_na or (op == "!=" and float_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 +872,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)