@pineforge/codegen-pyodide 0.10.0 → 0.10.2

package/pineforge_codegen/codegen/tables.py

@@ -458,22 +458,256 @@ ORDER_DIRECTION_MAP = {
 # Array / Map / Matrix method dispatch
 # ---------------------------------------------------------------------------
 
+
+def _checked_array_index_prelude(
+    *,
+    normalize_negative: bool = True,
+    allow_size: bool = False,
+    name: str = "index",
+) -> str:
+    """C++ body shared by checked single-index operations.
+
+    Pine v6 explicitly gives end-relative negative indices to ``array.get``,
+    ``array.set``, ``array.insert``, and ``array.remove``. Other indexed
+    functions such as ``percentrank`` and the ``fill``/``slice`` range
+    endpoints still need the same NA/non-finite/range checks, but must reject
+    negative indices instead of normalizing them (``normalize_negative``).
+
+    ``allow_size`` widens the upper bound from ``index < size`` to
+    ``index <= size``. An *element access* is invalid at ``size``, but an
+    *insertion point* is not: ``array.insert(id, size, v)`` appends, and the
+    half-open ``[index_from, index_to)`` ranges of ``array.fill`` /
+    ``array.slice`` legally end at ``size``.
+
+    ``name`` renames every emitted local so two endpoints can be checked in
+    one C++ scope without colliding. ``name="index"`` reproduces the original
+    identifiers byte-for-byte.
+    """
+    raw_value = f"__pf_raw_{name}_value"
+    raw_type = f"__pf_raw_{name}_type"
+    raw_text = f"__pf_raw_{name}_text"
+    raw_wide = f"__pf_raw_{name}_wide"
+    raw = f"__pf_raw_{name}"
+    checked = f"__pf_array_{name}"
+    size = "__pf_array_size" if name == "index" else f"__pf_array_size_{name}"
+    checked_index = (
+        f"{raw}<0?{raw}+{size}:{raw}" if normalize_negative else raw
+    )
+    upper = ">" if allow_size else ">="
+    return (
+        f"using {raw_type}=std::decay_t<decltype({raw_value})>; "
+        f"if constexpr(!std::is_same_v<{raw_type},bool>) {{ "
+        f"if(is_na({raw_value})) "
+        "pine_runtime_error(std::string(\"Index na is out of bounds. Array size is \")+"
+        "std::to_string((int64_t)__pf_array.size())); } "
+        f"if constexpr(std::is_floating_point_v<{raw_type}>) {{ "
+        f"if(!std::isfinite({raw_value})) {{ "
+        f"std::string {raw_text}={raw_value}>0?\"inf\":\"-inf\"; "
+        f"pine_runtime_error(std::string(\"Index \")+{raw_text}+"
+        "\" is out of bounds. Array size is \"+"
+        "std::to_string((int64_t)__pf_array.size())); } "
+        f"long double {raw_wide}=(long double){raw_value}; "
+        f"if({raw_wide}<(long double)std::numeric_limits<int64_t>::min()||"
+        f"{raw_wide}>(long double)std::numeric_limits<int64_t>::max()) "
+        "pine_runtime_error(std::string(\"Index \")+"
+        f"std::to_string((double){raw_value})+"
+        "\" is out of bounds. Array size is \"+"
+        "std::to_string((int64_t)__pf_array.size())); } "
+        f"int64_t {raw}=(int64_t){raw_value}; "
+        f"int64_t {size}=(int64_t)__pf_array.size(); "
+        f"int64_t {checked}={checked_index}; "
+        f"if({checked}<0||{checked}{upper}{size}) "
+        f"pine_runtime_error(std::string(\"Index \")+std::to_string({raw})+"
+        f"\" is out of bounds. Array size is \"+std::to_string({size})); "
+    )
+
+
+def _checked_array_range_prelude() -> str:
+    """Validate the half-open ``[index_from, index_to)`` range of fill/slice.
+
+    Both endpoints are checked with ``allow_size`` (``index_to`` is exclusive,
+    so ``size`` is a legal endpoint) and without negative normalization
+    (neither function appears in the Pine v6 reference's negative-indexing
+    set). An inverted range is rejected rather than silently treated as empty:
+    ``begin()+from > begin()+to`` is undefined behaviour in the STL forms this
+    replaces, and no evidence pins TradingView's behaviour there.
+    """
+    return (
+        _checked_array_index_prelude(
+            normalize_negative=False, allow_size=True, name="index_from"
+        )
+        + _checked_array_index_prelude(
+            normalize_negative=False, allow_size=True, name="index_to"
+        )
+        + "if(__pf_array_index_from>__pf_array_index_to) "
+        "pine_runtime_error(std::string(\"Index range \")+"
+        "std::to_string(__pf_array_index_from)+\"..\"+"
+        "std::to_string(__pf_array_index_to)+"
+        "\" is invalid. Array size is \"+"
+        "std::to_string(__pf_array_size_index_from)); "
+    )
+
+
+def _checked_array_insert(a: str, args: list[str]) -> str:
+    """``array.insert(id, index, value)`` — index is an INSERTION point.
+
+    ``index == size`` appends, so the bound is ``index <= size``; a negative
+    index is end-relative, exactly as for ``get``/``set``/``remove``.
+    """
+    check = _checked_array_index_prelude(allow_size=True)
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_value){ "
+        "return [&](auto&& __pf_array_value){ "
+        f"{check}"
+        "__pf_array.insert(__pf_array.begin()+(size_t)__pf_array_index, "
+        "__pf_array_value); "
+        f"}}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def _checked_array_fill_range(a: str, args: list[str]) -> str:
+    """``array.fill(id, value, index_from, index_to)`` — bounded range fill."""
+    check = _checked_array_range_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_array_value){ "
+        "return [&](auto&& __pf_raw_index_from_value){ "
+        "return [&](auto&& __pf_raw_index_to_value){ "
+        f"{check}"
+        "std::fill(__pf_array.begin()+(size_t)__pf_array_index_from, "
+        "__pf_array.begin()+(size_t)__pf_array_index_to, __pf_array_value); "
+        f"}}(({args[2]})); }}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
+    """``array.slice(id, index_from, index_to)`` — bounded range extraction.
+
+    ``result_type`` stays caller-supplied so the typed method lane keeps
+    emitting the receiver's own element type; only the bounds checks are new.
+    """
+    check = _checked_array_range_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_from_value){ "
+        "return [&](auto&& __pf_raw_index_to_value){ "
+        f"{check}"
+        f"return {result_type}(__pf_array.begin()+(size_t)__pf_array_index_from, "
+        "__pf_array.begin()+(size_t)__pf_array_index_to); "
+        f"}}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def _checked_array_get(a: str, args: list[str]) -> str:
+    check = _checked_array_index_prelude()
+    return (
+        "[&](auto&& __pf_array)->decltype(auto){ "
+        "return [&](auto&& __pf_raw_index_value)->decltype(auto){ "
+        f"{check}"
+        "if constexpr(std::is_lvalue_reference_v<decltype(__pf_array)>) "
+        "return (__pf_array[(size_t)__pf_array_index]); "
+        "else { using __pf_array_value_type=typename "
+        "std::decay_t<decltype(__pf_array)>::value_type; "
+        "return __pf_array_value_type(__pf_array[(size_t)__pf_array_index]); } "
+        f"}}(({args[0]})); }}(({a}))"
+    )
+
+
+def _checked_array_set(a: str, args: list[str]) -> str:
+    check = _checked_array_index_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_value){ "
+        "return [&](auto&& __pf_array_value){ "
+        f"{check}"
+        "__pf_array[(size_t)__pf_array_index]=__pf_array_value; "
+        f"}}(({args[1]})); }}(({args[0]})); }}(({a}))"
+    )
+
+
+def _checked_array_remove(a: str, args: list[str]) -> str:
+    check = _checked_array_index_prelude()
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_value){ "
+        f"{check}"
+        "using __pf_array_value_type=typename "
+        "std::decay_t<decltype(__pf_array)>::value_type; "
+        "__pf_array_value_type __pf_array_value="
+        "__pf_array[(size_t)__pf_array_index]; "
+        "__pf_array.erase(__pf_array.begin()+(size_t)__pf_array_index); "
+        "return __pf_array_value; "
+        f"}}(({args[0]})); }}(({a}))"
+    )
+
+
+def _checked_array_end_get(a: str, method: str) -> str:
+    access = "front" if method == "first" else "back"
+    return (
+        "[&](auto&& __pf_array)->decltype(auto){ "
+        f"if(__pf_array.empty()) pine_runtime_error(\"Cannot use {method}() "
+        "if array is empty.\"); "
+        "if constexpr(std::is_lvalue_reference_v<decltype(__pf_array)>) "
+        f"return (__pf_array.{access}()); "
+        "else { using __pf_array_value_type=typename "
+        "std::decay_t<decltype(__pf_array)>::value_type; "
+        f"return __pf_array_value_type(__pf_array.{access}()); }} "
+        f"}}(({a}))"
+    )
+
+
+def _checked_array_end_remove(a: str, method: str) -> str:
+    access = "back" if method == "pop" else "front"
+    mutation = (
+        "__pf_array.pop_back();"
+        if method == "pop"
+        else "__pf_array.erase(__pf_array.begin());"
+    )
+    return (
+        "[&](auto&& __pf_array){ "
+        f"if(__pf_array.empty()) pine_runtime_error(\"Cannot use {method}() "
+        "if array is empty.\"); "
+        "using __pf_array_value_type=typename "
+        "std::decay_t<decltype(__pf_array)>::value_type; "
+        f"__pf_array_value_type __pf_array_value=__pf_array.{access}(); "
+        f"{mutation} return __pf_array_value; }}(({a}))"
+    )
+
+
+def _checked_array_percentrank(a: str, args: list[str]) -> str:
+    """Preserve degenerate results, then reject invalid PercentRank indices."""
+    check = _checked_array_index_prelude(normalize_negative=False)
+    return (
+        "[&](auto&& __pf_array){ "
+        "return [&](auto&& __pf_raw_index_value){ "
+        "if(__pf_array.size()<=1) return na<double>(); "
+        f"{check}"
+        "double v=__pf_array[(size_t)__pf_array_index]; "
+        "if(std::isnan(v)) return na<double>(); "
+        "int le=0; for(auto x:__pf_array) "
+        "if(!std::isnan(x) && x<=v) le++; "
+        "return (double)(le-1)/(__pf_array.size()-1)*100.0; "
+        f"}}(({args[0]})); }}(({a}))"
+    )
+
+
 # Methods called as ``array.method(arr, ...)`` or ``arr.method(...)``.
 ARRAY_METHODS = {
-    "get":       lambda a, args: f"{a}[({args[0]})]",
-    "set":       lambda a, args: f"{a}[({args[0]})] = {args[1]}",
+    "get":       _checked_array_get,
+    "set":       _checked_array_set,
     "push":      lambda a, args: f"{a}.push_back({args[0]})",
     "unshift":   lambda a, args: f"{a}.insert({a}.begin(), {args[0]})",
-    "insert":    lambda a, args: f"{a}.insert({a}.begin() + (int)({args[0]}), {args[1]})",
-    "pop":       lambda a, args: f"[&](){{ auto v={a}.back(); {a}.pop_back(); return v; }}()",
-    "shift":     lambda a, args: f"[&](){{ auto v={a}.front(); {a}.erase({a}.begin()); return v; }}()",
-    "remove":    lambda a, args: f"[&](){{ auto v={a}[({args[0]})]; {a}.erase({a}.begin()+(int)({args[0]})); return v; }}()",
-    "first":     lambda a, args: f"{a}.front()",
-    "last":      lambda a, args: f"{a}.back()",
+    "insert":    _checked_array_insert,
+    "pop":       lambda a, args: _checked_array_end_remove(a, "pop"),
+    "shift":     lambda a, args: _checked_array_end_remove(a, "shift"),
+    "remove":    _checked_array_remove,
+    "first":     lambda a, args: _checked_array_end_get(a, "first"),
+    "last":      lambda a, args: _checked_array_end_get(a, "last"),
     "size":      lambda a, args: f"(double){a}.size()",
     "clear":     lambda a, args: f"{a}.clear()",
     "fill":      lambda a, args: f"std::fill({a}.begin(), {a}.end(), {args[0]})" if len(args) == 1
-                                 else f"std::fill({a}.begin()+(int)({args[1]}), {a}.begin()+(int)({args[2]}), {args[0]})",
+                                 else _checked_array_fill_range(a, args),
     "includes":  lambda a, args: f"(std::find({a}.begin(), {a}.end(), {args[0]}) != {a}.end())",
     "indexof":   lambda a, args: f"[&](){{ auto it=std::find({a}.begin(),{a}.end(),{args[0]}); return it!={a}.end()?(double)(it-{a}.begin()):-1.0; }}()",
     "lastindexof": lambda a, args: f"[&](){{ for(int i=(int){a}.size()-1;i>=0;i--)if({a}[i]=={args[0]})return(double)i; return -1.0; }}()",
@@ -483,58 +717,90 @@ ARRAY_METHODS = {
     ),
     "reverse":   lambda a, args: f"std::reverse({a}.begin(),{a}.end())",
     "copy":      lambda a, args: f"std::vector<double>({a})",
-    "slice":     lambda a, args: f"std::vector<double>({a}.begin()+(int)({args[0]}),{a}.begin()+(int)({args[1]}))",
+    "slice":     lambda a, args: checked_array_slice(a, args, result_type="std::vector<double>"),
     "concat":    lambda a, args: f"{a}.insert({a}.end(),{args[0]}.begin(),{args[0]}.end())",
-    "sum":       lambda a, args: f"std::accumulate({a}.begin(),{a}.end(),0.0)",
-    "avg":       lambda a, args: f"({a}.empty()?0.0:std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size())",
-    "min":       lambda a, args: f"*std::min_element({a}.begin(),{a}.end())",
-    "max":       lambda a, args: f"*std::max_element({a}.begin(),{a}.end())",
-    "range":     lambda a, args: f"(*std::max_element({a}.begin(),{a}.end())-*std::min_element({a}.begin(),{a}.end()))",
+    "sum":       lambda a, args: f"({a}.empty()?na<double>():std::accumulate({a}.begin(),{a}.end(),0.0))",
+    "avg":       lambda a, args: f"({a}.empty()?na<double>():std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size())",
+    "min":       lambda a, args: f"({a}.empty()?na<double>():*std::min_element({a}.begin(),{a}.end()))",
+    "max":       lambda a, args: f"({a}.empty()?na<double>():*std::max_element({a}.begin(),{a}.end()))",
+    "range":     lambda a, args: f"({a}.empty()?na<double>():*std::max_element({a}.begin(),{a}.end())-*std::min_element({a}.begin(),{a}.end()))",
     "every":     lambda a, args: f"std::all_of({a}.begin(),{a}.end(),[](double v){{return v!=0.0;}})",
     "some":      lambda a, args: f"std::any_of({a}.begin(),{a}.end(),[](double v){{return v!=0.0;}})",
     # stdev/variance honor the optional 2nd ``biased`` arg (Pine v6:
-    # biased=true → population (default), false → sample / n-1). The no-arg
-    # form keeps the original population emission byte-identical.
+    # biased=true → population (default), false → sample / n-1).
     "stdev":     lambda a, args: (
-        f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); "
+        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); "
         f"double _d=({args[0]})?(double){a}.size():((double){a}.size()-1.0); "
         f"return _d>0?std::sqrt(s/_d):na<double>(); }}()"
         if args else
