@pineforge/codegen-pyodide 1.0.0 → 1.1.0

package/pineforge_codegen/codegen/ta.py

@@ -1131,6 +1131,65 @@ class TaSiteHelper:
             )
         return cache[id(node)]
 
+    def _lazy_ctor_history_call(self, call) -> bool:
+        """A positional call of the one user function of its name whose body
+        is a single ``T.new(...)`` of a user-defined type over
+        ``_lazy_call_history_pure_expr`` arguments of its parameters: its value
+        is a new object of fixed fields, and TradingView runs it on every
+        execution of its scope below a lazy edge when its history is read
+        (fixtures/udt_history_tv udth_expr: ``(mk(bar_index * 7)[1]).v`` in a
+        ternary's arm reads the previous bar's call)."""
+        if not isinstance(call, FuncCall) or not isinstance(call.callee, Identifier):
+            return False
+        overloads = [fi for fi in self.ctx.func_infos if fi.name == call.callee.name]
+        if call.kwargs or len(overloads) != 1 or overloads[0].node is None:
+            return False
+        node = overloads[0].node
+        body = getattr(node, "body", None) or []
+        if len(call.args) != len(node.params) or len(body) != 1:
+            return False
+        ctor = body[0].expr if isinstance(body[0], ExprStmt) else None
+        if not (isinstance(ctor, FuncCall)
+                and isinstance(ctor.callee, MemberAccess)
+                and isinstance(ctor.callee.object, Identifier)
+                and ctor.callee.object.name in self._udt_defs
+                and ctor.callee.member == "new"):
+            return False
+        params = set(node.params)
+        return all(self._lazy_call_history_pure_expr(arg, params)
+                   for arg in [*ctor.args, *ctor.kwargs.values()])
+
+    def _lazy_reference_history_object(self, obj) -> bool:
+        """Whether the history of the object or drawing reference ``obj``
+        below a lazy edge is kept on every execution of its scope, as
+        TradingView keeps it (udth_expr): a pure call or a
+        ``_lazy_ctor_history_call`` over pure arguments, a ternary over
+        names, literals and operators, or a field of a named object (read
+        na while the object is na, ``_lazy_history_read_cpp``)."""
+        if self._reference_cpp_type(obj) is None:
+            return False
+        if isinstance(obj, FuncCall):
+            return ((self._lazy_call_history_pure_call(obj)
+                     or self._lazy_ctor_history_call(obj))
+                    and all(self._lazy_call_history_pure_expr(arg, None)
+                            for arg in obj.args))
+        if isinstance(obj, Ternary):
+            return self._lazy_call_history_pure_expr(obj, None)
+        return (isinstance(obj, MemberAccess)
+                and isinstance(obj.object, Identifier)
+                and self._reference_cpp_type(obj.object) is not None)
+
+    def _lazy_history_read_cpp(self, obj) -> str:
+        """The value a hoisted history read pushes: the expression, a field of
+        a na object reading na (TradingView stops on the read itself)."""
+        if (isinstance(obj, MemberAccess)
+                and self._reference_cpp_type(obj.object) is not None):
+            handle = self._reference_cpp_type(obj)
+            receiver = self._visit_expr(obj.object)
+            return (f"(is_na({receiver}) ? {handle}{{}} : "
+                    f"{handle}({self._visit_expr(obj)}))")
+        return self._visit_expr(obj)
+
     def _lazy_call_history_units(self, stmt) -> list:
         """The ``pure_call(...)[k]`` reads below a lazy edge of ``stmt``'s
         roots (``_lazy_edge_statement_roots``), in evaluation order, whose
@@ -1159,6 +1218,10 @@ class TaSiteHelper:
                                 for arg in call.args)):
                     units.append(expr)
                     return
+                if (under_lazy and self._registered_history_handle(expr) is not None
+                        and self._lazy_reference_history_object(call)):
+                    units.append(expr)
+                    return
                 scan(expr.object, under_lazy)
                 scan(expr.index, under_lazy)
             elif isinstance(expr, FuncCall):
@@ -1219,7 +1282,8 @@ class TaSiteHelper:
         hoisted = []
         for read in units:
             member = self._inline_history_member("hist_call", read)
-            self._emit_history_series_write(lines, pad, member, self._visit_expr(read.object))
+            self._emit_history_series_write(
+                lines, pad, member, self._lazy_history_read_cpp(read.object))
             self._hoisted_hist_reads[id(read)] = member
             hoisted.append(id(read))
         return hoisted

package/pineforge_codegen/codegen/types.py

@@ -42,6 +42,7 @@ from ..ast_nodes import (
     MemberAccess, MethodDef, NaLiteral, NumberLiteral, StringLiteral, SwitchStmt,
     Subscript, Ternary, TupleAssign, TupleLiteral, UnaryOp, VarDecl,
 )
+from ..collection_history import history_annotation
 from ..errors import Phase
 from ..external_requests import UNPINNED_ANNOTATION
 from ..limits import iter_ast_nodes
@@ -1545,14 +1546,26 @@ class TypeInferer:
                     return TypeSpec.primitive(primitive_name)
             return None
         if isinstance(node, Subscript):
-            # History access preserves the scalar drawing-handle type.  This
-            # is intentionally not generalized to arrays/maps: their
-            # subscripting rules are handled by the collection paths below.
+            # History access preserves the drawing-handle and user-object
+            # type: ``c[1]`` is the reference ``c`` held one bar back
+            # (fixtures/udt_history_tv).  This is intentionally not
+            # generalized to arrays/maps: their subscripting rules are handled
+            # by the collection paths below.
             receiver_spec = self._type_spec_from_expr(node.object)
             if (receiver_spec is not None
                     and receiver_spec.kind == "udt"
-                    and receiver_spec.name in DRAWING_TYPE_TO_CPP):
+                    and (receiver_spec.name in DRAWING_TYPE_TO_CPP
+                         or receiver_spec.name in self._udt_defs)):
                 return receiver_spec
+            annotation = history_annotation(node)
+            if annotation is not None:
+                # An array's or a matrix's history is a collection of its
+                # type (pineforge_codegen/collection_history.py), the
+                # analyzer's when no declaration registered one yet.
+                if (receiver_spec is not None
+                        and receiver_spec.kind in ("array", "matrix")):
+                    return receiver_spec
+                return annotation["spec"]
             return None
         if isinstance(node, Ternary):
             true_spec = self._type_spec_from_expr(node.true_val)
@@ -1851,13 +1864,18 @@ class TypeInferer:
                     if return_spec is not None:
                         return return_spec
                 if recv_spec is not None and recv_spec.kind == "matrix":
-                    if func_name in MATRIX_RETURNING_METHODS:
+                    # A method on a matrix's history names its method only
+                    # in the member (``_resolve_callee`` reports none).
+                    method = (member_name
+                              if history_annotation(node.callee.object) is not None
+                              else func_name)
+                    if method in MATRIX_RETURNING_METHODS:
                         return recv_spec
-                    if func_name in ("row", "col"):
+                    if method in ("row", "col"):
                         return TypeSpec.array(recv_spec.element)
-                    if func_name == "get":
+                    if method == "get":
                         return recv_spec.element
-                    if func_name == "eigenvalues":
+                    if method == "eigenvalues":
                         return TypeSpec.array(TypeSpec.primitive("float"))
                 # Drawing method-form: ``a.copy()`` -> same handle type;
                 # ``lf.get_line1()`` -> line. (L-N6 alias-vs-copy typing.)
@@ -2206,6 +2224,9 @@ class TypeInferer:
         # init RHS is such a builtin, so also match the builtin name directly.
         if name in INT64_BUILTINS:
             return "int64_t"
+        handle = self._series_handle_cpp_type(name)
+        if handle is not None:
+            return handle
         sym = self._variable_symbol(name)
         # A float or bool an epoch reaches keeps its type: the analyzer types
         # every request.security value float (a double holds an epoch
@@ -2225,6 +2246,51 @@ class TypeInferer:
             return PINE_TYPE_TO_CPP.get(sym.pine_type, "double")
         return "double"
 
+    def _series_handle_type_name(self, name: str) -> str | None:
+        """The user-defined or drawing type (``Cell``, ``box``) of the
+        history-read variable ``name``, else None. Such a variable holds a
+        reference, and its history the references it held: ``(c[1]).v`` reads
+        the object ``c`` held one bar back as it is now (fixtures/
+        udt_history_tv; Pine v6 User Manual, "Type system": value vs.
+        reference types). A buffer is keyed by spelling across scopes, so
+        every scope's history-read variable of that spelling must hold the
+        same type; any other variable keeps the buffer it always had.
+        Cached per name."""
+        cache = self.__dict__.setdefault("_series_handle_type_cache", {})
+        if name in cache:
+            return cache[name]
+        found: set[str] = set()
+        for scope in self.ctx.symbols.all_scopes:
+            sym = scope.symbols.get(name)
+            if sym is None or not getattr(sym, "is_series", False):
+                continue
+            spec = getattr(sym, "type_spec", None)
+            if (spec is None or spec.kind != "udt"
+                    or not (spec.name in DRAWING_TYPE_TO_CPP
+                            or spec.name in self._udt_defs)):
+                found = set()
+                break
+            found.add(spec.name)
+        cache[name] = next(iter(found)) if len(found) == 1 else None
+        return cache[name]
+
+    def _series_handle_cpp_type(self, name: str) -> str | None:
+        """The handle such a variable stores per bar (``Series<Cell>``,
+        ``Series<Box>``; a na reference is the handle's ``T{}``), else
+        None (``_series_handle_type_name``)."""
+        udt = self._series_handle_type_name(name)
+        if udt is None:
+            return None
+        return DRAWING_TYPE_TO_CPP.get(udt) or self._safe_name(udt)
+
+    def _series_handle_target(self, name: str) -> str | None:
+        """``_visit_rhs_value``'s target for a value stored in such a
+        variable's history: the drawing handle, or the user type's name."""
+        udt = self._series_handle_type_name(name)
+        if udt is None:
+            return None
+        return DRAWING_TYPE_TO_CPP.get(udt, udt)
+
     def _variable_symbol(self, name: str):
         """The symbol the variable ``name`` resolves to.
 
@@ -2303,6 +2369,18 @@ class TypeInferer:
         declared_spec = (
             declared_specs[index] if index < len(declared_specs) else None
         )
+        # A parameter holding a user-defined object or a drawing keeps the
+        # references its calls passed (``_series_handle_cpp_type``).
+        inferred_specs = list(getattr(func_info, "param_type_specs", ()) or ())
+        for candidate in (
+            declared_spec,
+            inferred_specs[index] if index < len(inferred_specs) else None,
+        ):
+            if (candidate is not None and candidate.kind == "udt"
+                    and (candidate.name in DRAWING_TYPE_TO_CPP
+                         or candidate.name in self._udt_defs)):
+                return (DRAWING_TYPE_TO_CPP.get(candidate.name)
+                        or self._safe_name(candidate.name))
         # A declared type is authoritative across every written call. Only a
         # truly untyped slot may consult the per-callsite specialization map.
         spec = declared_spec
@@ -3302,6 +3380,19 @@ class TypeInferer:
             cpp_type = "int64_t"
         return cpp_type if cpp_type in (*NA_PRESERVING_INT_TYPES, "bool") else None
 
+    def _udt_field_is_double(self, target_node) -> bool:
+        """Whether a UDT field write target is a ``float`` field (a C++
+        ``double``)."""
+        if not isinstance(target_node, MemberAccess):
+            return False
+        owner = self._type_spec_from_expr(target_node.object)
+        if owner is None or owner.kind != "udt" or not owner.name:
+            return False
+        spec = (self._udt_field_type_specs.get(owner.name) or {}).get(
+            target_node.member
+        )
+        return spec is not None and self._type_spec_to_cpp(spec) == "double"
+
     def _coerce_int_slot(self, cpp_val: str, node, target_cpp_type: str | None,
                          *, value_is_double: bool | None = None) -> str:
         """Route a value into an ``int``/``int64_t`` slot without losing ``na``.
@@ -3343,6 +3434,30 @@ class TypeInferer:
             return na_preserving_int_cast(cpp_val, target_cpp_type)
         return cpp_val
 
+    def _coerce_double_slot(self, cpp_val: str, node) -> str:
+        """Route a value into a ``double`` that a designated initializer
+        fills (a user-defined record's ``float`` field: ``Cell.new(v =
+        bar_index)``). C++ refuses to narrow a non-constant ``int`` or
+        ``int64_t`` there, which did not compile; TradingView holds the
+        number, an integer na as na (fixtures/array_history_tv uctor_float).
+        A double, an integer literal or an expression of literals (a constant
+        a double holds exactly narrows) and a bare na keep their spelling."""
+        constant = self._pure_int_literal_value(node)
+        if (cpp_val == "na<double>()"
+                or self._INTEGRAL_CPP_TEXT.match(cpp_val)
+                or (constant is not None and abs(constant) <= 2 ** 53)
+                or self._emitted_value_is_double(node)):
+            return cpp_val
+        if cpp_val in {"na<int>()", "na<int64_t>()"}:
+            return "na<double>()"
+        # A bool (TradingView refuses one here: CE10123, CE10173) is 1 or 0,
+        # never na, whatever is_na() of a bool resolves to.
+        return (f"[&](){{ auto _pf_w = ({cpp_val}); "
+                f"if constexpr (std::is_floating_point_v<decltype(_pf_w)> "
+                f"|| std::is_same_v<decltype(_pf_w), bool>) "
+                f"return (double)_pf_w; "
+                f"else return is_na(_pf_w) ? na<double>() : (double)_pf_w; }}()")
+
     def _coerce_int_slot_with_cast(
         self, cpp_val: str, node, target_cpp_type: str
     ) -> str:
@@ -3605,12 +3720,25 @@ class TypeInferer:
         and ternaries / if / switch expressions. Returns the string
         ``"double"`` as the safe fallback when no narrower type can be
         determined."""
