@pineforge/codegen-pyodide 0.7.6 → 0.8.1

package/pineforge_codegen/codegen/types.py

@@ -41,13 +41,33 @@ from ..ast_nodes import (
 from ..symbols import PineType, TypeSpec
 from .. import signatures as sigs
 from .tables import (
+    ARRAY_DRAWING_NEW_CTORS,
     ARRAY_METHODS,
     BAR_BUILTINS,
     BAR_FIELDS,
+    DRAWING_NS,
+    DRAWING_TYPE_TO_CPP,
     PINE_TYPE_TO_CPP,
     TA_RETURNS_BOOL,
 )
 
+# Collection (array / map / matrix) methods that MUTATE the receiver in place.
+# Used by the BUG-2 collection-lvalue-alias path to decide whether a local
+# bound to an existing collection lvalue must alias (mutated) or may value-copy
+# (read-only). A method missing here only costs the alias optimization; a
+# non-mutating method accidentally present would alias a read-only local, which
+# is still correct (reads through a reference equal reads through a copy).
+COLLECTION_MUTATING_METHODS = frozenset({
+    # array
+    "push", "unshift", "insert", "remove", "pop", "shift", "clear",
+    "set", "fill", "sort", "reverse", "concat",
+    # map
+    "put", "put_all",
+    # matrix
+    "add_row", "add_col", "remove_row", "remove_col", "reshape",
+    "swap_rows", "swap_columns",
+})
+
 
 class TypeInferer:
     """Type-spec / C++-type inference helpers shared across visitor mixins.
@@ -100,6 +120,12 @@ class TypeInferer:
                 return TypeSpec.map(key, val)
         if name in self._udt_defs:
             return TypeSpec.udt(name)
+        # Drawing-objects-as-data (spec §4.1 / P3): scalar ``line``/``box``/
+        # ``label``/``linefill``/``chart.point`` hints carry the handle identity
+        # via a udt TypeSpec. (``array<line>`` already resolves via the array
+        # fallback above.) Drawing names are NOT in _udt_defs.
+        if name in DRAWING_TYPE_TO_CPP:
+            return TypeSpec.udt(name)
         return None
 
     def _type_spec_to_cpp(self, spec: TypeSpec | None) -> str:
@@ -110,6 +136,11 @@ class TypeInferer:
             return {"float": "double", "int": "int", "bool": "bool",
                     "string": "std::string", "color": "int"}.get(spec.name or "float", "double")
         if spec.kind == "udt" and spec.name:
+            # Drawing handle structs (P1): map BEFORE the _udt_defs check so
+            # array<line> -> std::vector<Line> and scalar line -> Line instead
+            # of the old collapse to double / unknown-type-name.
+            if spec.name in DRAWING_TYPE_TO_CPP:
+                return DRAWING_TYPE_TO_CPP[spec.name]
             return spec.name if spec.name in self._udt_defs else "double"
         if spec.kind == "array":
             return f"std::vector<{self._type_spec_to_cpp(spec.element)}>"
@@ -143,6 +174,10 @@ class TypeInferer:
         UDTs would otherwise fall through to ``0`` which is type-incompatible.
         """
         if spec is not None and spec.kind == "udt" and spec.name:
+            # Drawing handle default (P2): brace-init the C++ struct name
+            # (Line{} = na handle), NOT the lowercase Pine name (line{}).
+            if spec.name in DRAWING_TYPE_TO_CPP:
+                return f"{DRAWING_TYPE_TO_CPP[spec.name]}{{}}"
             return f"{spec.name}{{}}"
         cpp_type = self._type_spec_to_cpp(spec)
         if cpp_type.startswith("std::vector") or cpp_type.startswith("std::unordered_map"):
@@ -179,6 +214,12 @@ class TypeInferer:
                 return self._collection_types[node.name]
             if node.name in self._udt_var_types:
                 return TypeSpec.udt(self._udt_var_types[node.name])
+            # Drawing-typed method/function parameter (L.6d / U.5): a ``line ln``
+            # method receiver registers in _udt_param_udt so its body getters
+            # resolve to the drawing udt and dispatch through the §4.3 path.
+            _pu = getattr(self, "_udt_param_udt", None)
+            if _pu and node.name in _pu and _pu[node.name] in DRAWING_TYPE_TO_CPP:
+                return TypeSpec.udt(_pu[node.name])
             sym = self.ctx.symbols.resolve(node.name)
             if sym is not None and getattr(sym, "type_spec", None) is not None:
                 return sym.type_spec
@@ -190,12 +231,27 @@ class TypeInferer:
             return None
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
+            # ticker.* constructors (inherit/standard/heikinashi) return a symbol
+            # string; without this the member-type inference defaults to double
+            # and a ``haTicker = ticker.heikinashi(...)`` global mis-declares as
+            # double then assigns a std::string. (Analyzer agrees: ticker.* -> STRING.)
+            if namespace == "ticker":
+                return TypeSpec.primitive("string")
             targs = self._template_args_from_call(node)
+            # Drawing-objects-as-data return typing (spec §4.5 DRAWING_RETURN_SPECS):
+            # *.new / *.copy -> handle of the self-type; linefill.get_line* -> line.
+            if namespace in DRAWING_NS:
+                if func_name in ("new", "copy"):
+                    return TypeSpec.udt(namespace)
+                if namespace == "linefill" and func_name in ("get_line1", "get_line2"):
+                    return TypeSpec.udt("line")
+            if self._is_chart_point_callee(node.callee):
+                return TypeSpec.udt("chart.point")
             if namespace == "str" and func_name == "split":
                 return TypeSpec.array(TypeSpec.primitive("string"))
             if namespace == "array" and func_name in (
                 "new", "new_float", "new_int", "new_bool", "new_string", "from",
-            ):
+            ) or (namespace == "array" and func_name in ARRAY_DRAWING_NEW_CTORS):
                 if func_name == "new_int":
                     return TypeSpec.array(TypeSpec.primitive("int"))
                 if func_name == "new_bool":
