@pineforge/codegen-pyodide 0.9.0 → 0.10.1

package/pineforge_codegen/codegen/drawing.py

@@ -20,7 +20,15 @@ reads only attributes established by ``CodeGen.__init__`` (``_uses_drawing``,
 from __future__ import annotations
 
 from ..ast_nodes import FuncCall, Identifier, MemberAccess
-from .tables import DRAWING_TYPE_TO_CPP, DRAWING_ARENA, ARRAY_VOID_METHODS as _ARRAY_VOID_METHODS
+from ..symbols import method_receiver_type_name
+from .tables import (
+    ARRAY_VOID_METHODS as _ARRAY_VOID_METHODS,
+    DRAWING_ARENA,
+    DRAWING_TYPE_TO_CPP,
+    MATRIX_VOID_METHODS as _MATRIX_VOID_METHODS,
+)
+
+_MAP_VOID_METHODS = frozenset({"clear", "put_all"})
 
 # ---------------------------------------------------------------------------
 # Canonical Pine v6 constructor param-name lists (positional order).
@@ -478,26 +486,90 @@ class DrawingVisitor:
         expression and so cannot be used as a function's return value / RHS.
 
         Covers drawing setters/delete/visual-noop (delegated to
-        ``_drawing_call_is_void``) AND the Pine array MUTATOR methods whose C++
+        ``_drawing_call_is_void``), the Pine array MUTATOR methods whose C++
         lowering is void / an iterator (``array.push/insert/clear/set/fill/
-        sort/reverse/concat/unshift``) — a function ending in
-        ``array.clear(x)`` returns void in Pine, so it must emit as a statement
-        with a default return, not ``return x.clear();``.
+        sort/reverse/concat/unshift``), matrix mutators whose runtime lowering
+        returns void, and terminal map ``clear``/``put_all`` calls. A function
+        ending in one of these calls must emit it as a statement with a default
+        return, never ``return <void-expression>;``.
         """
-        if self._drawing_call_is_void(node):
-            return True
         if not isinstance(node, FuncCall) or not isinstance(node.callee, MemberAccess):
             return False
         method = node.callee.member
-        _fn, ns = self._resolve_callee(node.callee)
-        if method not in _ARRAY_VOID_METHODS:
+        direct_spec = self._type_spec_from_expr(node.callee.object)
+        direct_receiver_name = method_receiver_type_name(direct_spec)
+        direct_method_info = (
+            getattr(self, "_func_info_map", {}).get(
+                f"{direct_receiver_name}.{method}"
+            )
+            if direct_receiver_name is not None
+            else None
+        )
+        # Exact typed user methods have dispatch precedence over every builtin
+        # family. Resolve that once before drawing/array/matrix/map terminal
+        # classification, including when a parameter named after a namespace
+        # (for example ``array`` or ``label``) is the authored receiver.
+        if direct_method_info is not None and getattr(
+            direct_method_info, "is_udt_method", False
+        ):
             return False
-        # array.<method>(arr, ...) namespace form OR arr.<method>(...) method
-        # form on a std::vector receiver.
-        if ns == "array":
+
+        if self._drawing_call_is_void(node):
             return True
-        recv_spec = self._type_spec_from_expr(node.callee.object)
-        return recv_spec is not None and recv_spec.kind == "array"
+        _fn, ns = self._resolve_callee(node.callee)
+
+        if method in _MATRIX_VOID_METHODS:
+            # Resolve the exact matrix receiver for both established spellings:
+            # ``matrix.set(id, ...)`` and ``id.set(...)``.
+            functional_namespace = ns == "matrix" and (
+                direct_spec is None or direct_spec.kind != "matrix"
+            )
+            recv_spec = direct_spec
+            if functional_namespace:
+                recv_spec = (
+                    self._type_spec_from_expr(node.args[0])
+                    if node.args
+                    else None
+                )
+            if recv_spec is not None and recv_spec.kind == "matrix":
+                return True
+
+        if method in _ARRAY_VOID_METHODS:
+            # array.<method>(arr, ...) namespace form OR arr.<method>(...)
+            # method form on a std::vector receiver.
+            if ns == "array":
+                return True
+            if direct_spec is not None and direct_spec.kind == "array":
+                return True
+
+        if method not in _MAP_VOID_METHODS:
+            return False
+        # Preserve the unsupported arbitrary-map-receiver boundary. Namespace
+        # functional calls are established; method calls must use a named
+        # global/local/parameter receiver.
+        if ns == "map":
+            # The established namespace-functional form has a positional map
+            # receiver.  Keyword-only receiver routing remains unsupported
+            # and must retain its pre-KI-48g fallback output.
+            expected_arity = 1 if method == "clear" else 2
+            return len(node.args) == expected_arity and not node.kwargs
+        if not isinstance(node.callee.object, Identifier):
+            return False
+        name = node.callee.object.name
+        param_spec = getattr(self, "_current_func_param_specs", {}).get(name)
+        if method == "clear":
+            if node.args or node.kwargs:
+                return False
+        elif param_spec is not None and param_spec.kind == "map":
+            if not (
+                (len(node.args) == 1 and not node.kwargs)
+                or (not node.args and set(node.kwargs) == {"id2"})
+            ):
+                return False
+        elif len(node.args) != 1 or node.kwargs:
+            return False
+        recv_spec = param_spec or self._type_spec_from_expr(node.callee.object)
+        return recv_spec is not None and recv_spec.kind == "map"
 
     # ------------------------------------------------------------------
     # _uses_drawing detection + arena caps
@@ -527,6 +599,14 @@ class DrawingVisitor:
         for spec in self._collection_types.values():
             if self._spec_mentions_drawing(spec):
                 return True
+        for specs in self._func_collection_types.values():
+            for spec in specs.values():
+                if self._spec_mentions_drawing(spec):
+                    return True
+        for specs in self._block_collection_types.values():
+            for spec in specs.values():
+                if self._spec_mentions_drawing(spec):
+                    return True
         for fields in self._udt_field_type_specs.values():
             for spec in fields.values():
                 if self._spec_mentions_drawing(spec):