@pineforge/codegen-pyodide 0.8.0 → 0.8.1

package/pineforge_codegen/analyzer/call_handlers.py

@@ -66,8 +66,8 @@ from __future__ import annotations
 from typing import Any
 
 from ..ast_nodes import (
-    ASTNode, BoolLiteral, FuncCall, Identifier, MemberAccess,
-    NumberLiteral, StringLiteral, TupleLiteral,
+    ASTNode, BinOp, BoolLiteral, ExprStmt, FuncCall, Identifier, MemberAccess,
+    NumberLiteral, StringLiteral, TupleLiteral, UnaryOp, VarDecl,
 )
 from ..symbols import PineType
 from .. import signatures as sigs
@@ -207,6 +207,7 @@ class CallHandlers:
                 is_static=is_static,
             )
             self._ta_call_sites.append(site)
+            self._ta_member_names.add(site.member_name)
             return PineType.FLOAT
 
         # Determine constructor args
@@ -249,9 +250,29 @@ class CallHandlers:
             is_static=is_static,
         )
         self._ta_call_sites.append(site)
+        self._ta_member_names.add(site.member_name)
 
         return PineType.FLOAT
 
+    def _security_symbol_is_heikinashi(self, node, _seen=None) -> bool:
+        """True when a request.security symbol is ``ticker.heikinashi(<chart
+        symbol>)`` — directly, or via a global alias (``haTicker =
+        ticker.heikinashi(syminfo.tickerid)``). Name-cycle-guarded. The
+        support_checker has already rejected the cross-symbol HA case, so any HA
+        reaching here is the chart's own symbol."""
+        if _seen is None:
+            _seen = set()
+        if (isinstance(node, FuncCall) and isinstance(node.callee, MemberAccess)
+                and isinstance(node.callee.object, Identifier)
+                and node.callee.object.name == "ticker"
+                and node.callee.member == "heikinashi"):
+            return True
+        if (isinstance(node, Identifier) and node.name in self._global_expr_map
+                and node.name not in _seen):
+            _seen.add(node.name)
+            return self._security_symbol_is_heikinashi(self._global_expr_map[node.name], _seen)
+        return False
+
     def _handle_request_call(self, func_name: str, node: FuncCall) -> PineType:
         """Handle request.* function calls."""
         if func_name == "security":
@@ -293,6 +314,15 @@ class CallHandlers:
             lookahead_node = all_args[4] if len(all_args) > 4 else None
 
             mutable_globals = tuple(sorted(self._collect_security_mutable_globals(expr_node)))
+            # Heikin-Ashi same-symbol read: request.security(ticker.heikinashi(
+            # syminfo.tickerid), ...) (directly or via a global alias). The engine
+            # applies the HA candle transform inside the security eval.
+            symbol_node = all_args[0] if all_args else None
+            heikinashi = self._security_symbol_is_heikinashi(symbol_node)
+            # Capture the user function (if any) whose body contains this call,
+            # so the codegen can resolve a parameter ``tf`` via the call sites.
+            scope_name = self._symbols.current_scope.name
+            containing_func = scope_name[5:] if scope_name.startswith("func_") else ""
             self._security_calls.append(SecurityCallInfo(
                 sec_id=sec_id,
                 timeframe=tf_node,
@@ -302,8 +332,10 @@ class CallHandlers:
                 gaps=gaps_node,
                 lookahead=lookahead_node,
                 ta_range=security_ta_range,
+                heikinashi=heikinashi,
                 depends_on_mutable_globals=bool(mutable_globals),
                 mutable_globals=mutable_globals,
+                containing_func=containing_func,
             ))
 
             return PineType.FLOAT
@@ -765,6 +797,57 @@ class CallHandlers:
     # User-defined function calls
     # ------------------------------------------------------------------
 