@@ -204,6 +260,10 @@ class TypeInferer:
                     return TypeSpec.array(TypeSpec.primitive("string"))
                 if func_name == "new_float":
                     return TypeSpec.array(TypeSpec.primitive("float"))
+                if func_name in ARRAY_DRAWING_NEW_CTORS:
+                    # array.new_line()/new_box()/new_label()/new_linefill() ->
+                    # std::vector<Line/Box/Label/Linefill> (typed alias of new<T>).
+                    return TypeSpec.array(TypeSpec.udt(ARRAY_DRAWING_NEW_CTORS[func_name]))
                 if targs:
                     return TypeSpec.array(self._type_spec_from_hint_name(targs[0]) or TypeSpec.udt(targs[0]))
                 if func_name == "from" and node.args:
@@ -249,6 +309,14 @@ class TypeInferer:
                         return recv_spec.element
                     if func_name == "eigenvalues":
                         return TypeSpec.array(TypeSpec.primitive("float"))
+                # Drawing method-form: ``a.copy()`` -> same handle type;
+                # ``lf.get_line1()`` -> line. (L-N6 alias-vs-copy typing.)
+                if (recv_spec is not None and recv_spec.kind == "udt"
+                        and recv_spec.name in DRAWING_TYPE_TO_CPP):
+                    if func_name == "copy":
+                        return recv_spec
+                    if recv_spec.name == "linefill" and func_name in ("get_line1", "get_line2"):
+                        return TypeSpec.udt("line")
         return None
 
     # ------------------------------------------------------------------
@@ -345,6 +413,22 @@ class TypeInferer:
             if node.type_hint in self._udt_defs:
                 return node.type_hint
             return PINE_TYPE_TO_CPP.get(node.type_hint, "double")
+        # Drawing handle local (L-N6): a hintless local whose RHS resolves to a
+        # drawing udt must declare as the handle struct, not the analyzer's
+        # scalar default. Covers ``ln = arr.get(i)``, alias ``b = a``, field read
+        # ``lvl.ln``, and ``c = a.copy()``. Also records _udt_var_types so later
+        # uses (``ln.set_x2(...)`` / ``ln.slope()``) resolve to the drawing udt.
+        if getattr(self, "_uses_drawing", False):
+            rhs_spec = self._type_spec_from_expr(node.value)
+            if (rhs_spec is not None and rhs_spec.kind == "udt"
+                    and rhs_spec.name in DRAWING_TYPE_TO_CPP):
+                self._udt_var_types.setdefault(node.name, rhs_spec.name)
+                return DRAWING_TYPE_TO_CPP[rhs_spec.name]
+            # Scalar drawing getter local (get_text -> std::string, etc.).
+            if isinstance(node.value, FuncCall):
+                _dret = self._drawing_call_return_cpp(node.value)
+                if _dret is not None:
+                    return _dret
         sym = self.ctx.symbols.resolve(node.name)
         if sym is not None:
             inferred = self._infer_type(node.value)
