@pineforge/codegen-pyodide 1.3.0 → 1.4.0

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))
 
 
 # ============================================================================

package/pineforge_codegen/support_checker.py

@@ -549,6 +549,20 @@ def _qualified_name(callee: ASTNode) -> tuple[str | None, str | None]:
     return None, None
 
 
+# The ``array.*`` functions whose value is a new array.
+_ARRAY_VALUED_FUNCTIONS = frozenset({"new", "from", "copy", "slice"})
+
+
+def _is_array_valued_call(node) -> bool:
+    """Whether ``node`` is a call of ``array.new``, ``array.new_<type>``,
+    ``array.from``, ``array.copy`` or ``array.slice``."""
+    if not isinstance(node, FuncCall):
+        return False
+    namespace, function = _qualified_name(node.callee)
+    return namespace == "array" and function is not None and (
+        function in _ARRAY_VALUED_FUNCTIONS or function.startswith("new_"))
+
+
 def _resolve_member_chain(node: ASTNode) -> str | None:
     """Flatten a MemberAccess/Identifier chain into a dotted name."""
     if isinstance(node, Identifier):
@@ -661,6 +675,11 @@ class SupportChecker:
         # then ``request.security(haTicker, ...)``, or ``reqSym = cond ? other :
         # syminfo.tickerid``. First binding wins (closest to declaration).
         self._scalar_defs: dict[str, ASTNode] = {}
+        # Variables declared an array (by an array-valued call or an
+        # ``array<...>`` type), and the names the script binds exactly once:
+        # the receivers ``_check_bound_array_concat`` resolves by name.
+        self._array_names: set[str] = set()
+        self._bound_once: set[str] | None = None
         # EVERY reassignment value bound to a scalar name (``name := <expr>``
         # and the compound forms). A declaration alone does not pin the value a
         # ``request.security`` symbol argument actually carries: the engine is
@@ -1335,6 +1354,10 @@ class SupportChecker:
 
     def _visit_VarDecl(self, node: VarDecl) -> None:
         self._check_tuple_literal_value(node.value)
+        self._check_bound_array_concat(node.value)
+        if node.name and (_is_array_valued_call(node.value)
+                          or (node.type_hint or "").startswith("array<")):
+            self._array_names.add(node.name)
         if node.name and node.value is not None:
             self._scalar_defs.setdefault(node.name, node.value)
         if node.name and (node.is_var or node.is_varip):
@@ -1367,6 +1390,7 @@ class SupportChecker:
         self._visit_children(node)
 
     def _visit_Assignment(self, node: Assignment) -> None:
+        self._check_bound_array_concat(node.value)
         if isinstance(node.target, TupleLiteral):
             # ``[p, q] := f()`` reached the C++ as an assignment to a
             # temporary tuple, a silent no-op. TradingView rejects it
@@ -1390,6 +1414,64 @@ class SupportChecker:
         self._record_scalar_rebind(node)
         self._visit_children(node)
 
+    def _check_bound_array_concat(self, value) -> None:
+        """Refuse the value of ``array.concat``: PineForge lowers the call as
+        the statement that appends to the first array (``a.concat(b)`` or
+        ``array.concat(a, b)``), which has no value to bind. The namespace
+        call is refused wherever its value is bound; the method form only on a
+        receiver known to be an array (a call that builds one, or a variable
+        declared as one that the script binds exactly once, so that a
+        parameter or a local of another type never shares the name), and never
+        when the script defines a method of that name."""
+        if not isinstance(value, FuncCall):
+            return
+        if isinstance(value.callee, MemberAccess):
+            # ``_qualified_name`` names no call receiver (``array.copy(a).concat(b)``).
+            method = value.callee.member
+            namespace = (value.callee.object.name
+                         if isinstance(value.callee.object, Identifier) else None)
+        else:
+            namespace, method = _qualified_name(value.callee)
+        if method != "concat":
+            return
+        if namespace != "array":
+            if method in self._user_methods or not isinstance(value.callee, MemberAccess):
+                return
+            receiver = value.callee.object
+            while isinstance(receiver, Subscript):
+                receiver = receiver.object
+            if not (_is_array_valued_call(receiver)
+                    or (isinstance(receiver, Identifier)
+                        and receiver.name in self._array_names
+                        and receiver.name in self._names_bound_once())):
+                return
+        name = method
+        self._err(value, f"array.{name}(...) is not implemented in PineForge runtime.")
+
+    def _names_bound_once(self) -> set[str]:
+        """The names the script binds exactly once: by one declaration, with
+        no function or method parameter, loop variable, tuple element or
+        second declaration (a local beside a global) sharing the name."""
+        if self._bound_once is None:
+            counts: dict[str, int] = {}
+            for item in _walk_nodes(self._ast):
+                if isinstance(item, VarDecl):
+                    names = (item.name,)
+                elif isinstance(item, TupleAssign):
+                    names = tuple(item.names)
+                elif isinstance(item, (FuncDef, MethodDef)):
+                    names = tuple(getattr(param, "name", param) for param in item.params)
+                elif isinstance(item, ForStmt):
+                    names = (item.var,)
+                elif isinstance(item, ForInStmt):
+                    names = tuple(item.vars or ()) + ((item.var,) if item.var else ())
+                else:
+                    continue
+                for name in names:
+                    counts[name] = counts.get(name, 0) + 1
+            self._bound_once = {name for name, count in counts.items() if count == 1}
+        return self._bound_once
+
     def _check_tuple_literal_value(self, value) -> None:
         """Refuse a tuple literal or a ternary of tuples as a declaration's
         or reassignment's value.

package/release.json

@@ -1,7 +1,7 @@
 {
-  "codegen": "1.3.0",
+  "codegen": "1.4.0",
   "pyodide": "314.0.0",
   "python": "3.14.0",
   "emscripten": "emscripten_5_0_3",
-  "sha256": "b058ef7c8ded42e7a80ccf551e62985e052d1e306aebf615ab9937544f060839"
+  "sha256": "fe674a25ca188d1d6902b01f81d040fc62e6ad9ee325afae7287d990248e1f97"
 }

package/tables.json

@@ -1,5 +1,5 @@
 {
-  "CODEGEN_VERSION": "1.3.0",
+  "CODEGEN_VERSION": "1.4.0",
   "TA_CLASS_MAP_KEYS": [
     "sma",
     "ema",
@@ -1121,8 +1121,12 @@
       "id",
       "id2"
     ],
-    "syminfo.prefix": [],
-    "syminfo.ticker": [],
+    "syminfo.prefix": [
+      "symbol"
+    ],
+    "syminfo.ticker": [
+      "symbol"
+    ],
     "na": [
       "x"
     ],