+    def _func_local_length_defs(self, func_def) -> dict[str, str]:
+        """Collect a user function's local scalar length-vars to their RHS
+        expression string, e.g. ``qqeCalc`` with ``wp = sf * 2 - 1`` returns
+        ``{"wp": "sf * 2 - 1"}``.
+
+        Only plain (non-``var``/``varip``) declarations whose RHS is a pure
+        arithmetic expression over identifiers/numbers (NumberLiteral, Identifier,
+        BinOp, UnaryOp, or a math.* FuncCall) qualify — these are the shapes that
+        can legitimately feed a TA constructor length. Series-valued locals (whose
+        RHS is a ta.* call, a subscript, a ternary, etc.) are skipped so we never
+        inline a price series into a ctor-length slot. Names reassigned with ``:=``
+        are also skipped (their value is not a stable compile-time length).
+        """
+        def _is_arith(n) -> bool:
+            if isinstance(n, (NumberLiteral, Identifier)):
+                return True
+            if isinstance(n, BinOp):
+                return _is_arith(n.left) and _is_arith(n.right)
+            if isinstance(n, UnaryOp):
+                return _is_arith(n.operand)
+            if isinstance(n, FuncCall):
+                # Allow math.* helpers (math.round/sqrt/...) over arith args.
+                callee = n.callee
+                if (isinstance(callee, MemberAccess)
+                        and isinstance(callee.object, Identifier)
+                        and callee.object.name == "math"):
+                    return all(_is_arith(a) for a in n.args)
+            return False
+
+        reassigned: set[str] = set()
+        def _scan_reassign(stmts):
+            from ..ast_nodes import Assignment
+            for s in stmts or []:
+                if isinstance(s, Assignment) and isinstance(s.target, Identifier):
+                    reassigned.add(s.target.name)
+                for attr in ("body", "else_body"):
+                    sub = getattr(s, attr, None)
+                    if isinstance(sub, list):
+                        _scan_reassign(sub)
+        _scan_reassign(func_def.body)
+
+        defs: dict[str, str] = {}
+        for stmt in func_def.body or []:
+            if (isinstance(stmt, VarDecl)
+                    and not stmt.is_var and not stmt.is_varip
+                    and stmt.name not in reassigned
+                    and stmt.value is not None
+                    and _is_arith(stmt.value)):
+                defs[stmt.name] = self._expr_to_str(stmt.value)
+        return defs
+
     def _handle_user_func_call(self, func_name: str, node: FuncCall) -> PineType:
         """Handle calls to user-defined functions."""
         func_def = self._func_defs[func_name]
@@ -783,14 +866,28 @@ class CallHandlers:
         # For now, use the cached return type from initial analysis
         return_type = self._func_return_types.get(func_name, PineType.FLOAT)
 
-        # If the return type was UNKNOWN or VOID, infer from param types
+        # If the return type was UNKNOWN or VOID, infer it ONLY when the body
+        # is a single bare identifier that returns a parameter directly
+        # (``f(s) => s``). Inferring from params for arbitrary bodies misfires
+        # when a function merely HAS a string param but returns something else
+        # (e.g. ``getLineStyle(s) => switch s ... => line.style_solid`` or a
+        # body ending in ``label.new(...)``). Other cases rely on the cached
+        # body type plus udt_return_type / tuple inference.
         if return_type in (PineType.UNKNOWN, PineType.VOID):
-            if any(t == PineType.STRING for t in param_types):
-                return_type = PineType.STRING
-            elif any(t == PineType.FLOAT for t in param_types):
-                return_type = PineType.FLOAT
-            elif any(t == PineType.INT for t in param_types):
-                return_type = PineType.INT
+            if (func_def.is_single_expr and func_def.body
+                    and isinstance(func_def.body[0], ExprStmt)
+                    and isinstance(func_def.body[0].expr, Identifier)):
+                ret_name = func_def.body[0].expr.name
+                for idx, pname in enumerate(func_def.params):
+                    if pname == ret_name and idx < len(param_types):
+                        pt = param_types[idx]
+                        if pt == PineType.STRING:
+                            return_type = PineType.STRING
+                        elif pt == PineType.INT:
+                            return_type = PineType.INT
+                        elif pt == PineType.FLOAT:
+                            return_type = PineType.FLOAT
+                        break
 
         # If this function has series params, ensure bar-field arguments
         # passed at the call site are registered as series_bar_fields so that