@@ -357,32 +441,285 @@ class TypeInferer:
 
     def _series_type_for(self, name: str) -> str:
         """C++ element type for a series variable's history buffer."""
-        if self._is_int64_builtin_init(name):
+        from .tables import INT64_BUILTINS
+        # A bare int64 bar builtin used as a history series (``time[1]``) needs an
+        # int64_t buffer: epoch-ms overflow int32 and the na sentinel would be
+        # misdetected. ``_is_int64_builtin_init`` only matches user vars whose
+        # init RHS is such a builtin, so also match the builtin name directly.
+        if name in INT64_BUILTINS or self._is_int64_builtin_init(name):
             return "int64_t"
         sym = self.ctx.symbols.resolve(name)
         if sym is not None:
             return PINE_TYPE_TO_CPP.get(sym.pine_type, "double")
         return "double"
 
+    def _expr_is_int64_builtin(self, expr) -> bool:
+        """True if ``expr`` is a top-level int64-returning Pine builtin: either a
+        call to one of ``INT64_BUILTINS`` (``time(...)``, ``timestamp(...)``, …)
+        or a bare ``Identifier`` spelled like ``time`` / ``time_close`` /
+        ``timenow`` (which Pine exposes as a value, not a call)."""
+        from .tables import INT64_BUILTINS, INT64_BUILTIN_IDENTIFIERS
+        if expr is None:
+            return False
+        if isinstance(expr, FuncCall):
+            func_name, namespace = self._resolve_callee(expr.callee)
+            return namespace is None and func_name in INT64_BUILTINS
+        if isinstance(expr, Identifier):
+            return expr.name in INT64_BUILTIN_IDENTIFIERS
+        return False
+
+    def _int64_reassign_targets(self) -> set[str]:
+        """Names of vars that are reassigned (``:=``/``=``) anywhere in the AST
+        with an RHS that is a top-level int64-returning builtin. Cached on the
+        instance. Pine ``int`` collapses these to 32-bit, but the runtime stores
+        the epoch in 64 bits, so the member must be promoted to ``int64_t``."""
+        cached = getattr(self, "_int64_reassign_cache", None)
+        if cached is not None:
+            return cached
+        from ..ast_nodes import Assignment
+        targets: set[str] = set()
+        ast = getattr(self.ctx, "ast", None)
+        if ast is not None:
+            for node in self._walk_ast(ast):
+                if (isinstance(node, Assignment)
+                        and isinstance(node.target, Identifier)
+                        and self._expr_is_int64_builtin(node.value)):
+                    targets.add(node.target.name)
+        self._int64_reassign_cache = targets
+        return targets
+
     def _is_int64_builtin_init(self, name: str) -> bool:
-        """True if ``name``'s defining expression is a top-level call to a
-        Pine builtin that returns ``int64_t`` (``time``, ``time_close``,
-        ``timestamp``). The Pine type system collapses these to ``int``
-        but the engine encodes the ``na`` sentinel in the upper 32 bits,
-        so storing into ``Series<int>`` would silently corrupt na detection.
+        """True if ``name``'s initializer OR any ``:=``/``=`` reassignment has an
+        RHS that is a top-level int64-returning builtin (``time``, ``time_close``,
+        ``timenow``, ``timestamp``, ``time_tradingday``). The Pine type system
+        collapses these to ``int`` but the engine encodes the ``na`` sentinel
+        (and the full epoch-ms value, which overflows int32) in 64 bits, so
+        storing into ``int`` silently corrupts both the value and na detection.
+        A reassignment like ``var int entryTime = na`` then ``entryTime := time``
+        must promote even though the *initializer* alone is ``na``.
         """
-        from .tables import INT64_BUILTINS
         expr = (
             self.ctx.global_expr_map.get(name)
             or self.ctx.var_member_init_exprs.get(name)
         )
-        if expr is None:
+        if self._expr_is_int64_builtin(expr):
+            return True
+        return name in self._int64_reassign_targets()
+
+    # ------------------------------------------------------------------
+    # BUG C: user-defined-UDT lvalue aliasing
+    # ------------------------------------------------------------------
+
+    def _is_udt_lvalue(self, expr) -> str | None:
+        """If ``expr`` is a *user-defined* UDT lvalue (a bare ``Identifier`` that
+        names a class-scope ``var``/global UDT member, e.g. ``wyckoffSwingLow``),
+        return its UDT type name; else ``None``.
+
+        Pine UDTs are reference types, so a local initialised from such an lvalue
+        and then mutated through must write back to the global. Drawing UDTs are
+        handled by the separate ``_uses_drawing`` path and are excluded here."""
+        if not isinstance(expr, Identifier):
+            return None
+        udt_t = self._udt_var_types.get(expr.name)
+        if udt_t is None or udt_t not in self._udt_defs:
+            return None
+        if udt_t in DRAWING_TYPE_TO_CPP:
+            return None
+        # Must be a known global/class-scope member (not a function param or a
+        # plain local snapshot) for write-through to be observable.
+        if expr.name in getattr(self, "_current_func_locals", set()):
+            # A function-local of UDT type that is itself a persistent ``var``
+            # member still write-through aliases; but a plain inline local does
+            # not represent shared state. Only treat ``var`` func-locals (in
+            # func_var_members) as aliasable shared state.
+            fname = getattr(self, "_active_func_name", None)
+            var_locals = {n for n, _, _ in self.ctx.func_var_members.get(fname, [])} if fname else set()
+            if expr.name not in var_locals:
+                return None
+        return udt_t
+
+    def _udt_lvalue_selection_type(self, expr) -> str | None:
+        """UDT type if ``expr`` is a UDT lvalue OR a ternary/switch whose every
+        selectable branch is a UDT lvalue of the SAME user-defined UDT type.
+        Returns ``None`` otherwise (so plain ``UDT a = b`` value-snapshots, calls,
+        ``.new(...)`` ctors, and mixed/non-lvalue selections never alias)."""
+        direct = self._is_udt_lvalue(expr)
+        if direct is not None:
+            return direct
+        branches: list = []
+        if isinstance(expr, Ternary):
+            branches = [expr.true_val, expr.false_val]
+        elif isinstance(expr, SwitchStmt):
+            for _case_expr, stmts in (expr.cases or []):
+                if not stmts:
+                    return None
+                last = stmts[-1]
+                branches.append(last.expr if isinstance(last, ExprStmt) else last)
+            if expr.default_body:
+                last = expr.default_body[-1]
+                branches.append(last.expr if isinstance(last, ExprStmt) else last)
+        else:
+            return None
+        if not branches:
+            return None
+        types = {self._is_udt_lvalue(b) for b in branches}
+        if len(types) == 1 and None not in types:
+            return next(iter(types))
+        return None
+
+    def _udt_local_alias_kind(self, node: VarDecl) -> tuple[str, str] | None:
+        """Decide whether a hintless/typed local UDT declaration must ALIAS the
+        global(s) it selects rather than value-copy (BUG C).
+
+        Returns ``("ref", udt_type)`` for a non-rebinding reference alias,
+        ``("ptr", udt_type)`` for a pointer alias (the local is later reassigned
+        to a *different* UDT lvalue, which a C++ reference cannot do), or
+        ``None`` to keep the existing value-copy semantics.
+
+        Conditions (all required):
+          * RHS is a UDT lvalue or a ternary/switch selecting same-typed UDT
+            lvalues (``_udt_lvalue_selection_type``).
+          * The local is MUTATED later in the enclosing function body
+            (``local.field := ...``) — a pure read-only snapshot needn't alias.
+
+        The mutation requirement is the safety guard: a local that is only read
+        keeps value semantics, and a local initialised from a non-lvalue (a
+        ``.new()`` ctor, a function return, or a plain local copy) returns
+        ``None`` here, preserving intentional independent-copy semantics."""
+        from ..ast_nodes import Assignment
+        body = getattr(self, "_current_func_body", None)
+        if body is None:
+            return None
+        udt_t = self._udt_lvalue_selection_type(node.value)
+        if udt_t is None:
+            return None
+        name = node.name
+        mutated = False
+        rebinds_to_other_lvalue = False
+        for stmt in self._walk_ast_list(body):
+            if not isinstance(stmt, Assignment):
+                continue
+            tgt = stmt.target
+            # Mutation through the local: ``p.field := ...``
+            if (isinstance(tgt, MemberAccess)
+                    and isinstance(tgt.object, Identifier)
+                    and tgt.object.name == name):
+                mutated = True
+            # Rebind of the local itself to another UDT lvalue: ``p := other``
+            elif isinstance(tgt, Identifier) and tgt.name == name:
+                if self._udt_lvalue_selection_type(stmt.value) is not None:
+                    rebinds_to_other_lvalue = True
+                else:
+                    # Reassigned to a non-lvalue (e.g. ``.new()`` / a copy):
+                    # aliasing would be wrong; bail to value-copy.
+                    return None
+        if not mutated:
+            return None
+        return ("ptr" if rebinds_to_other_lvalue else "ref"), udt_t
+
+    # ------------------------------------------------------------------
+    # BUG 2: collection (array / map / matrix) lvalue aliasing
+    # ------------------------------------------------------------------
+
+    def _collection_lvalue_spec(self, expr):
+        """If ``expr`` is a bare ``Identifier`` naming an array/map/matrix
+        var/global member, return its ``TypeSpec``; else ``None``. Pine
+        collections are reference types, so a local bound to such an lvalue and
+        then mutated through must ALIAS it, not value-copy."""
+        if not isinstance(expr, Identifier):
+            return None
+        name = expr.name
+        if name in self._matrix_specs:
+            return self._matrix_specs[name]
+        spec = self._collection_types.get(name)
+        if spec is not None and spec.kind in ("array", "map", "matrix"):
+            return spec
+        if name in self._array_vars:
+            return self._array_spec_for_name(name)
+        if name in self._map_vars:
+            return self._map_spec_for_name(name)
+        return None
+
+    def _collection_lvalue_selection_spec(self, expr):
+        """``TypeSpec`` if ``expr`` is a collection lvalue OR a ternary/switch
+        whose every selectable branch is a collection lvalue of the SAME C++
+        type; ``None`` otherwise (so ``array.new(...)`` ctors, copies, function
+        returns, and mixed selections keep value-copy semantics). Mirrors
+        ``_udt_lvalue_selection_type`` for the BUG-2 collection-alias path."""
+        direct = self._collection_lvalue_spec(expr)
+        if direct is not None:
+            return direct
+        branches: list = []
+        if isinstance(expr, Ternary):
+            branches = [expr.true_val, expr.false_val]
+        elif isinstance(expr, SwitchStmt):
+            for _case_expr, stmts in (expr.cases or []):
+                if not stmts:
+                    return None
+                last = stmts[-1]
+                branches.append(last.expr if isinstance(last, ExprStmt) else last)
+            if expr.default_body:
+                last = expr.default_body[-1]
+                branches.append(last.expr if isinstance(last, ExprStmt) else last)
+        else:
+            return None
+        if not branches:
+            return None
+        specs = [self._collection_lvalue_spec(b) for b in branches]
+        if any(s is None for s in specs):
+            return None
+        cpp_types = {self._type_spec_to_cpp(s) for s in specs}
+        if len(cpp_types) == 1:
+            return specs[0]
+        return None
+
+    def _collection_local_must_alias(self, node) -> bool:
+        """True when the local ``node`` declares an alias of an existing
+        collection lvalue that is later MUTATED in the enclosing function body
+        (``local.push/unshift/insert/remove/set/clear/pop/...``). A purely-read
+        local needn't alias; a local REASSIGNED to a different value can't be a
+        C++ reference, so it bails to value-copy (returns ``False``)."""
+        from ..ast_nodes import Assignment
+        body = getattr(self, "_current_func_body", None)
+        if body is None:
             return False
-        if isinstance(expr, FuncCall):
-            func_name, namespace = self._resolve_callee(expr.callee)
-            if namespace is None and func_name in INT64_BUILTINS:
-                return True
-        return False
+        name = node.name
+        mutated = False
+        for stmt in self._walk_ast_list(body):
+            # Rebind of the local itself (``orderBlocks := other``) — a C++
+            # reference cannot rebind, so keep value-copy semantics.
+            if (isinstance(stmt, Assignment)
+                    and isinstance(stmt.target, Identifier)
+                    and stmt.target.name == name):
+                return False
+            if (isinstance(stmt, FuncCall)
+                    and isinstance(stmt.callee, MemberAccess)
+                    and isinstance(stmt.callee.object, Identifier)
+                    and stmt.callee.object.name == name
+                    and stmt.callee.member in COLLECTION_MUTATING_METHODS):
+                mutated = True
+        return mutated
+
+    def _walk_ast_list(self, stmts):
+        """Yield every node within a list of statements (depth-first)."""
+        for s in stmts:
+            yield from self._walk_ast(s)
+
+    def _addr_of_udt_selection(self, expr, local_name: str):
+        """Render the address-of form of a UDT lvalue selection for a pointer
+        alias (BUG C rebind case): ``other`` -> ``&(other)``;
+        ``cond ? a : b`` -> ``(cond ? &(a) : &(b))``. The selectable branches are
+        guaranteed (by ``_udt_lvalue_selection_type``) to be UDT lvalues."""
+        if isinstance(expr, Identifier):
+            return f"&({self._safe_name(expr.name)})"
+        if isinstance(expr, Ternary):
+            cond = self._visit_expr(expr.condition)
+            t = self._addr_of_udt_selection(expr.true_val, local_name)
+            f = self._addr_of_udt_selection(expr.false_val, local_name)
+            return f"({cond} ? {t} : {f})"
+        # Switch selection: lower to nested ternaries over case equality. Rare in
+        # practice; fall back to address-of the whole lowered expression.
+        return f"&({self._visit_expr(expr)})"
 
     def _infer_cpp_type_for_security_elem(self, node) -> str:
         """C++ type for one element of the ``request.security(..., expr, ...)`` payload.
