@pineforge/codegen-pyodide 1.2.0 → 1.4.0

package/pineforge_codegen/codegen/visit_expr.py

@@ -87,6 +87,8 @@ classes from ``..ast_nodes``.
 
 from __future__ import annotations
 
+from .run_stops import request_stop
+
 from ..errors import Phase
 from ..symbols import TypeSpec
 from ..external_requests import UNPINNED_ANNOTATION
@@ -311,12 +313,18 @@ class ExprVisitor:
         while isinstance(links[-1].false_val, Ternary):
             links.append(links[-1].false_val)
         string_na = self._ternary_string_na(links)
+        array_history_type = self._array_history_value_expr_cpp_type(node)
         if len(links) < self._FLAT_TERNARY_CHAIN:
             c = self._coerce_bool_expr(
                 self._visit_expr(node.condition), node.condition
             )
             t = self._ternary_arm(node.true_val, string_na)
             f = self._ternary_arm(node.false_val, string_na)
+            if array_history_type is not None:
+                t = (f"{array_history_type}{{}}" if self._is_na_expr(node.true_val)
+                     else f"{array_history_type}({t})")
+                f = (f"{array_history_type}{{}}" if self._is_na_expr(node.false_val)
+                     else f"{array_history_type}({f})")
             return f"(({c}) ? ({t}) : ({f}))"
         arms = []
         for link in links:
@@ -324,8 +332,15 @@ class ExprVisitor:
                 self._visit_expr(link.condition), link.condition
             )
             t = self._ternary_arm(link.true_val, string_na)
+            if array_history_type is not None:
+                t = (f"{array_history_type}{{}}" if self._is_na_expr(link.true_val)
+                     else f"{array_history_type}({t})")
             arms.append(f"({c}) ? ({t}) : ")