-        f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); return std::sqrt(s/{a}.size()); }}()"
+        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); return std::sqrt(s/{a}.size()); }}()"
     ),
     "variance":  lambda a, args: (
-        f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); "
+        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); "
         f"double _d=({args[0]})?(double){a}.size():((double){a}.size()-1.0); "
         f"return _d>0?s/_d:na<double>(); }}()"
         if args else
-        f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); return s/{a}.size(); }}()"
+        f"[&](){{ if({a}.empty()) return na<double>(); double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); return s/{a}.size(); }}()"
     ),
-    "median":    lambda a, args: f"[&](){{ auto c={a}; std::sort(c.begin(),c.end()); int n=c.size(); return n%2?c[n/2]:(c[n/2-1]+c[n/2])/2.0; }}()",
-    "mode":      lambda a, args: f"[&](){{ std::unordered_map<double,int> m; for(auto v:{a})m[v]++; double best=0; int bc=0; for(auto&[v,c]:m)if(c>bc||(c==bc&&v<best)){{bc=c;best=v;}} return best; }}()",
-    "percentile_linear_interpolation": lambda a, args: f"[&](){{ auto c={a}; std::sort(c.begin(),c.end()); double k=({args[0]}/100.0)*c.size()-0.5; int i=std::max(0,(int)k); double f=k-i; if(i+1>=(int)c.size()) return c.back(); return c[i]*(1-f)+c[i+1]*f; }}()",
-    "percentile_nearest_rank": lambda a, args: f"[&](){{ auto c={a}; std::sort(c.begin(),c.end()); int r=(int)std::ceil(({args[0]}/100.0)*c.size()); return c[std::min(r-1,(int)c.size()-1)]; }}()",
-    "percentrank": lambda a, args: f"[&](){{ if({a}.size()<=1) return na<double>(); double v={a}[({args[0]})]; if(std::isnan(v)) return na<double>(); int le=0; for(auto x:{a}) if(!std::isnan(x) && x<=v) le++; return (double)(le-1)/({a}.size()-1)*100.0; }}()",
+    "median":    lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto c={a}; std::sort(c.begin(),c.end()); int n=c.size(); return n%2?c[n/2]:(c[n/2-1]+c[n/2])/2.0; }}()",
+    "mode":      lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); std::unordered_map<double,int> m; for(auto v:{a})m[v]++; double best=0; int bc=0; for(auto&[v,c]:m)if(c>bc||(c==bc&&v<best)){{bc=c;best=v;}} return best; }}()",
+    "percentile_linear_interpolation": lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto c={a}; std::sort(c.begin(),c.end()); double k=({args[0]}/100.0)*c.size()-0.5; int i=std::max(0,(int)k); double f=k-i; if(i+1>=(int)c.size()) return c.back(); return c[i]*(1-f)+c[i+1]*f; }}()",
+    "percentile_nearest_rank": lambda a, args: f"[&](){{ if({a}.empty()) return na<double>(); auto c={a}; std::sort(c.begin(),c.end()); int r=(int)std::ceil(({args[0]}/100.0)*c.size()); return (double)c[std::min(r-1,(int)c.size()-1)]; }}()",
+    "percentrank": _checked_array_percentrank,
     "abs":       lambda a, args: f"[&](){{ std::vector<double> r; for(auto v:{a})r.push_back(std::abs(v)); return r; }}()",
     "join":      lambda a, args: "[&](){{ std::string r; for(size_t i=0;i<{arr}.size();i++){{ if(i>0)r+={sep}; r+=std::to_string({arr}[i]); }} return r; }}()".format(arr=a, sep=args[0] if args else 'std::string(",")'),
     "standardize": lambda a, args: f"[&](){{ double m=std::accumulate({a}.begin(),{a}.end(),0.0)/{a}.size(); double s=0; for(auto v:{a})s+=(v-m)*(v-m); s=std::sqrt(s/{a}.size()); std::vector<double> r; for(auto v:{a})r.push_back(s==0?1.0:(v-m)/s); return r; }}()",