@@ -462,6 +799,12 @@ class TypeInferer:
             return "double"
         if isinstance(node, FuncCall):
             func_name, namespace = self._resolve_callee(node.callee)
+            # Drawing scalar getter return type (get_text -> std::string,
+            # get_x* -> int64_t, get_y*/get_price/get_top/get_bottom -> double).
+            if getattr(self, "_uses_drawing", False):
+                _dret = self._drawing_call_return_cpp(node)
+                if _dret is not None:
+                    return _dret
             if func_name in ("time", "time_close") and namespace is None and node.args:
                 return "int64_t"
             if func_name == "timestamp" and namespace is None:
@@ -473,12 +816,23 @@ class TypeInferer:
                     return "std::string"
                 if func_name == "bool":
                     return "bool"
-                if func_name in ("int", "color", "time"):
+                if func_name == "int":
                     return "int"
+                # ``input.time`` returns an epoch-MS timestamp and ``input.color``
+                # a packed ARGB int — both use the ``get_input_int64`` getter
+                # (input.py), so their storage must be ``int64_t`` or the value
+                # truncates under int32 (e.g. a date-window bound flips sign and
+                # the guard is permanently false).
+                if func_name in ("color", "time"):
+                    return "int64_t"
                 return "double"
             if namespace == "str":
                 if func_name == "split":
                     return "std::vector<std::string>"