-        return f"({''.join(arms)}({self._ternary_arm(links[-1].false_val, string_na)}))"
+        tail = self._ternary_arm(links[-1].false_val, string_na)
+        if array_history_type is not None:
+            tail = (f"{array_history_type}{{}}" if self._is_na_expr(links[-1].false_val)
+                    else f"{array_history_type}({tail})")
+        return f"({''.join(arms)}({tail}))"
 
     def _ternary_string_na(self, links: list[Ternary]) -> bool:
         """A ``?:`` chain whose every value arm but a bare ``na`` is a
@@ -493,15 +508,14 @@ class ExprVisitor:
             value = self._visit_expr(node)
         finally:
             node.annotations = notes
-        if isinstance(marker, dict):
+        stop = request_stop(marker)
+        if "ref" in marker:
             # Evaluated first: a recorded request sets its flag where it is
             # evaluated, which may be this read.
-            stop = (f'pine_runtime_error(std::string('
-                    f'"{self._cpp_string_escape(marker["message"])}"))')
             return (f"([&]() {{ auto _pf_read = {value}; "
                     f"if ({self._request_data_missing(marker['ref'])}) {stop}; "
                     f"return _pf_read; }}())")
-        return (f'([&]() {{ pine_runtime_error(std::string("{self._cpp_string_escape(marker)}")); '
+        return (f'([&]() {{ {stop}; '
                 f"return {value}; }}())")
 
     def _identifier_reads_series(self, node: Identifier) -> bool:
@@ -952,6 +966,7 @@ class ExprVisitor:
                 if node.member == "isfirst":
                     return "(bar_index_ == 0)"
                 if node.member == "islast":
+                    self._order_shape_host_reads.add("barstate_islast_")
                     return "barstate_islast_"
                 if node.member == "isnew":
                     return "is_first_tick()"
@@ -962,6 +977,7 @@ class ExprVisitor:
                 if node.member == "isrealtime":
                     return "false"
                 if node.member == "islastconfirmedhistory":
+                    self._order_shape_host_reads.add("barstate_islast_")
                     return "barstate_islast_"
                 return "false"
             if ns in ("backadjustment", "settlement_as_close"):
@@ -1046,12 +1062,16 @@ class ExprVisitor:
                         return ismarket
                     return f"(!{ismarket} && {predicate})"
                 if node.member == "isfirstbar":
+                    self._order_shape_host_reads.add("session_isfirstbar_")
                     return "session_isfirstbar_"
                 if node.member == "islastbar":
+                    self._order_shape_host_reads.add("session_islastbar_")
                     return "session_islastbar_"
                 if node.member == "isfirstbar_regular":
+                    self._order_shape_host_reads.add("session_isfirstbar_regular_")
                     return "session_isfirstbar_regular_"
                 if node.member == "islastbar_regular":
+                    self._order_shape_host_reads.add("session_islastbar_regular_")
                     return "session_islastbar_regular_"
                 return "false"
             if ns == "syminfo":
@@ -1083,7 +1103,7 @@ class ExprVisitor:
             if ns in SKIP_NAMESPACES:
                 return "0"
             if ns == "currency":
-                return f'std::string("{node.member}")'
+                return f'std::string("{self._cpp_string_escape(node.member)}")'
             if ns == "order":
                 # order.ascending / order.descending. Unknown member -> "ascending".
                 return ORDER_DIRECTION_MAP.get(node.member, 'std::string("ascending")')
@@ -1163,7 +1183,7 @@ class ExprVisitor:
                 return f"{safe}.{node.member}"
             if name not in self.ctx.series_vars:
                 # Unknown identifier — likely an enum value
-                return f'std::string("{node.member}")'
+                return f'std::string("{self._cpp_string_escape(node.member)}")'
         return f"{obj}.{node.member}"
 
     def _operand_na_kind(self, node, cpp_type: str) -> str | None:
@@ -1954,7 +1974,13 @@ class ExprVisitor:
                     "collection IDs, so this result can differ from TradingView "
                     "and a missing index is not represented faithfully.",
                 )
-                return f"{self._collection_receiver_expr(name)}[{idx}]"
+                receiver = self._collection_receiver_expr(name)
+                if spec.kind == "array":
+                    return self._legacy_array_history_element(
+                        receiver, spec, series_idx,
+                        mutable=getattr(self, "_udt_assignment_target", None) is node,
+                    )
+                return f"{receiver}[{idx}]"
         # Handle strategy.* history access (e.g., strategy.position_size[1])
         if isinstance(node.object, MemberAccess):
             if isinstance(node.object.object, Identifier):
@@ -2094,4 +2120,10 @@ class ExprVisitor:
                 self._warn_untracked_reference_history(node)
                 return obj
         idx_int = self._history_offset_cpp(idx, node.index)
+        object_spec = self._type_spec_from_expr(node.object)
+        if object_spec is not None and object_spec.kind == "array":
+            return self._legacy_array_history_element(
+                obj, object_spec, idx_int,
+                mutable=getattr(self, "_udt_assignment_target", None) is node,
+            )
         return f"{obj}[{idx_int}]"

package/pineforge_codegen/codegen/visit_stmt.py

@@ -1100,10 +1100,8 @@ class StmtVisitor:
             # the backtest runtime. See: pineforge-codegen issue #10.
             if self._is_omitted_udt_field(node.target):
                 recv = self._visit_expr(node.target.object)
-                lines.append(
-                    f"{pad}/* drawing field assignment omitted: "
-                    f"{recv}.{node.target.member} {node.op} ... */"
-                )
+                omitted = self._cpp_comment_escape(f"{recv}.{node.target.member} {node.op}")
+                lines.append(f"{pad}/* drawing field assignment omitted: {omitted} ... */")
                 return
             # General expression target (e.g., member access)
             target_cpp = self._visit_mutable_expr(node.target)
@@ -1824,6 +1822,9 @@ class StmtVisitor:
         self._current_counted_loop_vars = (
             self._current_counted_loop_vars - {node.var, *(node.vars or ())})
         iterable_spec = self._type_spec_from_expr(node.iterable)
+        if (iterable_spec is not None and iterable_spec.kind == "array"
+                and self._array_history_value_names()):
+            iterable = f"_pf_array_id({iterable})"
         elem_spec = (
             iterable_spec.element
             if iterable_spec is not None and iterable_spec.kind == "array"

package/pineforge_codegen/collection_history.py

@@ -204,7 +204,6 @@ _STRING_PARAMETER_LOWERING_FAILS = _PARAMETER_LOWERING_FAILS | frozenset(
 _MATRIX_RECEIVER_LOWERING_FAILS = frozenset({
     "read:receiver", "change:receiver", "render", "copy:untyped",
     "read:argument:det", "read:argument:copy", "change:argument",
-    "other:collection",  # matrix.sum (_matrix_sum_use)
 })
 
 
@@ -233,16 +232,30 @@ COLLECTION_HISTORY_CPP = r"""
 // for a var) opens a slot, and the end of the bar closes it with a copy.
 template <typename T>
 struct _PFCollectionTraits;