@@ -824,6 +921,16 @@ class CallHandlers:
             if has_ta:
                 start, end = self._func_ta_ranges[func_name]
 
+                # Map of this function's local (non-param, non-series) derived
+                # length vars to their raw RHS expression strings, e.g.
+                # ``qqeCalc`` => ``wp = sf * 2 - 1`` -> {"wp": "sf * 2 - 1"}.
+                # A TA ctor arg captured as the bare local name ("wp") must be
+                # expanded to its definition so the subsequent param-substitution
+                # turns it into a class-scope expression ("rsiSmooth * 2 - 1")
+                # rather than leaving a dangling local that degenerates to
+                # period 1 in codegen.
+                local_defs = self._func_local_length_defs(func_def)
+
                 def _subst_params(arg: str, pmap: dict[str, str]) -> str:
                     """Substitute parameter names in an expression string.
 
@@ -837,23 +944,81 @@ class CallHandlers:
                         result = re.sub(rf'\b{re.escape(param)}\b', value, result)
                     return result
 
+                def _expand_locals(arg: str) -> str:
+                    """Recursively expand function-local length vars to their RHS
+                    (parenthesized) so only params / class-scope names remain."""
+                    import re
+                    if not local_defs:
+                        return arg
+                    for _ in range(32):
+                        def _rep(m: re.Match) -> str:
+                            nm = m.group(0)
+                            if nm in local_defs:
+                                return "(" + local_defs[nm] + ")"
+                            return nm
+                        new = re.sub(r"[A-Za-z_][A-Za-z_0-9]*", _rep, arg)
+                        if new == arg:
+                            break
+                        arg = new
+                    return arg
+
+                # Params of the function we are *currently inside* (if this is a
+                # nested user-func call). Used to detect when a substituted ctor
+                # arg becomes parameterized by the OUTER function, so the outer
+                # call site can resolve it (f_bbwp's _bbwLen -> i_bbwLen reaches
+                # f_basisMa's sites).
+                import re as _re
+                enclosing_params: set[str] = set()
+                for s in self._enclosing_func_params:
+                    enclosing_params |= s
+
                 if cs_idx == 0:
                     # First call site: save original param-based ctor_args for future cloning,
                     # then resolve to actual call-site values
                     for i in range(start, end):
                         site = self._ta_call_sites[i]
                         if not hasattr(site, '_orig_ctor_args'):
-                            site._orig_ctor_args = site.ctor_args[:]
+                            site._orig_ctor_args = [
+                                _expand_locals(a) for a in site.ctor_args
+                            ]
                         site.ctor_args = [_subst_params(a, param_arg_map) for a in site._orig_ctor_args]
+                        # If a substituted arg is now expressed in terms of an
+                        # enclosing function's params, promote it to the original
+                        # so the enclosing call re-substitutes, and mark the site
+                        # so the enclosing function's TA range widens to cover it.
+                        if enclosing_params and self._nested_ta_touched is not None:
+                            for a in site.ctor_args:
+                                toks = set(_re.findall(r"[A-Za-z_][A-Za-z_0-9]*", a))
+                                if toks & enclosing_params:
+                                    site._orig_ctor_args = list(site.ctor_args)
+                                    self._nested_ta_touched.add(i)
+                                    break
                 else:
                     # Subsequent call sites: clone using saved original param names,
                     # substituted with this call site's arguments
+                    clone_name_map: dict[str, str] = {}
                     for i in range(start, end):
                         orig = self._ta_call_sites[i]
                         orig_args = getattr(orig, '_orig_ctor_args', orig.ctor_args)
                         resolved_ctor = [_subst_params(a, param_arg_map) for a in orig_args]
+                        # Default name follows the ``{base}_cs{cs_idx}`` formula the
+                        # codegen re-derives. But the SAME base TA site can be reached
+                        # through more than one enclosing function (e.g. a helper cloned
+                        # both via its own call sites AND via a range-widened outer
+                        # function), so two distinct (func, cs_idx) namespaces can mint
+                        # the same name. Detect that collision and fall back to a
+                        # globally-unique name; record the chosen name so the codegen
+                        # consumes it verbatim (see _func_cs_ta_clone_names).
+                        clone_name = f"{orig.member_name}_cs{cs_idx}"
+                        if clone_name in self._ta_member_names:
+                            base = clone_name
+                            n = 2
+                            while clone_name in self._ta_member_names:
+                                clone_name = f"{base}_u{n}"
+                                n += 1
+                            clone_name_map[orig.member_name] = clone_name
                         cloned = TACallSite(
-                            member_name=f"{orig.member_name}_cs{cs_idx}",
+                            member_name=clone_name,
                             class_name=orig.class_name,
                             ctor_args=resolved_ctor,
                             compute_args=orig.compute_args[:],
@@ -862,6 +1027,9 @@ class CallHandlers:
                             is_static=orig.is_static,
                         )
                         self._ta_call_sites.append(cloned)
+                        self._ta_member_names.add(clone_name)
+                    if clone_name_map:
+                        self._func_cs_ta_clone_names[(func_name, cs_idx)] = clone_name_map
 
         # Create or update FuncInfo
         is_tuple = self._func_returns_tuple.get(func_name, False)
@@ -869,6 +1037,15 @@ class CallHandlers:
         # Forward UDT-return inference (set in _visit_FuncDef) so codegen can
         # emit the struct return type. Probe: udt-method-probe-20.
         udt_ret = self._func_udt_return_types.get(func_name)
+        ret_spec = getattr(self, "_func_return_type_specs", {}).get(func_name)
+        # Per-param TypeSpec: declared hints are authoritative; for untyped
+        # params, infer from the call-site argument's type_spec (so an untyped
+        # ``s`` used as a string, or a UDT passed by value, emits correctly).
+        param_specs = self._param_type_specs_from_def(func_def)
+        arg_specs = [self._type_spec_from_expr(arg) for arg in node.args]
+        for i in range(len(param_specs)):
+            if param_specs[i] is None and i < len(arg_specs):
+                param_specs[i] = arg_specs[i]
         existing = [fi for fi in self._func_infos if fi.name == func_name]
         if not existing:
             fi = FuncInfo(
@@ -879,6 +1056,8 @@ class CallHandlers:
                 returns_tuple=is_tuple,
                 tuple_element_count=tuple_count,
                 udt_return_type=udt_ret,
+                param_type_specs=param_specs,
+                return_type_spec=ret_spec,
             )
             self._func_infos.append(fi)
         else:
@@ -889,7 +1068,17 @@ class CallHandlers:
             for i, pt in enumerate(param_types):
                 if i < len(fi.param_types) and fi.param_types[i] == PineType.UNKNOWN:
                     fi.param_types[i] = pt
+            # Merge per-param TypeSpecs: keep declared hints (authoritative),
+            # fill untyped slots from this call site if still unknown.
+            if not fi.param_type_specs:
+                fi.param_type_specs = list(param_specs)
+            else:
+                for i in range(len(param_specs)):
+                    if i < len(fi.param_type_specs) and fi.param_type_specs[i] is None:
+                        fi.param_type_specs[i] = param_specs[i]
             if fi.udt_return_type is None and udt_ret is not None:
                 fi.udt_return_type = udt_ret
+            if fi.return_type_spec is None and ret_spec is not None:
+                fi.return_type_spec = ret_spec
 
         return return_type

package/pineforge_codegen/analyzer/contracts.py

@@ -65,6 +65,21 @@ class FuncInfo:
     # ``Sample s = build_sample(...)`` then ``s.score()`` dispatches
     # correctly. Probe: data/validation/udt-method-probe-20-udt-return-from-func.
     udt_return_type: str | None = None
+    # Parallel to ``node.params``; each entry is a ``TypeSpec`` (or ``None``)
+    # carrying UDT / drawing-handle / precise-scalar typing that the coarse
+    # ``param_types`` (PineType) cannot represent. Populated from the
+    # function's declared parameter type hints (authoritative) and, for
+    # untyped params, from the call-site argument type. The codegen prefers
+    # this over ``param_types`` when emitting each parameter's C++ type so a
+    # ``pivot hi`` parameter emits as ``pivot hi`` (not ``double hi``) and an
+    # untyped ``s`` used as a string emits as ``std::string s``.
+    param_type_specs: list = field(default_factory=list)
+    # ``TypeSpec`` of the function's return value when it is a collection the
+    # coarse ``return_type`` (PineType) cannot represent — today this covers
+    # array-returning functions (``buildPDLevels() => array.from(...)`` ->
+    # ``std::vector<double>``). UDT / drawing-handle returns use
+    # ``udt_return_type``; tuple returns use ``returns_tuple``.
+    return_type_spec: Any = None
 
 
 @dataclass
@@ -104,9 +119,33 @@ class SecurityCallInfo:
     gaps: Any = None
     lookahead: Any = None
     ta_range: Any = None
+    # request.security(ticker.heikinashi(syminfo.tickerid), ...) — the chart's own
+    # symbol read as Heikin-Ashi candles. The engine applies the HA OHLC transform
+    # to each (aggregated) bar before evaluating the security expression; the
+    # expression's close/open/high/low therefore see HA values. Same-symbol only.
+    heikinashi: bool = False
     depends_on_mutable_globals: bool = False
     mutable_globals: tuple[str, ...] = ()
     is_lower_tf_array: bool = False
+    # Name of the user function whose body contains this call ("" at global
+    # scope). A ``request.security(sym, tf, ...)`` whose ``tf`` is that
+    # function's parameter cannot be resolved at class scope (the security
+    # evaluator is a class method, not the function body) — the codegen resolves
+    # such a param-tf from the function's call sites instead.
+    containing_func: str = ""
+    # Set when this SecurityCallInfo is one of N per-call-site CLONES of a
+    # single source request.security(...) whose ``timeframe`` is a UDF
+    # parameter called from >= 2 sites with >= 2 distinct literal timeframes
+    # (e.g. ``scoreFromRange(tf) => request.security(sym, tf, ...)`` called as
+    # ``scoreFromRange("15")``, ``scoreFromRange("240")``, ...). Each clone's
+    # ``timeframe`` is rewritten to a literal StringLiteral for its call site
+    # and gets its own unique ``sec_id``; ``callsite_idx`` is the SAME index
+    # ``func_call_cs_map`` assigns that call site for the existing per-
+    # call-site UDF-body-cloning mechanism, so the codegen can pick the right
+    # clone's ``sec_id`` while emitting that call site's specialized function
+    # body (``self._active_call_site_idx``). None for an ordinary
+    # (non-cloned) security call.
+    callsite_idx: int | None = None
 
 
 @dataclass
@@ -135,6 +174,21 @@ class AnalyzerContext:
     func_ta_ranges: dict = field(default_factory=dict)    # func_name -> (start_idx, end_idx)
     func_call_cs_map: dict = field(default_factory=dict)  # call_node_id -> (func_name, call_site_index)
     func_call_site_counts: dict = field(default_factory=dict)  # func_name -> int
+    # Functions that need per-call-site body cloning PURELY because they
+    # contain a request.security(...) whose timeframe is a UDF parameter
+    # called with >= 2 distinct literal timeframes (the security-tf-
+    # monomorphization case), even though they have no TA call sites or
+    # series/var members of their own (the usual trigger for cloning). The
+    # codegen's function-emission gate ORs this in alongside has_ta/
+    # has_series so self._active_call_site_idx is actually set while it
+    # emits each call site's body — required for the per-clone
+    # SecurityCallInfo.callsite_idx disambiguation in visit_call.py to work.
+    func_security_clone_only: set = field(default_factory=set)
+    # (func_name, cs_idx) -> {orig_member_name: cloned_member_name}. Populated by
+    # the analyzer ONLY for clones whose default ``{base}_cs{cs_idx}`` name would
+    # collide with a clone minted through another enclosing function; lets codegen
+    # use the disambiguated name instead of re-deriving a colliding one.
+    func_cs_ta_clone_names: dict = field(default_factory=dict)
     # UDT / enum definitions:
     udt_defs: dict = field(default_factory=dict)          # type_name -> {field_name: PineType}
     enum_defs: dict = field(default_factory=dict)         # enum_name -> [member names]
@@ -145,12 +199,20 @@ class AnalyzerContext:
     # Per-function var_members + series_vars (used when emitting per-function call-site variants):
     func_var_members: dict = field(default_factory=dict)
     func_series_vars: dict = field(default_factory=dict)
+    # Per-function array-return TypeSpec (see FuncInfo.return_type_spec).
+    func_return_type_specs: dict = field(default_factory=dict)
     # var_name -> UDT type name for variables instantiated via TypeName.new(...)
     udt_var_types: dict[str, str] = field(default_factory=dict)
     # var_name -> structured collection/UDT type metadata
     collection_types: dict[str, TypeSpec] = field(default_factory=dict)
     # UDT name -> field_name -> structured type metadata
     udt_field_type_specs: dict[str, dict[str, TypeSpec]] = field(default_factory=dict)
+    # id(block_node) -> {raw_var_name: scope_unique_member_name} for block-scoped
+    # ``var``/``varip`` declarations whose raw name collides with a same-named
+    # block var in a sibling scope. Codegen activates the rename via
+    # ``_active_var_remap`` while emitting that block's statements so reads/writes
+    # of the var resolve to the disambiguated member.
+    block_var_renames: dict[int, dict[str, str]] = field(default_factory=dict)
     # ``// @pf-trace name=expr`` pragmas in source order. Populated by
     # :func:`pineforge_codegen.pragmas.extract_pf_trace_pragmas` from
     # the original source text and attached after :class:`Analyzer`

package/pineforge_codegen/analyzer/types.py

@@ -45,6 +45,12 @@ from ..ast_nodes import (
 )
 from ..symbols import PineType, TypeSpec
 
+# Drawing-objects-as-data type names (spec §4.1). Defined locally — the
+# analyzer must not import from ``codegen`` (codegen imports analyzer, so the
+# reverse would be a cycle). Mirrors codegen.tables.DRAWING_TYPE_TO_CPP keys.
+_DRAWING_TYPE_NAMES = frozenset({"line", "box", "label", "linefill", "chart.point"})
+_DRAWING_NS = frozenset({"line", "box", "label", "linefill"})
+
 
 class TypeHelper:
     """Pine type-hint / expression inference.