+                if func_name == "tonumber":
+                    return "double"
+                if func_name == "length":
+                    return "int"
                 return "std::string"
             if namespace == "ta" and func_name == "pivot_point_levels":
                 return "std::vector<double>"
@@ -563,16 +917,24 @@ class TypeInferer:
     def _infer_tuple_types(self, func_node: FuncDef, count: int) -> list[str]:
         """Infer the C++ type of each element returned by a tuple-returning function.
 
-        Builds a lightweight local-type map from the function's
-        ``VarDecl``s so identifiers referenced inside the final
-        ``[a, b, c]`` literal resolve precisely; falls back to
-        ``_infer_type`` when no local declaration matches."""
+        Builds a lightweight local-type map from the function's ``VarDecl``s
+        (including ones nested inside if/for/switch blocks) so identifiers
+        referenced inside the final ``[a, b, c]`` literal resolve precisely.
+        An explicit type hint wins (``string tag = na`` -> ``std::string``,
+        not the ``double`` implied by ``na``); otherwise the initializer
+        expression is inferred. Falls back to ``_infer_type`` when no local
+        declaration matches."""
         if not func_node.body:
             return ["double"] * count
 
         local_types: dict[str, str] = {}
-        for stmt in func_node.body:
-            if isinstance(stmt, VarDecl) and stmt.value is not None:
+        for stmt in self._walk_ast(func_node):
+            if isinstance(stmt, VarDecl) and stmt.value is not None and stmt.name:
+                if stmt.type_hint:
+                    spec = self._type_spec_from_hint_name(stmt.type_hint)
+                    if spec is not None:
+                        local_types[stmt.name] = self._type_spec_to_cpp(spec)
+                        continue
                 local_types[stmt.name] = self._infer_type(stmt.value)
 
         last_stmt = func_node.body[-1]