+template <typename T>
+class _PFArrayHistoryValue;
 template <typename E, typename A>
 struct _PFCollectionTraits<std::vector<E, A>> {
     static std::shared_ptr<const std::vector<E, A>> freeze(const std::vector<E, A>& value) {
         return std::make_shared<const std::vector<E, A>>(value);
     }
     static std::vector<E, A> copy(const std::vector<E, A>& value) { return value; }
+    static _PFArrayHistoryValue<std::vector<E, A>> reference(std::shared_ptr<const std::vector<E, A>> value) {
+        return _PFArrayHistoryValue<std::vector<E, A>>(value);
+    }
     static bool is_na(const std::vector<E, A>&) { return false; }
     static const char* na_message() {
         return "@NA_ARRAY_MESSAGE@";
     }
+    static void na_stop() {
+        _PF_COLLECTION_STOP("na_reference", "array", "@NA_ARRAY_MESSAGE@");
+    }
+    [[noreturn]] static void history_stop() {
+        _PF_COLLECTION_STOP("historical_modified", "array", "@HISTORICAL_CHANGE_MESSAGE@");
+#ifndef PINEFORGE_HAS_RUN_FAILURE_CODES_V1
+        throw 0;
+#endif
+    }
 };
 """
 
@@ -261,6 +274,15 @@ struct _PFCollectionTraits<PineMatrix> {
     static const char* na_message() {
         return "@NA_MATRIX_MESSAGE@";
     }
+    static void na_stop() {
+        _PF_COLLECTION_STOP("na_reference", "matrix", "@NA_MATRIX_MESSAGE@");
+    }
+    [[noreturn]] static void history_stop() {
+        _PF_COLLECTION_STOP("historical_modified", "matrix", "@HISTORICAL_CHANGE_MESSAGE@");
+#ifndef PINEFORGE_HAS_RUN_FAILURE_CODES_V1
+        throw 0;
+#endif
+    }
 };
 """
 