@@ -100,8 +106,28 @@ class TypeHelper:
                 return TypeSpec.map(key, val)
         if hint in self._udt_fields:
             return TypeSpec.udt(hint)
+        # Drawing-objects-as-data (P3): scalar ``line``/``box``/``label``/
+        # ``linefill``/``chart.point`` carry the handle identity via a udt
+        # TypeSpec. Without this the analyzer field-spec filter (base.py ~847)
+        # erases a scalar drawing field, collapsing it to double. Drawing names
+        # are NOT in _udt_fields.
+        if hint in _DRAWING_TYPE_NAMES:
+            return TypeSpec.udt(hint)
         return None
 
+    def _param_type_specs_from_def(self, func_def) -> list:
+        """Per-parameter ``TypeSpec`` (or ``None``) from a function's DECLARED
+        parameter type hints — the authoritative source for typed params
+        (``pivot hi``, ``string tf``, ``line[] arr``). Untyped params are
+        ``None`` here so regular-function call-site inference can fill them.
+        """
+        hints = (getattr(func_def, "annotations", None) or {}).get("param_type_hints", [])
+        specs: list = []
+        for i in range(len(func_def.params)):
+            hint = hints[i] if i < len(hints) else None
+            specs.append(self._type_spec_from_hint(hint) if hint else None)
+        return specs
+
     def _template_args_from_call(self, node: FuncCall) -> list[str]:
         callee = node.callee
         ann = getattr(callee, "annotations", None) or {}