-    "covariance": lambda a, args: f"[&](){{ auto&b={args[0]}; int n=std::min({a}.size(),b.size()); double ma=0,mb=0; for(int i=0;i<n;i++){{ma+={a}[i];mb+=b[i];}} ma/=n;mb/=n; double c=0; for(int i=0;i<n;i++)c+=({a}[i]-ma)*(b[i]-mb); return c/n; }}()",
+    "covariance": lambda a, args: f"[&](){{ auto&&b=({args[0]}); int n=std::min({a}.size(),b.size()); if(n<=0) return na<double>(); double ma=0,mb=0; for(int i=0;i<n;i++){{ma+={a}[i];mb+=b[i];}} ma/=n;mb/=n; double c=0; for(int i=0;i<n;i++)c+=({a}[i]-ma)*(b[i]-mb); return c/n; }}()",
     "binary_search": lambda a, args: f"[&](){{ auto it=std::lower_bound({a}.begin(),{a}.end(),{args[0]}); return (it!={a}.end()&&*it=={args[0]})?(double)(it-{a}.begin()):-1.0; }}()",
     "binary_search_leftmost": lambda a, args: f"[&](){{ auto it=std::lower_bound({a}.begin(),{a}.end(),{args[0]}); return (it!={a}.end()&&*it=={args[0]})?(double)(it-{a}.begin()):(double)(it-{a}.begin()-1); }}()",
     "binary_search_rightmost": lambda a, args: f"[&](){{ auto it=std::upper_bound({a}.begin(),{a}.end(),{args[0]}); return (it!={a}.begin()&&*(it-1)=={args[0]})?(double)(it-{a}.begin()-1):(double)(it-{a}.begin()); }}()",
     "sort_indices": lambda a, args: f"[&](){{ std::vector<double> idx({a}.size()); std::iota(idx.begin(),idx.end(),0); std::sort(idx.begin(),idx.end(),[&](int i,int j){{return {a}[i]<{a}[j];}}); return idx; }}()",
 }
 