+        if isinstance(node, Subscript) and history_annotation(node) is not None:
+            # An array's or a matrix's history is a collection of its type
+            # (collection_history.py): a loop's local bound to it is one.
+            spec = self._type_spec_from_expr(node)
+            if spec is not None:
+                return self._type_spec_to_cpp(spec)
         if isinstance(node, Subscript) and isinstance(node.object, Identifier):
             name = node.object.name
             if name in self.ctx.series_vars:
                 return self._series_type_for(name)
             if name in self.ctx.series_bar_fields:
                 return "double"
+        if (isinstance(node, Subscript)
+                and isinstance(node.object, (FuncCall, Ternary, MemberAccess))):
+            # The history of an expression whose value is an object or a
+            # drawing is a reference of its type (``_history_value_cpp_type``).
+            reference = self._reference_cpp_type(node.object)
+            if reference is not None:
+                return reference
         if isinstance(node, Subscript) and isinstance(node.object, FuncCall):
             # A callable-result history read keeps the callable's scalar
             # family. Collection subscripts follow separate element-type paths.

package/pineforge_codegen/codegen/visit_call.py

@@ -143,11 +143,13 @@ from ..ast_nodes import (
     MemberAccess,
     NaLiteral,
     NumberLiteral,
+    Subscript,
     Ternary,
     TupleLiteral,
     StringLiteral,
     VarDecl,
 )