@@ -278,15 +300,83 @@ struct _PFCollectionTraits<PineGenericMatrix<E>> {
     static const char* na_message() {
         return "@NA_MATRIX_MESSAGE@";
     }
+    static void na_stop() {
+        _PF_COLLECTION_STOP("na_reference", "matrix", "@NA_MATRIX_MESSAGE@");
+    }
+    [[noreturn]] static void history_stop() {
+        _PF_COLLECTION_STOP("historical_modified", "matrix", "@HISTORICAL_CHANGE_MESSAGE@");
+#ifndef PINEFORGE_HAS_RUN_FAILURE_CODES_V1
+        throw 0;
+#endif
+    }
+};
+"""
+
+COLLECTION_HISTORY_ARRAY_VALUE_CPP = r"""
+template <typename T>
+class _PFArrayHistoryValue {
+public:
+    _PFArrayHistoryValue() = default;
+    _PFArrayHistoryValue(const T& value) : value_(std::make_shared<T>(value)) {}
+    _PFArrayHistoryValue(std::shared_ptr<const T> value)
+        : value_(value ? std::make_shared<T>(*value) : nullptr) {}
+    bool is_na() const { return !value_; }
+    T& get() const {
+        if (!value_) _PF_COLLECTION_STOP("na_reference", "array", "@NA_ARRAY_MESSAGE@");
+        return *value_;
+    }
+    operator T&() const { return get(); }
+
+private:
+    std::shared_ptr<T> value_;
+};
+
+template <typename T>
+bool is_na(const _PFArrayHistoryValue<T>& value) { return value.is_na(); }
+
+template <typename T>
+T& _pf_array_id(T& value) { return value; }
+template <typename T>
+const T& _pf_array_id(const T& value) { return value; }
+template <typename T>
+T _pf_array_id(T&& value) { return std::move(value); }
+template <typename T>
+T& _pf_array_id(const _PFArrayHistoryValue<T>& value) { return value.get(); }
+template <typename T>
+T& _pf_array_id(_PFArrayHistoryValue<T>& value) { return value.get(); }
+template <typename T>
+T _pf_array_id(_PFArrayHistoryValue<T>&& value) { return value.get(); }
+
+template <typename T>
+struct _PFCollectionTraits<_PFArrayHistoryValue<T>> {
+    static std::shared_ptr<const _PFArrayHistoryValue<T>> freeze(const _PFArrayHistoryValue<T>& value) {
+        if (value.is_na()) return nullptr;
+        return std::make_shared<const _PFArrayHistoryValue<T>>(T(value.get()));
+    }
+    static _PFArrayHistoryValue<T> copy(const _PFArrayHistoryValue<T>& value) { return value; }
+    static _PFArrayHistoryValue<T> reference(std::shared_ptr<const _PFArrayHistoryValue<T>> value) {
+        return value ? *value : _PFArrayHistoryValue<T>{};
+    }
+    static bool is_na(const _PFArrayHistoryValue<T>& value) { return value.is_na(); }
+    static const char* na_message() { return "@NA_ARRAY_MESSAGE@"; }
+    static void na_stop() {
+        _PF_COLLECTION_STOP("na_reference", "array", "@NA_ARRAY_MESSAGE@");
+    }
+    [[noreturn]] static void history_stop() {
+        _PF_COLLECTION_STOP("historical_modified", "array", "@HISTORICAL_CHANGE_MESSAGE@");
+#ifndef PINEFORGE_HAS_RUN_FAILURE_CODES_V1
+        throw 0;
+#endif
+    }
 };
 """
 
 COLLECTION_HISTORY_CLASS_CPP = r"""
 // A change to the history of an array or a matrix stops the run, as
 // TradingView's does (RE10051).
+template <typename T>
 [[noreturn]] inline void _pf_collection_history_changed() {
-    pine_runtime_error("@HISTORICAL_CHANGE_MESSAGE@");
-    throw 0;
+    _PFCollectionTraits<T>::history_stop();
 }
 
 template <typename T>
@@ -316,7 +406,7 @@ public:
     const T& at(int offset) const {
         std::shared_ptr<const T> slot = offset > 0 ? slots_[offset] : nullptr;
         if (!slot) {
-            pine_runtime_error(_PFCollectionTraits<T>::na_message());
+            _PFCollectionTraits<T>::na_stop();
         }
         return *slot;
     }
@@ -332,13 +422,20 @@ public:
     T value(int offset, const T& current) const {
         return offset == 0 ? current : value(offset);
     }
+    auto reference(int offset) const {
+        return _PFCollectionTraits<T>::reference(offset > 0 ? slots_[offset] : nullptr);
+    }
+    auto reference(int offset, const T& current) const {
+        return offset == 0 ? _PFCollectionTraits<T>::reference(
+            _PFCollectionTraits<T>::freeze(current)) : reference(offset);
+    }
     // The receiver of a built-in that changes it: the variable itself at a
     // zero offset, else the run stops, as TradingView's does (RE10051; a na
     // history stops it with RE10052 / RE10053 first).
     T& changed(int offset, T& current) const {
         if (offset == 0) return current;
         (void)at(offset);
-        _pf_collection_history_changed();
+        _pf_collection_history_changed<T>();
     }
 
 private:
@@ -366,6 +463,7 @@ def _with_messages(text: str) -> str:
 COLLECTION_HISTORY_CPP = _with_messages(COLLECTION_HISTORY_CPP)
 COLLECTION_HISTORY_MATRIX_CPP = _with_messages(COLLECTION_HISTORY_MATRIX_CPP)
 COLLECTION_HISTORY_GENERIC_MATRIX_CPP = _with_messages(COLLECTION_HISTORY_GENERIC_MATRIX_CPP)
+COLLECTION_HISTORY_ARRAY_VALUE_CPP = _with_messages(COLLECTION_HISTORY_ARRAY_VALUE_CPP)
 COLLECTION_HISTORY_CLASS_CPP = _with_messages(COLLECTION_HISTORY_CLASS_CPP)
 
 
@@ -457,6 +555,9 @@ class Use:
     needs_collection: bool = False
     form: str | None = None        # read / change / slice: receiver or argument;
                                    # render: tostring or format
+    crosses_callable: bool = False  # a copy given to a user function's or
+                                    # method's parameter (a method's receiver
+                                    # is its first)
 
     def tag(self) -> str:
         """The use's class, by which ``_ELEMENT_LOWERING_FAILS`` and its
@@ -483,11 +584,13 @@ class NameUses:
     change: Use | None = None
     reject: Use | None = None
     other: Use | None = None
+    crosses_parameter: bool = False
     tags: dict[str, Use] = field(default_factory=dict)   # every use's class
 
     def merge(self, other: "NameUses | None") -> None:
         if other is None:
             return
+        self.crosses_parameter |= other.crosses_parameter
         for key in ("collection", "element", "change", "reject", "other"):
             if getattr(self, key) is None and getattr(other, key) is not None:
                 setattr(self, key, getattr(other, key))
@@ -516,6 +619,7 @@ class NameUses:
                 if use.names.element is not None or use.names.other is not None:
                     self.merge(NameUses(other=use.names.element or use.names.other))
         elif how in ("copy", "flow"):
+            self.crosses_parameter |= use.crosses_callable
             self.merge(use.names)
             if use.needs_collection:
                 self.merge(NameUses(collection=use))
@@ -861,8 +965,6 @@ class CollectionHistoryChecker:
             return Use("other", node, f"{label}.{method}: {_a(kind)} has no fields.",
                        needs_collection=True)
         if method in self._builtin_methods(kind):
-            if kind == "matrix" and method == "sum":
-                return self._matrix_sum_use(node, label)
             if kind == "array" and method == "slice":
                 return self._slice_use(call, node, label, "receiver")
             if self._changing(kind, method):
@@ -871,18 +973,12 @@ class CollectionHistoryChecker:
         if method in self._methods:
             definitions = self._definitions_for(self._methods[method], 0, None, kind)
             return Use("copy", node, names=self._parameter_uses(
-                definitions, 0, None, kind), needs_collection=True, form="receiver")
+                definitions, 0, None, kind), needs_collection=True, form="receiver",
+                crosses_callable=True)
         return Use("other", node,
                    f"{label}.{method}(): no array or matrix method of that name.",
                    needs_collection=True)
 
-    def _matrix_sum_use(self, node, label: str) -> Use:
-        """``matrix.sum(m[k], m2)``: its matrix result does not compile,
-        history or not (the earlier build refused the history)."""
-        return Use("other", node,
-                   f"matrix.sum of {label} is not supported in PineForge: the "
-                   "matrix it returns does not compile.", needs_collection=True)
-
     def _slice_use(self, call: FuncCall, node, label: str, form: str) -> Use:
         """``(a[k]).slice(...)``: TradingView's slice shares the history's
         elements, so a change to it stops the run (RE10051)."""
@@ -906,7 +1002,7 @@ class CollectionHistoryChecker:
                            names=self._parameter_uses(definitions, positional, keyword, kind),
                            needs_collection=self._parameter_is_collection(
                                definitions, positional, keyword),
-                           form="parameter")
+                           form="parameter", crosses_callable=True)
             if name in _SCALAR_FUNCTIONS:
                 return self._reject(
                     node, f"{label} is {_a(kind)}, which TradingView refuses as an "
@@ -922,8 +1018,6 @@ class CollectionHistoryChecker:
                 return self._reject(
                     node, f"{label} is {_a(kind)}, which TradingView refuses as an "
                     "element of array.from (CE10122).")
-            if namespace == "matrix" and member == "sum" and kind == "matrix":
-                return self._matrix_sum_use(node, label)
             if member in methods:
                 return self._builtin_slot_use(
                     namespace, member, positional, keyword, node, kind, label)
@@ -972,7 +1066,7 @@ class CollectionHistoryChecker:
             return Use("copy", node, names=self._parameter_uses(
                 definitions, position, keyword, kind),
                 needs_collection=self._parameter_is_collection(
-                    definitions, position, keyword))
+                    definitions, position, keyword), crosses_callable=True)
         if (namespace not in _BUILTIN_NAMESPACES and namespace not in self._types
                 and (member in self._array_methods or member in self._matrix_methods)):
             # A built-in method on another collection (``c.concat(a[1])``,
@@ -1410,6 +1504,14 @@ class CollectionHistoryChecker:
         if use.how == "copy":
             if uses.change is not None:
                 return self._change_refusal(read, label, uses.change, "a name bound to it")
+            nullable = (uses.element is not None
+                        and all(not tag.startswith("render") for tag in uses.tags))
+            # A value that reaches a user callable's parameter, directly or
+            # through a name, stays the copy it was: the parameter is a
+            # ``std::vector&``, which holds no na array and answers no na().
+            parameter_copy = uses.crosses_parameter
+            if (nullable and not parameter_copy and uses.other is None):
+                return Decision(SUPPORTED, "reference" if kind == "array" else "copy")
             if uses.needs_collection():
                 if uses.element is not None:
                     return Decision(
@@ -1422,7 +1524,7 @@ class CollectionHistoryChecker:
                     return Decision(REFUSED, node=uses.other.node or read.node,
                                     message=uses.other.message or
                                     f"{label} is not supported in PineForge here.")
-                return Decision(SUPPORTED, "copy")
+                return Decision(SUPPORTED, "reference" if kind == "array" and not parameter_copy else "copy")
             return None
         if kind == "matrix" and use.how == "discard":
             return Decision(SUPPORTED, "copy")

package/pineforge_codegen/diagnostics_catalog.json

@@ -357,6 +357,7 @@
   "PF-E5049": {"severity": "error", "area": "codegen", "message": "session.{flag}[...] is not supported here: PineForge keeps a session flag''s history for the script''s top level, a function body and a request.security expression that reads it.", "hint": null, "explanation": "A session flag history read is supported only at the top level, in a function body or in a request.security expression, and this read is none of those.", "args": {"flag": {"kind": "identifier"}}},
   "PF-E5050": {"severity": "error", "area": "codegen", "message": "History of the chart.point {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.", "explanation": "History of a chart.point variable whose fields the script changes is refused because PineForge holds points as values; use a separate variable or build a new point.", "args": {"object_name": {"kind": "identifier"}}},
   "PF-E5051": {"severity": "error", "area": "codegen", "message": "matrix ''{target_label}'' element type mismatch on reassignment: expected {target_type}, got {rhs_type}", "hint": null, "explanation": "A matrix variable is reassigned a matrix with a different element type, which Pine forbids; make the new matrix's element type match the variable's.", "args": {"target_label": {"kind": "identifier"}, "target_type": {"kind": "type"}, "rhs_type": {"kind": "type"}}},
+  "PF-E5052": {"severity": "error", "area": "codegen", "message": "array.{method}: wrong number of arguments", "hint": null, "explanation": "An array method call has too few arguments for its lowering; check the Pine v6 array method signature.", "args": {"method": {"kind": "identifier"}}},
   "PF-E6001": {"severity": "error", "area": "collection-history", "message": "matrix.{method}: wrong number of arguments", "hint": "Check Pine v6 matrix method signature (positional vs keyword).", "explanation": "A matrix method call has the wrong number of arguments; check the Pine v6 matrix method signature and whether arguments are positional or keyword.", "args": {"method": {"kind": "identifier"}}},
   "PF-E6002": {"severity": "error", "area": "collection-history", "message": "{label} := ...: an assignment to the history-referencing operator is not supported in PineForge.", "hint": null, "explanation": "TradingView refuses an assignment to a history reference; assign the variable itself.", "args": {"label": {"kind": "text"}}},
   "PF-E6003": {"severity": "error", "area": "collection-history", "message": "{label} is a {kind}, which TradingView refuses for operator {op} (CE10123).", "hint": null, "explanation": "An array or matrix history read such as a[1] is an operand of an operator, which TradingView refuses; read an element or the size and use that instead.", "args": {"label": {"kind": "identifier"}, "kind": {"kind": "vocab", "values": ["array", "matrix"]}, "op": {"kind": "keyword"}}},

package/pineforge_codegen/external_requests.py

@@ -359,7 +359,7 @@ def no_data_request(node) -> str | None:
     return None
 
 
-def spell_call(node: FuncCall) -> str:
+def spell_call_spelling(node: FuncCall) -> str:
     """The call as a message names it: callee and its first arguments."""
     ns, name = _call_name(node)
     head = f"{ns}.{name}" if ns else str(name)
@@ -379,8 +379,13 @@ def spell_call(node: FuncCall) -> str:
     shown = [arg(a) for a in node.args[:2]]
     if len(node.args) > 2 or node.kwargs:
         shown.append("...")
+    return f"{head}({', '.join(shown)})"
+
+
+def spell_call(node: FuncCall) -> str:
+    """The message's call spelling and its top-level source-line suffix."""
     line = f" at line {node.loc.line}" if node.loc is not None else ""