+# Pine parameter order for the checked-index subset. Keeping the receiver
+# (``id``) separate lets method syntax merge ``a.get(index = i)`` while the
+# namespace-functional path merges ``array.get(id = a, index = i)``.
+CHECKED_ARRAY_METHOD_KWARGS: dict[str, list[str]] = {
+    "get": ["index"],
+    "set": ["index", "value"],
+    "remove": ["index"],
+    "percentrank": ["index"],
+    "insert": ["index", "value"],
+    "fill": ["value", "index_from", "index_to"],
+    "slice": ["index_from", "index_to"],
+    "first": [],
+    "last": [],
+    "pop": [],
+    "shift": [],
+}
+
 MAP_METHODS = {
-    "put":      lambda m, args: f"({m}[{args[0]}] = {args[1]})",
-    "get":      lambda m, args: f"({m}.count({args[0]}) ? {m}[{args[0]}] : na<double>())",
-    "remove":   lambda m, args: f"[&](){{ auto it={m}.find({args[0]}); if(it!={m}.end()){{ auto v=it->second; {m}.erase(it); return v; }} return na<double>(); }}()",
-    "contains": lambda m, args: f"({m}.count({args[0]}) > 0)",
-    "size":     lambda m, args: f"(double){m}.size()",
+    "put":      lambda m, args: f"{m}.put({args[0]}, {args[1]})",
+    "get":      lambda m, args: f"{m}.get({args[0]})",
+    "remove":   lambda m, args: f"{m}.remove({args[0]})",
+    "contains": lambda m, args: f"{m}.contains({args[0]})",
+    "size":     lambda m, args: f"{m}.size()",
     "clear":    lambda m, args: f"{m}.clear()",
-    "keys":     lambda m, args: f"[&](){{ std::vector<std::string> v; for(auto& p:{m}) v.push_back(p.first); return v; }}()",
-    "values":   lambda m, args: f"[&](){{ std::vector<double> v; for(auto& p:{m}) v.push_back(p.second); return v; }}()",
-    "copy":     lambda m, args: f"std::unordered_map<std::string,double>({m})",
-    "put_all":  lambda m, args: f"{m}.insert({args[0]}.begin(), {args[0]}.end())",
+    "keys":     lambda m, args: f"{m}.keys()",
+    "values":   lambda m, args: f"{m}.values()",
+    "copy":     lambda m, args: f"{m}.copy()",
+    "put_all":  lambda m, args: f"{m}.put_all({args[0]})",
+}
+
+# Declared signature order after removing the method receiver ``id``.  This is
+# consumed by the typed-map UDF-parameter lane; established global/local and
+# namespace map lowerings intentionally retain their existing output.
+MAP_METHOD_KWARGS: dict[str, list[str]] = {
+    "put": ["key", "value"],
+    "get": ["key"],
+    "remove": ["key"],
+    "contains": ["key"],
+    "size": [],
+    "clear": [],
+    "keys": [],
+    "values": [],
+    "copy": [],
+    "put_all": ["id2"],
 }
 
 