@@ -116,6 +142,17 @@ class TypeHelper:
             func = cal.member if isinstance(cal, MemberAccess) else None
             ns = cal.object.name if isinstance(cal, MemberAccess) and isinstance(cal.object, Identifier) else None
             targs = self._template_args_from_call(value)
+            # Drawing-objects-as-data return typing: *.new / *.copy -> handle of
+            # the self-type; linefill.get_line* -> line; chart.point.* -> point.
+            if ns in _DRAWING_NS:
+                if func in ("new", "copy"):
+                    return TypeSpec.udt(ns)
+                if ns == "linefill" and func in ("get_line1", "get_line2"):
+                    return TypeSpec.udt("line")
+            if (isinstance(cal, MemberAccess) and isinstance(cal.object, MemberAccess)
+                    and isinstance(cal.object.object, Identifier)
+                    and cal.object.object.name == "chart" and cal.object.member == "point"):
+                return TypeSpec.udt("chart.point")
             if ns == "array" and func in ("new", "new_float", "new_int", "new_bool", "new_string", "from"):
                 if func == "new_float":
                     return TypeSpec.array(TypeSpec.primitive("float"))
@@ -194,10 +231,26 @@ class TypeHelper:
                         return recv_spec.element
                     if func == "eigenvalues":
                         return TypeSpec.array(TypeSpec.primitive("float"))