-    return f"{head}({', '.join(shown)}){line}"
+    return f"{spell_call_spelling(node)}{line}"
 
 
 class TradeSlice:
@@ -745,6 +750,21 @@ def unpinned_message(node: FuncCall) -> str:
     return f"{spell_call(node)}: no data is pinned for this request, and its value was read"
 
 
+def request_stop_marker(node: FuncCall) -> dict:
+    """Keep stop provenance before lowering replaces a request's arguments."""
+    namespace, function = _call_name(node)
+    other_symbol = function in ("security", "security_lower_tf")
+    symbol = node.args[0] if node.args else node.kwargs.get("symbol")
+    return {
+        "message": unpinned_message(node),
+        "kind": "other_symbol" if other_symbol else "no_data",
+        "function": f"{namespace}.{function}",
+        "call": spell_call_spelling(node),
+        "line": node.loc.line if node.loc else 1,
+        "symbol_literal": symbol.value if isinstance(symbol, StringLiteral) else None,
+    }
+
+
 def _na_of(request: FuncCall, funcs: dict[str, FuncDef]) -> ASTNode:
     """The ``na`` a request lowers to when no data is read for it."""
     payload = None if no_data_request(request) else (
@@ -799,7 +819,7 @@ def lower_no_data_requests(program: Program) -> Program:
             continue
         if lowering == ABSENT_LOWERING:
             _record_unpinned_capability(program, node)
-            node.annotations = {**node.annotations, UNPINNED_ANNOTATION: unpinned_message(node)}
+            node.annotations = {**node.annotations, UNPINNED_ANNOTATION: request_stop_marker(node)}
             continue
         swaps[id(node)] = _na_of(node, funcs)
         if lowering == "unpinned":
@@ -811,12 +831,12 @@ def lower_no_data_requests(program: Program) -> Program:
                         if isinstance(stmt, (VarDecl, TupleAssign))}
         for request in unpinned:
             _mark_reads(program, index, declarations, request, swaps[id(request)],
-                        unpinned_message(request))
+                        request_stop_marker(request))
         for request in backed:
             ref = RequestRef()
             request.annotations = {**(request.annotations or {}), REQUEST_REF_ANNOTATION: ref}
             _mark_reads(program, index, declarations, request, request,
-                        {"message": unpinned_message(request), "ref": ref})
+                        {**request_stop_marker(request), "ref": ref})
             if request.annotations.get(LOWERING_ANNOTATION) == RECORDED_LOWERING:
                 # The key's other parts are constants: the call keeps its
                 # symbol, the one part the run computes.