@@ -566,6 +832,20 @@ MATRIX_METHOD_KWARGS: dict[str, list[str]] = {
     "add_col": ["col_index", "array_id"],
 }
 
+# Matrix mutators whose established C++ lowering returns ``void``.  A Pine
+# callable may use one as its terminal expression, but its generated numeric
+# fallback wrapper must emit the mutation as a statement and then return the
+# default value; ``return matrix.set(...)`` is invalid C++.
+#
+# ``remove_row`` / ``remove_col`` are intentionally absent: their lowering in
+# ``MATRIX_METHODS`` already wraps the runtime mutation in a lambda that returns
+# a numeric sentinel.  Matrix-returning transforms belong exclusively in
+# ``MATRIX_RETURNING_METHODS`` below.
+MATRIX_VOID_METHODS: frozenset[str] = frozenset({
+    "set", "fill", "add_row", "add_col", "swap_rows", "swap_columns",
+    "reshape", "reverse", "sort",
+})
+
 # matrix.* method names whose RUNTIME return type is ``PineMatrix``. Used by
 # the codegen aggregate-type registration to declare the LHS variable as
 # ``PineMatrix`` instead of the analyzer's default ``double``. Without this
@@ -683,6 +963,17 @@ def _math_minmax_na_expr(func_name: str, args: list[str]) -> str:
     )
 
 
