@pineforge/codegen-pyodide 1.0.0 → 1.0.1

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)})"

package/pineforge_codegen/codegen/visit_expr.py

@@ -88,6 +88,7 @@ classes from ``..ast_nodes``.
 from __future__ import annotations
 
 from ..errors import Phase
+from ..symbols import TypeSpec
 from ..external_requests import UNPINNED_ANNOTATION
 from ..ast_nodes import (
     ASTNode,
@@ -503,6 +504,18 @@ class ExprVisitor:
         return (f'([&]() {{ pine_runtime_error(std::string("{self._cpp_string_escape(marker)}")); '
                 f"return {value}; }}())")
 
+    def _identifier_reads_series(self, node: Identifier) -> bool:
+        """Whether ``_visit_ident`` lowers ``node`` to its Series' current slot
+        (``x[0]``, a copy): a history-read parameter or variable."""
+        name = node.name
+        if name in self._current_func_series_params:
+            return True
+        if (name in self._current_func_param_types or name in BAR_FIELDS
+                or name in BAR_BUILTINS):
+            return False
+        return self._binding_is_series(
+            name, self._call_site_var_name(node, self._safe_name(name)))
+
     def _visit_ident(self, node: Identifier) -> str:
         name = node.name
         # Bare 'na' identifier → na<double>()
@@ -1270,7 +1283,66 @@ class ExprVisitor:
             return self._emit_na_relational(op, left_cpp, right_cpp)
         return f"({left_cpp} {op} {right_cpp})"
 
+    # The reference types TradingView compares with == and != (lab tv
+    # pf-udth-line-eq: by identity, a na reference included); every other
+    # object or drawing type is CE10123 there.
+    _IDENTITY_COMPARED_REFERENCES = frozenset({"line", "label"})
+
+    def _reference_operand_kind(self, operand) -> str | None:
+        """The type of a user-defined object or drawing reference operand
+        (``Cell``, ``box``, ``chart.point``, ...), else None."""
+        spec = self._type_spec_from_expr(operand)
+        if spec is None or spec.kind != "udt" or not spec.name:
+            return None
+        if spec.name not in DRAWING_TYPE_TO_CPP and spec.name not in self._udt_defs:
+            return None
+        if self._infer_type(operand) in (
+                "double", "int", "int64_t", "bool", "std::string"):
+            return None
+        return spec.name
+
+    def _reference_equality_cpp(self, node: BinOp) -> str | None:
+        """``==`` / ``!=`` with a reference operand: a line or a label equals
+        the same line or label, na included (TradingView compares their
+        references; a deleted drawing keeps its own), the handles' ids here.
+        TradingView refuses the comparison of any other object or drawing
+        (CE10123) and of a reference with na (CE10187), which never compiled
+        here either."""
+        kinds = (self._reference_operand_kind(node.left),
+                 self._reference_operand_kind(node.right))
+        if kinds == (None, None):
+            return None
+        other = node.right if kinds[0] is not None else node.left
+        kind = kinds[0] or kinds[1]
+        if isinstance(other, NaLiteral) or (
+                isinstance(other, Identifier) and other.name == "na"):
+            self._codegen_error(
+                node,
+                f"{node.op} na on a {kind} reference: TradingView refuses a "
+                "comparison with na (CE10187: \"Cannot compare a value to "
+                "\\\"na\\\" directly\").",
+                hint="Test the reference with na(...).",
+            )
+        if kinds[0] != kinds[1] or kind not in self._IDENTITY_COMPARED_REFERENCES:
+            self._codegen_error(
+                node,
+                f"{node.op} on a {kind} reference: TradingView compares only "
+                "line and label references (CE10123: \"Cannot call "
+                f"'operator {node.op}'\" with an argument of the {kind} type).",
+                hint="Compare the fields or getter values the objects hold, "
+                     "or test na(...).",
+            )
+        left = self._visit_expr(node.left)
+        right = self._visit_expr(node.right)
+        return self._left_operand_first(
+            node, left, right,
+            lambda left, right: f"(({left}).id {node.op} ({right}).id)")
+
     def _visit_binop(self, node: BinOp) -> str:
+        if node.op in ("==", "!="):
+            identity = self._reference_equality_cpp(node)
+            if identity is not None:
+                return identity
         # An int-literal-only ``+ - *`` tree whose exact value leaves int32 is
         # a 64-bit Pine int (``90 * 24 * 60 * 60 * 1000`` = 7 776 000 000);
         # C++ ``int`` literal arithmetic would wrap it. Fold it here and spell
@@ -1723,7 +1795,119 @@ class ExprVisitor:
             idx_int = f"({idx_int})"
         return idx_int
 
+    def _warn_untracked_reference_history(self, node: Subscript) -> None:
+        """A history read of an object or drawing reference that lowers to
+        the current reference, which keeps the lowering it compiled to: the
+        analyzer registered no history for it here, while TradingView reads
+        the reference the variable held k bars back (fixtures/
+        udt_history_tv)."""
+        if isinstance(node.index, NumberLiteral) and node.index.value == 0:
+            return
+        spec = self._type_spec_from_expr(node.object)
+        if spec is not None and spec.kind in ("array", "matrix"):
+            # A parameter's array or matrix history (collection_history.py:
+            # the earlier lowering, kept where it compiled).
+            self._codegen_warning(
+                node,
+                f"{node.object.name}[...] reads the current {spec.kind} in "
+                "PineForge: no history of this parameter is kept, where "
+                "TradingView reads the copy the call that many calls back "
+                "left (fixtures/array_history_tv ahist_fn).",
+            )
+            return
+        if (spec is None or spec.kind != "udt"
+                or not (spec.name in DRAWING_TYPE_TO_CPP
+                        or spec.name in self._udt_defs)):
+            return
+        self._codegen_warning(
+            node,
+            f"{node.object.name}[...] reads the current {spec.name} reference "
+            "in PineForge: no history of this variable is kept here, where "
+            "TradingView reads the reference it held that many bars back.",
+        )
+
+    def _chart_point_field_written_names(self) -> set[str]:
+        """The chart.point variables a field of which the script assigns
+        (``p.price := x``). Cached."""
+        cached = getattr(self, "_chart_point_writes_cache", None)
+        if cached is not None:
+            return cached
+        point = TypeSpec.udt("chart.point")
+        names: set[str] = set()
+        for node in self._walk_ast(self.ctx.ast):
+            if (isinstance(node, Assignment)
+                    and isinstance(node.target, MemberAccess)
+                    and isinstance(node.target.object, Identifier)
+                    and any(getattr(scope.symbols.get(node.target.object.name),
+                                    "type_spec", None) == point
+                            for scope in self.ctx.symbols.all_scopes)):
+                names.add(node.target.object.name)
+        self._chart_point_writes_cache = names
+        return names
+
+    def _refuse_mutable_chart_point_history(self, node: Subscript) -> None:
+        """History of a chart.point variable the script changes a field of.
+        TradingView's chart.point is an object (its history holds references,
+        read as they are now: fixtures/udt_history_tv); PineForge holds one
+        as a value, so its history would read a changed point's old value,
+        and the field write on its history did not compile. A point no field
+        write changes reads alike either way."""
+        if isinstance(node.index, NumberLiteral) and node.index.value == 0:
+            return
+        if not (isinstance(node.object, Identifier)
+                and node.object.name in self._chart_point_field_written_names()
+                and self._type_spec_from_expr(node.object)
+                == TypeSpec.udt("chart.point")):
+            return
+        self._codegen_error(
+            node,
+            f"History of the chart.point {node.object.name} is not supported "
+            "in PineForge when the script changes its fields: PineForge holds "
+            "a chart.point as a value, where TradingView's history reads the "
+            "point object as it is now.",
+            hint="Keep the field in a variable of its own and read that "
+                 "variable's history, or build a new point instead of "
+                 "changing a field.",
+        )
+
+    def _refuse_field_value_history(self, node: Subscript) -> None:
+        """History of a user-defined object's field that holds a value:
+        TradingView refuses ``c.v[1]`` and ``(c.v)[1]`` alike ("Cannot use the
+        history-referencing operator on fields of user-defined types",
+        CE10290) and takes ``(c[1]).v``; the C++ subscripted the field's
+        scalar, which did not compile. A field holding an object or a drawing
+        is a reference, whose history TradingView keeps (udth_expr); the
+        analyzer refuses a collection field's history (CE10290 too:
+        ``_refuse_collection_field_history``)."""
+        field = node.object
+        if not isinstance(field, MemberAccess):
+            return
+        owner = self._type_spec_from_expr(field.object)
+        if (owner is None or owner.kind != "udt"
+                or owner.name not in self._udt_defs
+                or self._reference_cpp_type(field) is not None):
+            return
+        field_spec = self._udt_field_type_specs.get(owner.name, {}).get(field.member)
+        if field_spec is not None and field_spec.kind in ("array", "map", "matrix"):
+            return
+        receiver = (field.object.name if isinstance(field.object, Identifier)
+                    else "object")
+        self._codegen_error(
+            node,
+            f"{receiver}.{field.member}[...]: TradingView refuses the "
+            "history-referencing operator on fields of user-defined types "
+            "(CE10290).",
+            hint=f"Read the field of the object's history: "
+                 f"({receiver}[1]).{field.member}.",
+        )
+
     def _visit_subscript(self, node: Subscript) -> str:
+        # An array's or a matrix's history (collection_history.py).
+        collection_history = self._lower_collection_history(node)
+        if collection_history is not None:
+            return collection_history
+        self._refuse_mutable_chart_point_history(node)
+        self._refuse_field_value_history(node)
         idx = self._visit_expr(node.index)
         # Series::operator[] accepts C++ int. A Pine int can be backed by an
         # int64_t timestamp slot; implicitly narrowing its na sentinel to int
@@ -1747,6 +1931,7 @@ class ExprVisitor:
                 return f"{self._safe_name(name)}[{series_idx}]"
             # Function parameters are scalars — src[0] → src, src[N>0] → src
             if name in self._current_func_param_types:
+                self._warn_untracked_reference_history(node)
                 return self._safe_name(name)
             if name in BAR_FIELDS or name in BAR_SERIES_PUSH:
                 # Index matches Pine: [0] current bar, [k] k bars ago (runtime Series deque).
@@ -1757,6 +1942,9 @@ class ExprVisitor:
             if self._binding_is_series(name, safe):
                 # Same Pine [k] semantics as Series in runtime/series.hpp
                 return f"{safe}[{series_idx}]"
+            # An array's history the analyzer annotated lowers above
+            # (collection_history.py); this legacy element read is left for
+            # one it never met.
             spec = self._collection_spec_for_name(name)
             if spec is not None and spec.kind in ("array", "map"):
                 self._codegen_warning(
@@ -1804,6 +1992,10 @@ class ExprVisitor:
             cpp_t = self._infer_type(node.object)
             if cpp_t not in ("double", "int", "int64_t", "bool"):
                 cpp_t = "double"
+            # A call's object or drawing result keeps the references it
+            # returned (``_history_value_cpp_type``), in the Series the
+            # prepass declared.
+            cpp_t = self._registered_history_handle(node) or cpp_t
             member = self._inline_history_member("hist_call", node)
             ta_site = self._get_ta_site(node.object)
             ta_name = (
@@ -1870,12 +2062,18 @@ class ExprVisitor:
             self._inline_history_member_by_key.get(
                 ("hist_call", id(node), self._current_instance_name)
             )
-            if isinstance(node.object, (BinOp, UnaryOp, Ternary))
+            if isinstance(node.object, (BinOp, UnaryOp, Ternary, MemberAccess))
             else None
         )
+        hoisted_member = self._hoisted_hist_reads.get(id(node))
+        if hoisted_member is not None:
+            # A reference's history below a lazy edge, pushed on every
+            # execution before the statement (``_emit_lazy_call_history_hoists``).
+            return f"{hoisted_member}[{self._history_offset_cpp(idx, node.index)}]"
         if compound_member is not None:
-            cpp_t = self._infer_type(node.object)
-            if cpp_t in ("double", "int", "int64_t", "bool"):
+            reference_cpp = self._registered_history_handle(node)
+            cpp_t = reference_cpp or self._infer_type(node.object)
+            if reference_cpp is not None or cpp_t in ("double", "int", "int64_t", "bool"):
                 inner = self._visit_expr(node.object)
                 idx_int = self._history_offset_cpp(idx, node.index)
                 return (
@@ -1893,6 +2091,7 @@ class ExprVisitor:
             if (name not in BAR_FIELDS and name not in BAR_SERIES_PUSH
                     and name not in self.ctx.series_vars
                     and name not in self._var_names):
+                self._warn_untracked_reference_history(node)
                 return obj
         idx_int = self._history_offset_cpp(idx, node.index)
         return f"{obj}[{idx_int}]"