@@ -872,7 +892,7 @@ def unpin_requests(program: Program, reasons: dict[int, str]) -> None:
         marker = (request.annotations or {}).get(UNPINNED_ANNOTATION)
         if isinstance(marker, dict):
             lowered.annotations = {**(lowered.annotations or {}),
-                                   UNPINNED_ANNOTATION: marker["message"]}
+                                   UNPINNED_ANNOTATION: {k: v for k, v in marker.items() if k != "ref"}}
         swaps[request_id] = lowered
         # The request leaves the program; its lowering is the deferred
         # refusal's now (``request_discovery`` lists it so).
@@ -885,11 +905,12 @@ def unpin_requests(program: Program, reasons: dict[int, str]) -> None:
             f"registration computes before the first bar; {reasons[request_id]}."))
     for node in _nodes(program):
         marker = (node.annotations or {}).get(UNPINNED_ANNOTATION)
-        if isinstance(marker, dict) and id(marker["ref"]) in chart_refs:
+        if isinstance(marker, dict) and "ref" in marker and id(marker["ref"]) in chart_refs:
             node.annotations = {k: v for k, v in node.annotations.items()
                                 if k != UNPINNED_ANNOTATION}
-        elif isinstance(marker, dict) and id(marker["ref"]) in refs:
-            node.annotations = {**node.annotations, UNPINNED_ANNOTATION: marker["message"]}
+        elif isinstance(marker, dict) and "ref" in marker and id(marker["ref"]) in refs:
+            node.annotations = {**node.annotations,
+                                UNPINNED_ANNOTATION: {k: v for k, v in marker.items() if k != "ref"}}
     if swaps:
         replace_nodes(program, swaps)
     notes = program.annotations = dict(program.annotations or {})