+# Pine ``math.sign`` returns a float, propagates numeric ``na``, and must not
+# evaluate its argument more than once.  Keep the callable separate from the
+# call template because the stable-runtime TA reset fallback also substitutes
+# bare ``math.sign`` member text with this same C++ function expression.
+_MATH_SIGN_CPP_FN = (
+    "([](const auto _pf_sign_v) -> double { "
+    "return is_na(_pf_sign_v) ? na<double>() "
+    ": (double)((_pf_sign_v > 0) - (_pf_sign_v < 0)); })"
+)
+
+
 MATH_FUNC_MAP = {
     "abs": "std::abs", "max": "std::max", "min": "std::min",
     "ceil": "std::ceil", "floor": "std::floor", "round": "std::round",
@@ -691,7 +982,7 @@ MATH_FUNC_MAP = {
     "sin": "std::sin", "cos": "std::cos", "tan": "std::tan",
     "asin": "std::asin", "acos": "std::acos", "atan": "std::atan",
     "atan2": "std::atan2({0}, {1})",
-    "sign": "((({0}) > 0) - (({0}) < 0))",
+    "sign": _MATH_SIGN_CPP_FN,
     "avg": "(({0} + {1}) / 2.0)",
 }
 
@@ -743,46 +1034,3 @@ def _merge_kwargs(args: list, kwargs: dict, param_names: list | None, visit_expr
     while merged and merged[-1] is None:
         merged.pop()
     return [visit_expr(a) for a in merged if a is not None]
-
-
-def _merge_kwargs_with_defaults(
-    args: list,
-    kwargs: dict,
-    param_names: list,
-    param_defaults: list,
-    visit_expr,
-) -> list:
-    """Like ``_merge_kwargs`` but fills missing slots from ``param_defaults``.
-
-    ``param_defaults`` must be parallel to ``param_names`` (use ``None`` for
-    parameters without a default). Used by the UDT-method call lowering so
-    callers may invoke ``cfg.threshold()``, ``cfg.threshold(atrVal)``, or
-    ``cfg.threshold(mult=2.0, base=rsiVal)`` against ``method threshold(Cfg
-    self, float mult = 1.0, float base = 0.0) =>`` and have clang see the
-    full positional argument list. PineScript has no overloading, so every
-    parameter must be filled at the call site.
-
-    Probe: data/validation/udt-method-probe-04-default-param.
-
-    The result preserves the parameter order from ``param_names`` and
-    contains ``visit_expr(node)`` for each filled slot. Trailing slots that
-    have neither a caller-supplied value nor a default are dropped (matches
-    ``_merge_kwargs`` behaviour for required-only signatures).
-    """
-    n = len(param_names)
-    slots: list = [None] * n
-    for i, a in enumerate(args):
-        if i < n:
-            slots[i] = a
-    for k, v in kwargs.items():
-        if k in param_names:
-            slots[param_names.index(k)] = v
-    # Fill remaining holes from defaults (only where the caller omitted the
-    # slot AND the parameter has a declared default).
-    if param_defaults:
-        for i in range(n):
-            if slots[i] is None and i < len(param_defaults) and param_defaults[i] is not None:
-                slots[i] = param_defaults[i]
-    while slots and slots[-1] is None:
-        slots.pop()
-    return [visit_expr(a) for a in slots if a is not None]