+                # Drawing method-form: a.copy() -> same handle; lf.get_line*() -> line.
+                if (recv_spec is not None and recv_spec.kind == "udt"
+                        and recv_spec.name in _DRAWING_TYPE_NAMES):
+                    if func == "copy":
+                        return recv_spec
+                    if recv_spec.name == "linefill" and func in ("get_line1", "get_line2"):
+                        return TypeSpec.udt("line")
         if isinstance(value, Identifier):
             sym = self._symbols.resolve(value.name)
             if sym is not None and sym.type_spec is not None:
                 return sym.type_spec
+        if isinstance(value, FuncCall):
+            # User-function return spec (e.g. an array-returning
+            # ``buildPDLevels() => array.from(...)``), so a caller's
+            # ``allLevels = buildPDLevels()`` infers an array TypeSpec.
+            cal = value.callee
+            fname = cal.member if isinstance(cal, MemberAccess) else (
+                cal.name if isinstance(cal, Identifier) else None)
+            if fname and fname in getattr(self, "_func_return_type_specs", {}):
+                return self._func_return_type_specs[fname]
         if isinstance(value, MemberAccess):
             owner = self._type_spec_from_expr(value.object)
             if owner is not None and owner.kind == "udt" and owner.name:

package/pineforge_codegen/codegen/__init__.py

@@ -41,6 +41,8 @@ from .tables import (
     SYMINFO_MEMBER_MAP,
     COLOR_CONST_MAP,
     ARRAY_METHODS,
+    ARRAY_DRAWING_NEW_CTORS,
+    ARRAY_NEW_CTORS,
     MAP_METHODS,
     MATRIX_METHODS,
     MATRIX_METHOD_KWARGS,
@@ -69,6 +71,8 @@ __all__ = [
     "SYMINFO_MEMBER_MAP",
     "COLOR_CONST_MAP",
     "ARRAY_METHODS",
+    "ARRAY_DRAWING_NEW_CTORS",
+    "ARRAY_NEW_CTORS",
     "MAP_METHODS",
     "MATRIX_METHODS",
     "MATRIX_METHOD_KWARGS",