+from ..collection_history import history_annotation, literal_offset
 from ..external_requests import RECORDED_KEY_ANNOTATION
 from ..limits import iter_ast_nodes
 from ..security_contexts import ticker_symbol_arg
@@ -583,7 +585,9 @@ class CallVisitor:
                     for arg in rest_nodes
                 )
             )) or self._binds_fresh_array_to_reference(
-                method_info, rest_nodes, first_param=1),
+                method_info, rest_nodes, first_param=1)
+            or self._binds_temporary_drawing_to_reference(
+                method_info, [receiver_node, *rest_nodes]),
         )
 
     def _callable_target_callsite_idx(self, fi, node: FuncCall) -> int | None:
@@ -1211,6 +1215,12 @@ class CallVisitor:
         returns its argument or a global) or a selection of a held and a
         fresh array, and ``"keep"`` for every other argument, which keeps the
         lowering it had: a variable, a field, ``na``, any other built-in."""
+        annotation = history_annotation(node)
+        if annotation is not None:
+            # A copy of an array's history for the callee (collection_history.py);
+            # at a zero offset, the variable itself.
+            return ("keep" if literal_offset(node) == 0 or annotation["use"] != "copy"
+                    else "fresh")
         if isinstance(node, Ternary):
             kinds = {self._array_arg_kind(node.true_val, depth),
                      self._array_arg_kind(node.false_val, depth)}
@@ -1306,6 +1316,63 @@ class CallVisitor:
             stage = stage or kind == "fresh"
         return stage
 
+    # The drawing types a callable takes as ``T&`` (emit_top: a parameter of
+    # a type outside the user types is a reference).
+    _REFERENCE_DRAWING_PARAMS = frozenset({"line", "box", "label", "linefill", "chart.point"})
+
+    def _drawing_arg_is_temporary(self, arg) -> bool:
+        """Whether the C++ of the drawing argument ``arg`` is a prvalue no
+        ``T&`` takes: a history read or the current slot of a history-read
+        variable (``b[1]``, ``b[0]``: ``Series::operator[]`` returns a copy),
+        a new or copied drawing or chart point, a user call's result, or a
+        selection with such an arm. A variable, a field and a collection
+        element are lvalues, which compiled before and keep their C++."""
+        if isinstance(arg, Subscript):
+            return True
+        if isinstance(arg, Identifier):
+            return self._identifier_reads_series(arg)
+        if isinstance(arg, Ternary):
+            return (self._drawing_arg_is_temporary(arg.true_val)
+                    or self._drawing_arg_is_temporary(arg.false_val))
+        if not isinstance(arg, FuncCall):
+            return False
+        func_name, namespace = self._resolve_callee(arg.callee)
+        if namespace in DRAWING_NS and func_name in ("new", "copy"):
+            return True
+        if self._is_chart_point_callee(arg.callee):
+            return True
+        if namespace is None and func_name in self._func_info_map:
+            return True
+        return (isinstance(arg.callee, MemberAccess)
+                and self._typed_user_method_info(
+                    arg.callee.object, arg.callee.member)[1] is not None)
+
+    def _binds_temporary_drawing_to_reference(self, func_info, arg_nodes: list,
+                                              first_param: int = 0) -> bool:
+        """Whether a call passes a temporary drawing (``_drawing_arg_is_temporary``)
+        to a drawing parameter its callee takes as ``T&``: staging the call
+        (``_ordered_user_call_expr``) binds it to a named forwarding
+        reference. The handle is an arena id and Pine forbids reassigning a
+        parameter, so the callee reads the drawing the argument names
+        (udth_drawparam). A history-read parameter takes a Series bridge
+        instead."""
+        if func_info is None:
+            return False
+        specs = list(getattr(func_info, "param_type_specs", ()) or ())
+        params = (list(func_info.node.params)
+                  if getattr(func_info, "node", None) is not None else [])
+        series = self.ctx.func_series_vars.get(func_info.name, set())
+        for offset, arg in enumerate(arg_nodes):
+            index = first_param + offset
+            spec = specs[index] if index < len(specs) else None
+            if (arg is None or spec is None or spec.kind != "udt"
+                    or spec.name not in self._REFERENCE_DRAWING_PARAMS
+                    or (index < len(params) and params[index] in series)):
+                continue
+            if self._drawing_arg_is_temporary(arg):
+                return True
+        return False
+
     def _ordered_user_call_expr(
         self,
         call_head: str,
@@ -1584,6 +1651,17 @@ class CallVisitor:
                 args = self._array_method_args(callee.member, arg_nodes, recv_spec)
                 return self._array_method_expr(recv, callee.member, args, recv_spec, node)
 
+        # A matrix method on a matrix's history (``(m[1]).get(0, 0)``:
+        # collection_history.py), which no other receiver path reaches.
+        if (isinstance(callee, MemberAccess)
+                and isinstance(callee.object, Subscript)
+                and history_annotation(callee.object) is not None
+                and callee.member in MATRIX_METHODS):
+            recv_spec = self._type_spec_from_expr(callee.object)
+            if recv_spec is not None and recv_spec.kind == "matrix":
+                return self._matrix_history_method_expr(
+                    callee.object, callee.member, recv_spec, node)
+
         # chart.point.now/new/from_index/from_time/copy — REAL data (a ChartPoint
         # aggregate). Routed here BEFORE the obj.field.method receiver logic,
         # which would otherwise mis-treat ``chart.point`` as a receiver object
@@ -1823,6 +1901,9 @@ class CallVisitor:
                 drawing = self._drawing_na_expr(node.args[0])
                 if drawing is not None:
                     return drawing
+                history = self._collection_history_na(node.args[0])
+                if history is not None:
+                    return history
             args = ", ".join(self._visit_expr(a) for a in node.args)
             return f"is_na({args})"
 
@@ -2564,9 +2645,13 @@ class CallVisitor:
             if func_name in MATRIX_METHODS and node.args:
                 from ..ast_nodes import Identifier as _Ident
                 if func_name in MATRIX_NUMERIC_ONLY:
-                    if not isinstance(node.args[0], _Ident):
+                    recv_node = node.args[0]
+                    if history_annotation(recv_node) is not None:
+                        # A matrix's history is a matrix of its type.
+                        recv_node = recv_node.object
+                    if not isinstance(recv_node, _Ident):
                         self._codegen_error(node, f"matrix.{func_name} receiver must be a variable reference")
-                    recv_name = node.args[0].name
+                    recv_name = recv_node.name
                     recv_spec = self._collection_spec_for_name(recv_name)
                     if recv_spec is None or recv_spec.kind != "matrix":
                         self._codegen_error(node, f"matrix.{func_name}: receiver '{recv_name}' is not a known matrix variable")
@@ -2684,6 +2769,8 @@ class CallVisitor:
                             val = "na<int64_t>()"
                     elif f_cpp_type == "bool":
                         val = self._coerce_bool_expr(val, value_node)
+                    elif f_cpp_type == "double":
+                        val = self._coerce_double_slot(val, value_node)
                     elif (self._is_nullable_collection_cpp_type(f_cpp_type)
                           and val == "na<double>()"):
                         val = f"{f_cpp_type}{{}}"
@@ -2958,6 +3045,8 @@ class CallVisitor:
                 all_args,
                 source_order_nodes=[*node.args, *node.kwargs.values()],
                 force_stage=self._binds_fresh_array_to_reference(
+                    self._func_info_map.get(func_name), ordered_arg_nodes)
+                or self._binds_temporary_drawing_to_reference(
                     self._func_info_map.get(func_name), ordered_arg_nodes),
             )
         return f"{call_head}({', '.join(all_args)})"