package/pineforge_codegen/matrix_overloads.py

@@ -0,0 +1,7 @@
+"""Argument-dependent result types of numeric matrix operations."""
+
+from .ast_nodes import FuncCall
+
+
+def matrix_sum_has_rhs(call: FuncCall, *, namespace: bool = False) -> bool:
+    return len(call.args) > int(namespace) or "id2" in call.kwargs

package/pineforge_codegen/parser.py

@@ -589,9 +589,14 @@ class Parser:
 
         if (len(tokens) in (5, 7) and word(0) and word(2)
                 and values[1] == values[3] == "/"
-                and tokens[4].type == TokenType.NUMBER and values[4].isdigit()
+                and tokens[4].type == TokenType.NUMBER
+                and values[4].isascii() and values[4].isdecimal()
                 and (len(tokens) == 5 or (values[5] == "as" and word(6)))):
-            node.user, node.name, node.version = values[0], values[2], int(values[4])
+            try:
+                version = int(values[4])
+            except ValueError:
+                return self._set_loc(node, start_tok)
+            node.user, node.name, node.version = values[0], values[2], version
             node.path = f"{node.user}/{node.name}/{node.version}"
             if len(tokens) == 7:
                 node.alias = values[6]

package/pineforge_codegen/signatures.py

@@ -404,8 +404,8 @@ SYMINFO_FUNCTIONS: dict[str, IntrinsicFunc] = {}
 def _syminfo_fn(short_name: str, *sigs: FuncSig) -> None:
     SYMINFO_FUNCTIONS[short_name] = _func(f"syminfo.{short_name}", *sigs)
 
-_syminfo_fn("prefix", _sig([], ret=S))
-_syminfo_fn("ticker", _sig([], ret=S))
+_syminfo_fn("prefix", _sig([("symbol", S)], ret=S))
+_syminfo_fn("ticker", _sig([("symbol", S)], ret=S))
 
 
 # ============================================================================