Barmaja-PyArduino 2.0.0__py3-none-any.whl

Barmaja_PyArduino/typesys.py

@@ -0,0 +1,917 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from enum import Enum
+
+from .errors import TypeCheckError, UnsupportedFeatureError
+from .flow import FlowAnalyzedModule
+from .symbols import ResolvedModule, Symbol, SymbolId, SymbolKind
+from .api_registry import CORE_FUNCTIONS, HARDWARE_CLASSES, SINGLETONS, SignatureSpec, matching_signatures
+
+
+class TypeKind(Enum):
+    UNKNOWN = "Unknown"
+    BOOL = "Bool"
+    INT = "Int"
+    FLOAT = "Float"
+    STRING = "String"
+    VOID = "Void"
+    TIME_U32 = "TimeU32"
+    HARDWARE = "Hardware"
+    FIXED_LIST = "FixedList"
+
+
+@dataclass(frozen=True)
+class BarmajaType:
+    kind: TypeKind
+    hardware_class: str | None = None
+    element_type: "BarmajaType | None" = None
+    length: int | None = None
+
+    @property
+    def display_name(self) -> str:
+        if self.kind == TypeKind.HARDWARE:
+            return f"Hardware[{self.hardware_class}]"
+        if self.kind == TypeKind.FIXED_LIST:
+            inner = self.element_type.display_name if self.element_type is not None else "?"
+            return f"FixedList[{inner},{self.length}]"
+        return self.kind.value
+
+    @property
+    def cpp_type(self) -> str:
+        mapping = {
+            TypeKind.BOOL: "bool",
+            TypeKind.INT: "int32_t",
+            TypeKind.FLOAT: "float",
+            TypeKind.STRING: "const char*",
+            TypeKind.VOID: "void",
+            TypeKind.TIME_U32: "uint32_t",
+        }
+        if self.kind == TypeKind.HARDWARE:
+            return self.hardware_class or "/*hardware*/"
+        if self.kind == TypeKind.FIXED_LIST:
+            if self.element_type is None or self.length is None:
+                raise ValueError("Incomplete FixedList type")
+            return f"{self.element_type.cpp_type}[{self.length}]"
+        if self.kind == TypeKind.UNKNOWN:
+            raise ValueError("Unknown type has no C++ representation")
+        return mapping[self.kind]
+
+
+UNKNOWN = BarmajaType(TypeKind.UNKNOWN)
+BOOL = BarmajaType(TypeKind.BOOL)
+INT = BarmajaType(TypeKind.INT)
+FLOAT = BarmajaType(TypeKind.FLOAT)
+STRING = BarmajaType(TypeKind.STRING)
+VOID = BarmajaType(TypeKind.VOID)
+TIME_U32 = BarmajaType(TypeKind.TIME_U32)
+
+
+def hardware_type(name: str) -> BarmajaType:
+    return BarmajaType(TypeKind.HARDWARE, name)
+
+
+def fixed_list_type(element_type: BarmajaType, length: int) -> BarmajaType:
+    return BarmajaType(TypeKind.FIXED_LIST, element_type=element_type, length=length)
+
+
+NUMERIC_KINDS = {TypeKind.INT, TypeKind.FLOAT}
+SCALAR_KINDS = {TypeKind.BOOL, TypeKind.INT, TypeKind.FLOAT, TypeKind.STRING, TypeKind.TIME_U32}
+
+
+@dataclass(frozen=True)
+class FunctionSignature:
+    name: str
+    symbol: Symbol
+    parameters: tuple[Symbol, ...]
+    parameter_types: tuple[BarmajaType, ...]
+    return_type: BarmajaType
+
+
+@dataclass(frozen=True)
+class TypedModule:
+    flow: FlowAnalyzedModule
+    symbol_types: dict[SymbolId, BarmajaType]
+    expression_types: dict[int, BarmajaType]
+    function_signatures: dict[str, FunctionSignature]
+
+    @property
+    def resolved(self) -> ResolvedModule:
+        return self.flow.resolved
+
+    def type_for_symbol(self, symbol: Symbol) -> BarmajaType:
+        return self.symbol_types[symbol.symbol_id]
+
+    def type_for_expr(self, node: ast.AST) -> BarmajaType:
+        return self.expression_types[id(node)]
+
+    def signature_for(self, name: str) -> FunctionSignature:
+        return self.function_signatures[name]
+
+
+class TypeAnalyzer:
+    """Step-7 fixed-point scalar/function type inference.
+
+    This phase owns language types. The backend receives resolved Barmaja
+    types and must not infer C++ storage types from AST spelling/shape.
+    Numeric overflow/range proofs are intentionally Step 8.
+    """
+
+    def __init__(self, flow: FlowAnalyzedModule) -> None:
+        self.flow = flow
+        self.resolved = flow.resolved
+        self.frontend = self.resolved.frontend
+        self.symbol_types: dict[SymbolId, BarmajaType] = {}
+        self.expression_types: dict[int, BarmajaType] = {}
+        self._function_nodes: dict[str, ast.FunctionDef] = {
+            node.name: node for node in self.frontend.tree.body if isinstance(node, ast.FunctionDef)
+        }
+        self._param_symbols: dict[str, list[Symbol]] = {}
+        self._return_types: dict[str, BarmajaType] = {}
+        self._hardware_classes: dict[SymbolId, str] = {}
+        self._changed = False
+
+    def analyze(self) -> TypedModule:
+        self._reject_recursion()
+        self._seed_symbols()
+
+        # Calls and return expressions can constrain one another across source
+        # order. Iterate to a fixed point instead of using function order.
+        for _ in range(64):
+            self._changed = False
+            self.expression_types.clear()
+            self._scan_module()
+            if not self._changed:
+                break
+        else:
+            raise TypeCheckError("Function/type inference did not converge.")
+
+        # One strict pass after convergence rejects unresolved/invalid forms.
+        self.expression_types.clear()
+        self._scan_module(strict=True)
+        self._require_resolved_user_symbols()
+
+        signatures: dict[str, FunctionSignature] = {}
+        for name, fn in self._function_nodes.items():
+            fn_symbol = self.resolved.symbol_for_function(fn)
+            params = tuple(self._param_symbols[name])
+            signatures[name] = FunctionSignature(
+                name=name,
+                symbol=fn_symbol,
+                parameters=params,
+                parameter_types=tuple(self.symbol_types[p.symbol_id] for p in params),
+                return_type=self._return_types[name],
+            )
+
+        return TypedModule(
+            flow=self.flow,
+            symbol_types=dict(self.symbol_types),
+            expression_types=dict(self.expression_types),
+            function_signatures=signatures,
+        )
+
+    def _reject_recursion(self) -> None:
+        names = set(self._function_nodes)
+        graph: dict[str, set[str]] = {name: set() for name in names}
+        for name, fn in self._function_nodes.items():
+            for node in ast.walk(fn):
+                if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id in names:
+                    graph[name].add(node.func.id)
+
+        visiting: set[str] = set()
+        visited: set[str] = set()
+
+        def visit(name: str, path: list[str]) -> None:
+            if name in visiting:
+                start = path.index(name) if name in path else 0
+                cycle = path[start:] + [name]
+                fn = self._function_nodes[name]
+                raise UnsupportedFeatureError(
+                    "Recursive function calls are not supported on Arduino Uno in Barmaja PyArduino V1: "
+                    + " -> ".join(cycle),
+                    line=getattr(fn, "lineno", None),
+                )
+            if name in visited:
+                return
+            visiting.add(name)
+            path.append(name)
+            for other in sorted(graph[name]):
+                visit(other, path)
+            path.pop()
+            visiting.remove(name)
+            visited.add(name)
+
+        for name in sorted(graph):
+            visit(name, [])
+
+    def _seed_symbols(self) -> None:
+        # Every user data symbol starts unknown; functions are represented by
+        # signatures rather than scalar symbol values.
+        for symbol in self.resolved.module_scope.symbols.values():
+            if symbol.kind in {SymbolKind.MODULE, SymbolKind.HARDWARE}:
+                self.symbol_types[symbol.symbol_id] = UNKNOWN
+        for name, scope in self.resolved.function_scopes.items():
+            params: list[Symbol] = []
+            for symbol in scope.symbols.values():
+                if symbol.kind in {SymbolKind.PARAMETER, SymbolKind.LOCAL}:
+                    self.symbol_types[symbol.symbol_id] = UNKNOWN
+                if symbol.kind == SymbolKind.PARAMETER:
+                    params.append(symbol)
+            # Preserve Python parameter order rather than dict assumptions.
+            fn = self._function_nodes[name]
+            ordered: list[Symbol] = []
+            for arg in fn.args.args:
+                ordered.append(self.resolved.symbol_for_parameter(arg))
+            self._param_symbols[name] = ordered
+            self._return_types[name] = VOID if not self.flow.function_facts[name].has_value_return else UNKNOWN
+
+        # Hardware object constructor assignments are a direct type source.
+        for stmt in self.frontend.tree.body:
+            if self._is_hardware_assignment(stmt):
+                target = stmt.targets[0]
+                sym = self.resolved.symbol_for_name(target)
+                cls = stmt.value.func.id
+                typ = hardware_type(cls)
+                self.symbol_types[sym.symbol_id] = typ
+                self._hardware_classes[sym.symbol_id] = cls
+
+    @staticmethod
+    def _is_hardware_assignment(node: ast.AST) -> bool:
+        return (
+            isinstance(node, ast.Assign)
+            and len(node.targets) == 1
+            and isinstance(node.targets[0], ast.Name)
+            and isinstance(node.value, ast.Call)
+            and isinstance(node.value.func, ast.Name)
+            and node.value.func.id in HARDWARE_CLASSES
+        )
+
+    def _scan_module(self, strict: bool = False) -> None:
+        for stmt in self.frontend.tree.body:
+            if isinstance(stmt, (ast.ImportFrom, ast.FunctionDef)):
+                continue
+            if self._is_hardware_assignment(stmt):
+                # Still type-check constructor arguments.
+                self._expr_type(stmt.value, strict=strict, value_required=True)
+                continue
+            if isinstance(stmt, ast.While) and isinstance(stmt.test, ast.Constant) and stmt.test.value is True:
+                self._scan_block(stmt.body, strict=strict, function_name=None)
+                continue
+            self._scan_stmt(stmt, strict=strict, function_name=None)
+
+        for name, fn in self._function_nodes.items():
+            self._scan_block(fn.body, strict=strict, function_name=name)
+
+    def _scan_block(self, body: list[ast.stmt], *, strict: bool, function_name: str | None) -> None:
+        for stmt in body:
+            self._scan_stmt(stmt, strict=strict, function_name=function_name)
+
+    def _scan_stmt(self, stmt: ast.stmt, *, strict: bool, function_name: str | None) -> None:
+        if isinstance(stmt, (ast.Pass, ast.Global)):
+            return
+        if isinstance(stmt, ast.Expr):
+            if isinstance(stmt.value, ast.Constant) and (stmt.value.value is Ellipsis or isinstance(stmt.value.value, str)):
+                return
+            self._expr_type(stmt.value, strict=strict, value_required=False)
+            return
+        if isinstance(stmt, ast.Assign):
+            # Supported tuple/list unpacking is pair-wise and fixed at compile
+            # time. Type each element directly instead of inventing a general
+            # Tuple runtime type.
+            if (
+                len(stmt.targets) == 1
+                and isinstance(stmt.targets[0], (ast.Tuple, ast.List))
+                and isinstance(stmt.value, (ast.Tuple, ast.List))
+            ):
+                for target, value in zip(stmt.targets[0].elts, stmt.value.elts):
+                    value_type = self._expr_type(value, strict=strict, value_required=True)
+                    self._assign_target(target, value_type, stmt, strict)
+                return
+            value_type = self._expr_type(stmt.value, strict=strict, value_required=True)
+            if value_type.kind == TypeKind.VOID:
+                raise self._error("A Void call cannot be assigned to a variable.", stmt.value)
+            if strict and value_type.kind == TypeKind.FIXED_LIST and not isinstance(stmt.value, ast.List):
+                # Python would make both names share ONE list object; a fixed Uno array
+                # cannot alias another array, so a copy would silently change behaviour.
+                raise self._error(
+                    "A list variable can only be given a list literal such as [1, 2, 3] in Barmaja PyArduino V1. "
+                    "Assigning one list to another name (sharing or copying a list) is not supported; "
+                    "copy the elements one by one instead.",
+                    stmt.value,
+                )
+            for target in stmt.targets:
+                if isinstance(target, ast.Subscript):
+                    list_type = self._expr_type(target.value, strict=strict, value_required=True)
+                    index_type = self._expr_type(target.slice, strict=strict, value_required=True)
+                    self._require_kind(index_type, {TypeKind.INT}, target.slice, "List index must be Int.", strict)
+                    if strict and list_type.kind != TypeKind.FIXED_LIST:
+                        raise self._error("Indexed assignment requires a fixed list.", target.value)
+                    if list_type.kind == TypeKind.FIXED_LIST and list_type.element_type is not None:
+                        joined = self._join(list_type.element_type, value_type, stmt.value, strict)
+                        if (
+                            strict
+                            and value_type.kind != TypeKind.UNKNOWN
+                            and joined != list_type.element_type
+                        ):
+                            # A fixed list keeps one element type. The only implicit
+                            # element conversion is the lossless Int -> Float store; a
+                            # Float value must never be silently truncated into an Int list.
+                            raise self._error(
+                                f"Cannot store a {value_type.display_name} value in a list of "
+                                f"{list_type.element_type.display_name} values; fixed lists keep one element type. "
+                                "Use int(...) or round(...) explicitly, or make the list hold Float values such as [1.0, 2.0].",
+                                stmt.value,
+                            )
+                        self._validate_static_index(target.slice, list_type.length or 0, strict)
+                    continue
+                self._assign_target(target, value_type, stmt, strict)
+            return
+        if isinstance(stmt, ast.AugAssign):
+            left = self._expr_type(stmt.target, strict=strict, value_required=True)
+            right = self._expr_type(stmt.value, strict=strict, value_required=True)
+            result = self._numeric_binop_type(left, right, stmt, division=isinstance(stmt.op, ast.Div), strict=strict)
+            sym = self.resolved.symbol_for_name(stmt.target)
+            self._merge_symbol(sym, result, stmt, strict)
+            return
+        if isinstance(stmt, ast.If):
+            cond = self._expr_type(stmt.test, strict=strict, value_required=True)
+            self._require_bool(cond, stmt.test, strict)
+            self._scan_block(stmt.body, strict=strict, function_name=function_name)
+            self._scan_block(stmt.orelse, strict=strict, function_name=function_name)
+            return
+        if isinstance(stmt, ast.While):
+            cond = self._expr_type(stmt.test, strict=strict, value_required=True)
+            self._require_bool(cond, stmt.test, strict)
+            self._scan_block(stmt.body, strict=strict, function_name=function_name)
+            return
+        if isinstance(stmt, ast.For):
+            iterator_type = self._expr_type(stmt.iter, strict=strict, value_required=False)
+            if isinstance(stmt.iter, ast.Call) and isinstance(stmt.iter.func, ast.Name) and stmt.iter.func.id == "range":
+                if isinstance(stmt.target, ast.Name):
+                    self._merge_symbol(self.resolved.symbol_for_name(stmt.target), INT, stmt.target, strict)
+                    self.expression_types[id(stmt.target)] = INT
+            elif isinstance(stmt.iter, ast.Call) and isinstance(stmt.iter.func, ast.Name) and stmt.iter.func.id == "enumerate":
+                if stmt.iter.args:
+                    list_type = self._expr_type(stmt.iter.args[0], strict=strict, value_required=True)
+                    if strict and list_type.kind != TypeKind.FIXED_LIST:
+                        raise self._error("enumerate() requires a fixed list.", stmt.iter.args[0])
+                    if len(stmt.iter.args) == 2:
+                        start_type = self._expr_type(stmt.iter.args[1], strict=strict, value_required=True)
+                        self._require_kind(start_type, {TypeKind.INT}, stmt.iter.args[1], "enumerate() start must be Int.", strict)
+                    if list_type.kind == TypeKind.FIXED_LIST and isinstance(stmt.target, (ast.Tuple, ast.List)) and len(stmt.target.elts) == 2:
+                        first, second = stmt.target.elts
+                        if isinstance(first, ast.Name):
+                            self._merge_symbol(self.resolved.symbol_for_name(first), INT, first, strict)
+                            self.expression_types[id(first)] = INT
+                        if isinstance(second, ast.Name) and list_type.element_type is not None:
+                            self._merge_symbol(self.resolved.symbol_for_name(second), list_type.element_type, second, strict)
+                            self.expression_types[id(second)] = list_type.element_type
+            else:
+                if strict and iterator_type.kind != TypeKind.FIXED_LIST:
+                    raise self._error("for iteration requires range() or a fixed list in V1.", stmt.iter)
+                if iterator_type.kind == TypeKind.FIXED_LIST and isinstance(stmt.target, ast.Name) and iterator_type.element_type is not None:
+                    self._merge_symbol(self.resolved.symbol_for_name(stmt.target), iterator_type.element_type, stmt.target, strict)
+                    self.expression_types[id(stmt.target)] = iterator_type.element_type
+            self._scan_block(stmt.body, strict=strict, function_name=function_name)
+            return
+        if isinstance(stmt, ast.Return):
+            if function_name is None:
+                return
+            typ = VOID if stmt.value is None else self._expr_type(stmt.value, strict=strict, value_required=True)
+            if typ.kind == TypeKind.VOID and stmt.value is not None:
+                raise self._error("A function cannot return a Void call as a value.", stmt.value)
+            self._merge_return(function_name, typ, stmt, strict)
+            return
+        if isinstance(stmt, (ast.Break, ast.Continue)):
+            return
+
+    def _assign_target(self, target: ast.AST, value_type: BarmajaType, owner: ast.AST, strict: bool) -> None:
+        if isinstance(target, ast.Name):
+            sym = self.resolved.symbol_for_name(target)
+            self._merge_symbol(sym, value_type, owner, strict)
+            self.expression_types[id(target)] = self.symbol_types[sym.symbol_id]
+            return
+        if isinstance(target, (ast.Tuple, ast.List)):
+            # The current closed frontend only reaches tuple/list unpacking for
+            # compile-time literal pairs. Keep pair typing exact.
+            if isinstance(owner, ast.Assign) and isinstance(owner.value, (ast.Tuple, ast.List)):
+                for t, v in zip(target.elts, owner.value.elts):
+                    self._assign_target(t, self._expr_type(v, strict=strict, value_required=True), owner, strict)
+                return
+            if strict:
+                raise self._error("This assignment target cannot be typed in V1.", target)
+
+    def _expr_type(self, node: ast.AST, *, strict: bool, value_required: bool) -> BarmajaType:
+        typ = self._expr_type_uncached(node, strict=strict, value_required=value_required)
+        self.expression_types[id(node)] = typ
+        if value_required and typ.kind == TypeKind.VOID:
+            raise self._error("A Void call cannot be used where a value is required.", node)
+        return typ
+
+    def _expr_type_uncached(self, node: ast.AST, *, strict: bool, value_required: bool) -> BarmajaType:
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, bool):
+                return BOOL
+            if isinstance(node.value, int):
+                return INT
+            if isinstance(node.value, float):
+                return FLOAT
+            if isinstance(node.value, str):
+                return STRING
+            if node.value is Ellipsis:
+                return VOID
+
+        if isinstance(node, ast.Name):
+            sym = self.resolved.symbol_for_name(node)
+            if sym.kind == SymbolKind.API:
+                if node.id in {"HIGH", "LOW", "INPUT", "OUTPUT", "INPUT_PULLUP", "A0", "A1", "A2", "A3", "A4", "A5", "DHT11", "DHT22", "CM", "INC"}:
+                    return INT
+                if strict:
+                    raise self._error(f"API name '{node.id}' is not a value.", node)
+                return UNKNOWN
+            if sym.kind == SymbolKind.BUILTIN:
+                if strict:
+                    raise self._error(f"Builtin '{node.id}' must be called, not used as a value.", node)
+                return UNKNOWN
+            if sym.kind == SymbolKind.FUNCTION:
+                if strict:
+                    raise self._error("Function objects are not first-class values in V1.", node)
+                return UNKNOWN
+            typ = self.symbol_types.get(sym.symbol_id, UNKNOWN)
+            if strict and typ.kind == TypeKind.UNKNOWN:
+                raise self._error(f"Could not infer a type for '{sym.name}'.", node)
+            return typ
+
+        if isinstance(node, ast.List):
+            if not node.elts:
+                if strict:
+                    raise self._error("Empty fixed lists are not supported in V1.", node)
+                return UNKNOWN
+            element = UNKNOWN
+            for item in node.elts:
+                item_type = self._expr_type(item, strict=strict, value_required=True)
+                if item_type.kind in {TypeKind.VOID, TypeKind.HARDWARE, TypeKind.FIXED_LIST, TypeKind.TIME_U32}:
+                    if strict:
+                        raise self._error("Fixed-list elements must be Bool, Int, Float, or String values.", item)
+                    return UNKNOWN
+                element = self._join(element, item_type, item, strict)
+            return fixed_list_type(element, len(node.elts)) if element.kind != TypeKind.UNKNOWN else UNKNOWN
+
+        if isinstance(node, ast.Subscript):
+            container = self._expr_type(node.value, strict=strict, value_required=True)
+            index = self._expr_type(node.slice, strict=strict, value_required=True)
+            self._require_kind(index, {TypeKind.INT}, node.slice, "List index must be Int.", strict)
+            if container.kind == TypeKind.FIXED_LIST and container.element_type is not None:
+                self._validate_static_index(node.slice, container.length or 0, strict)
+                return container.element_type
+            if strict:
+                raise self._error("Indexing is supported only on fixed lists in V1.", node.value)
+            return UNKNOWN
+
+        if isinstance(node, ast.JoinedStr):
+            for part in node.values:
+                if isinstance(part, ast.FormattedValue):
+                    inner = self._expr_type(part.value, strict=strict, value_required=True)
+                    if strict and inner.kind not in SCALAR_KINDS:
+                        raise self._error("f-string values must be supported scalar values.", part.value)
+            return STRING
+
+        if isinstance(node, ast.UnaryOp):
+            operand = self._expr_type(node.operand, strict=strict, value_required=True)
+            if isinstance(node.op, ast.Not):
+                self._require_bool(operand, node.operand, strict)
+                return BOOL
+            if isinstance(node.op, ast.USub):
+                self._require_kind(operand, NUMERIC_KINDS, node.operand, "Unary '-' requires Int or Float.", strict)
+                return operand
+
+        if isinstance(node, ast.BinOp):
+            left = self._expr_type(node.left, strict=strict, value_required=True)
+            right = self._expr_type(node.right, strict=strict, value_required=True)
+            return self._numeric_binop_type(left, right, node, division=isinstance(node.op, ast.Div), strict=strict)
+
+        if isinstance(node, ast.BoolOp):
+            for value in node.values:
+                self._require_bool(self._expr_type(value, strict=strict, value_required=True), value, strict)
+            return BOOL
+
+        if isinstance(node, ast.Compare):
+            values = [node.left, *node.comparators]
+            types = [self._expr_type(x, strict=strict, value_required=True) for x in values]
+            if strict and all(t.kind != TypeKind.UNKNOWN for t in types):
+                for op, a, b in zip(node.ops, types, types[1:]):
+                    if not self._comparison_compatible(a, b):
+                        raise self._error(f"Cannot compare {a.display_name} with {b.display_name}.", node)
+                    # V1 intentionally supports String/Bool equality only; do
+                    # not silently inherit C++ pointer ordering or bool-as-int.
+                    if (a.kind == TypeKind.STRING or b.kind == TypeKind.STRING) and not isinstance(op, (ast.Eq, ast.NotEq)):
+                        raise self._error("String ordering comparisons are not supported in Barmaja PyArduino V1.", node)
+                    if a.kind == TypeKind.BOOL and b.kind == TypeKind.BOOL and not isinstance(op, (ast.Eq, ast.NotEq)):
+                        raise self._error("Bool ordering comparisons are not supported in Barmaja PyArduino V1.", node)
+            return BOOL
+
+        if isinstance(node, ast.IfExp):
+            self._require_bool(self._expr_type(node.test, strict=strict, value_required=True), node.test, strict)
+            a = self._expr_type(node.body, strict=strict, value_required=True)
+            b = self._expr_type(node.orelse, strict=strict, value_required=True)
+            return self._join(a, b, node, strict)
+
+        if isinstance(node, ast.Call):
+            return self._call_type(node, strict=strict)
+
+        if strict:
+            raise self._error(f"Expression '{type(node).__name__}' has no V1 type rule.", node)
+        return UNKNOWN
+
+    def _call_type(self, node: ast.Call, *, strict: bool) -> BarmajaType:
+        if isinstance(node.func, ast.Name):
+            name = node.func.id
+            args = [self._expr_type(arg, strict=strict, value_required=True) for arg in node.args]
+
+            if name in self._function_nodes:
+                params = self._param_symbols[name]
+                for param, arg_type, arg_node in zip(params, args, node.args):
+                    self._merge_symbol(param, arg_type, arg_node, strict)
+                return self._return_types[name]
+
+            if name in HARDWARE_CLASSES:
+                return self._registry_constructor_type(name, args, node.args, strict)
+            if name == "print":
+                for typ, arg in zip(args, node.args):
+                    if strict and typ.kind not in SCALAR_KINDS:
+                        raise self._error("print() accepts supported scalar values in V1.", arg)
+                return VOID
+            if name in CORE_FUNCTIONS:
+                return self._registry_function_type(name, args, node.args, strict)
+            if name in {"int", "float", "bool"}:
+                return self._conversion_type(name, args[0] if args else UNKNOWN, node, strict)
+            if name == "round":
+                if not args:
+                    return UNKNOWN
+                self._require_kind(args[0], NUMERIC_KINDS, node.args[0], "round() requires Int or Float.", strict)
+                if len(args) == 2:
+                    self._require_kind(args[1], {TypeKind.INT}, node.args[1], "round() ndigits must be Int.", strict)
+                    if strict:
+                        ndigits = self._literal_int(node.args[1])
+                        if ndigits is None or not (-6 <= ndigits <= 6):
+                            raise self._error("round() ndigits must be a compile-time Int from -6 to 6 in V1.", node.args[1])
+                    return args[0] if args[0].kind != TypeKind.UNKNOWN else UNKNOWN
+                return INT if args[0].kind == TypeKind.FLOAT else args[0]
+            if name == "abs":
+                self._require_kind(args[0], NUMERIC_KINDS, node.args[0], "abs() requires Int or Float.", strict)
+                return args[0]
+            if name in {"min", "max"}:
+                current = UNKNOWN
+                for typ, arg in zip(args, node.args):
+                    self._require_kind(typ, NUMERIC_KINDS, arg, f"{name}() requires numeric arguments.", strict)
+                    current = self._join(current, typ, node, strict)
+                return current
+            if name == "len":
+                if not args:
+                    return UNKNOWN
+                if strict and args[0].kind != TypeKind.FIXED_LIST:
+                    raise self._error("len() requires a fixed list in V1.", node.args[0])
+                return INT
+            if name == "sum":
+                if not args:
+                    return UNKNOWN
+                if strict and args[0].kind != TypeKind.FIXED_LIST:
+                    raise self._error("sum() requires a fixed list in V1.", node.args[0])
+                if args[0].kind == TypeKind.FIXED_LIST and args[0].element_type is not None:
+                    self._require_kind(args[0].element_type, NUMERIC_KINDS, node.args[0], "sum() requires an Int or Float fixed list.", strict)
+                    return args[0].element_type
+                return UNKNOWN
+            if name == "enumerate":
+                if args and strict and args[0].kind != TypeKind.FIXED_LIST:
+                    raise self._error("enumerate() requires a fixed list in V1.", node.args[0])
+                if len(args) == 2:
+                    self._require_kind(args[1], {TypeKind.INT}, node.args[1], "enumerate() start must be Int.", strict)
+                return VOID
+            if name == "range":
+                for typ, arg in zip(args, node.args):
+                    self._require_kind(typ, {TypeKind.INT}, arg, "range() values must be Int.", strict)
+                return VOID  # only valid as for-iterator, never a V1 value
+
+        if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name):
+            owner_node = node.func.value
+            owner_sym = self.resolved.symbol_for_name(owner_node)
+            args = [self._expr_type(arg, strict=strict, value_required=True) for arg in node.args]
+            if owner_node.id in SINGLETONS and owner_sym.kind == SymbolKind.API:
+                return self._registry_singleton_method_type(owner_node.id, node.func.attr, args, node.args, strict)
+
+            owner_type = self.symbol_types.get(owner_sym.symbol_id, UNKNOWN)
+            if owner_type.kind != TypeKind.HARDWARE:
+                if strict:
+                    raise self._error(f"'{owner_node.id}' is not a hardware object.", owner_node)
+                return UNKNOWN
+            return self._registry_hardware_method_type(owner_type.hardware_class or "", node.func.attr, args, node.args, strict)
+
+        if strict:
+            raise self._error("Unsupported call form for type analysis.", node)
+        return UNKNOWN
+
+    def _conversion_type(self, name: str, arg: BarmajaType, node: ast.AST, strict: bool) -> BarmajaType:
+        allowed = {TypeKind.BOOL, TypeKind.INT, TypeKind.FLOAT}
+        if name == "float":
+            # Explicit, non-narrowing conversion of millis() time, e.g. float(millis()) / 1000.
+            allowed = allowed | {TypeKind.TIME_U32}
+        message = "float() accepts Bool, Int, Float, or millis() time in V1." if name == "float" else f"{name}() accepts Bool, Int, or Float in V1."
+        self._require_kind(arg, allowed, node, message, strict)
+        return {"int": INT, "float": FLOAT, "bool": BOOL}[name]
+
+    def _registry_constructor_type(self, name: str, args: list[BarmajaType], nodes: list[ast.AST], strict: bool) -> BarmajaType:
+        spec = HARDWARE_CLASSES[name]
+        sig = self._validate_registry_call(f"{name}()", spec.constructors, args, nodes, strict)
+        return self._type_from_registry_token(sig.returns, name)
+
+    def _registry_function_type(self, name: str, args: list[BarmajaType], nodes: list[ast.AST], strict: bool) -> BarmajaType:
+        spec = CORE_FUNCTIONS[name]
+        sig = self._validate_registry_call(f"{name}()", spec.signatures, args, nodes, strict)
+        return self._type_from_registry_token(sig.returns)
+
+    def _registry_hardware_method_type(self, cls: str, method: str, args: list[BarmajaType], nodes: list[ast.AST], strict: bool) -> BarmajaType:
+        try:
+            spec = HARDWARE_CLASSES[cls].methods[method]
+        except KeyError:
+            if strict:
+                node = nodes[0] if nodes else self._function_nodes[next(iter(self._function_nodes))] if self._function_nodes else self.frontend.tree
+                raise self._error(f"{cls}.{method}() is not registered in Barmaja PyArduino V1.", node)
+            return UNKNOWN
+        sig = self._validate_registry_call(f"{cls}.{method}()", spec.signatures, args, nodes, strict)
+        return self._type_from_registry_token(sig.returns)
+
+    def _registry_singleton_method_type(self, owner: str, method: str, args: list[BarmajaType], nodes: list[ast.AST], strict: bool) -> BarmajaType:
+        try:
+            spec = SINGLETONS[owner].methods[method]
+        except KeyError:
+            if strict:
+                node = nodes[0] if nodes else self.frontend.tree
+                raise self._error(f"{owner}.{method}() is not registered in Barmaja PyArduino V1.", node)
+            return UNKNOWN
+        sig = self._validate_registry_call(f"{owner}.{method}()", spec.signatures, args, nodes, strict)
+        return self._type_from_registry_token(sig.returns)
+
+    def _validate_registry_call(
+        self,
+        label: str,
+        signatures: tuple[SignatureSpec, ...],
+        args: list[BarmajaType],
+        nodes: list[ast.AST],
+        strict: bool,
+    ) -> SignatureSpec:
+        candidates = matching_signatures(signatures, len(args))
+        if not candidates:
+            # Frontend owns arity diagnostics; retain a defensive type-phase guard.
+            node = nodes[0] if nodes else self.frontend.tree
+            if strict:
+                allowed = ", ".join(str(len(sig.args)) for sig in signatures)
+                raise self._error(f"{label} accepts registered argument counts: {allowed}.", node)
+            return signatures[0]
+        if not strict:
+            return candidates[0]
+        for sig in candidates:
+            if all(self._registry_token_accepts(token, typ, node, strict=False) for token, typ, node in zip(sig.args, args, nodes)):
+                # Strict pass gives specialized constant-token diagnostics.
+                for token, typ, node in zip(sig.args, args, nodes):
+                    self._registry_token_accepts(token, typ, node, strict=True)
+                return sig
+        expected = " or ".join("(" + ", ".join(sig.args) + ")" for sig in candidates)
+        actual = "(" + ", ".join(t.display_name for t in args) + ")"
+        node = nodes[0] if nodes else self.frontend.tree
+        raise self._error(f"{label} expects {expected}, not {actual}.", node)
+
+    def _registry_token_accepts(self, token: str, typ: BarmajaType, node: ast.AST, *, strict: bool) -> bool:
+        if typ.kind == TypeKind.UNKNOWN:
+            return not strict
+        allowed: set[TypeKind] | None = {
+            "Int": {TypeKind.INT},
+            "Bool": {TypeKind.BOOL},
+            "Float": {TypeKind.FLOAT},
+            "String": {TypeKind.STRING},
+            "IntOrBool": {TypeKind.INT, TypeKind.BOOL},
+            "Scalar": SCALAR_KINDS,
+            "NumericOrBool": {TypeKind.INT, TypeKind.FLOAT, TypeKind.BOOL},
+            "UltrasonicUnit": {TypeKind.INT},
+            "DHTType": {TypeKind.INT},
+        }.get(token)
+        if allowed is None:
+            return True
+        if typ.kind not in allowed:
+            return False
+        if token == "UltrasonicUnit":
+            ok = isinstance(node, ast.Name) and node.id in {"CM", "INC"}
+            if strict and not ok:
+                raise self._error("Ultrasonic.read() unit must be CM or INC.", node)
+            return ok
+        if token == "DHTType":
+            ok = isinstance(node, ast.Name) and node.id in {"DHT11", "DHT22"}
+            if strict and not ok:
+                raise self._error("DHT() sensor type must be DHT11 or DHT22.", node)
+            return ok
+        return True
+
+    @staticmethod
+    def _type_from_registry_token(token: str, hardware_class: str | None = None) -> BarmajaType:
+        mapping = {
+            "Void": VOID,
+            "Bool": BOOL,
+            "Int": INT,
+            "Float": FLOAT,
+            "String": STRING,
+            "TimeU32": TIME_U32,
+        }
+        if token.startswith("Hardware["):
+            name = token[len("Hardware["):-1]
+            return hardware_type(name)
+        return mapping.get(token, hardware_type(hardware_class) if hardware_class else UNKNOWN)
+
+    def _require_all_int(self, args: list[BarmajaType], nodes: list[ast.AST], label: str, strict: bool) -> None:
+        for typ, node in zip(args, nodes):
+            self._require_kind(typ, {TypeKind.INT}, node, f"{label} arguments must be Int.", strict)
+
+    def _numeric_binop_type(self, left: BarmajaType, right: BarmajaType, node: ast.AST, *, division: bool, strict: bool) -> BarmajaType:
+        # Arduino wrap-safe elapsed time: TimeU32 - TimeU32 remains TimeU32.
+        if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Sub) and left.kind == TypeKind.TIME_U32 and right.kind == TypeKind.TIME_U32:
+            return TIME_U32
+        # True division never narrows: millis() / 1000 is a Float number of seconds.
+        if (
+            division and isinstance(node, ast.BinOp)
+            and TypeKind.TIME_U32 in {left.kind, right.kind}
+            and {left.kind, right.kind} <= {TypeKind.TIME_U32, TypeKind.INT, TypeKind.FLOAT}
+        ):
+            return FLOAT
+        if left.kind == TypeKind.UNKNOWN or right.kind == TypeKind.UNKNOWN:
+            # If one side is a name and the other fixes the numeric family, use
+            # that as a constraint. A float counterpart widens the unknown.
+            known = right if left.kind == TypeKind.UNKNOWN else left
+            unknown_node = node.left if isinstance(node, ast.BinOp) and left.kind == TypeKind.UNKNOWN else (node.right if isinstance(node, ast.BinOp) else None)
+            if known.kind in NUMERIC_KINDS and isinstance(unknown_node, ast.Name):
+                sym = self.resolved.symbol_for_name(unknown_node)
+                self._merge_symbol(sym, known, unknown_node, strict=False)
+                left = self.symbol_types.get(sym.symbol_id, known) if unknown_node is getattr(node, "left", None) else left
+                right = self.symbol_types.get(sym.symbol_id, known) if unknown_node is getattr(node, "right", None) else right
+            if left.kind == TypeKind.UNKNOWN or right.kind == TypeKind.UNKNOWN:
+                return UNKNOWN
+        if left.kind not in NUMERIC_KINDS or right.kind not in NUMERIC_KINDS:
+            if strict:
+                raise self._error(f"Arithmetic requires Int/Float, not {left.display_name} and {right.display_name}.", node)
+            return UNKNOWN
+        if division:
+            return FLOAT
+        return FLOAT if TypeKind.FLOAT in {left.kind, right.kind} else INT
+
+    def _validate_static_index(self, node: ast.AST, length: int, strict: bool) -> None:
+        value = self._literal_int(node)
+        if value is None or not strict:
+            return
+        if value < 0:
+            raise self._error("Negative list indexing is not supported in Barmaja PyArduino V1.", node)
+        if value >= length:
+            raise self._error(f"List index {value} is out of range for fixed list of length {length}.", node)
+
+    @staticmethod
+    def _literal_int(node: ast.AST) -> int | None:
+        if isinstance(node, ast.Constant) and isinstance(node.value, int) and not isinstance(node.value, bool):
+            return int(node.value)
+        if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
+            value = TypeAnalyzer._literal_int(node.operand)
+            return -value if value is not None else None
+        return None
+
+    @staticmethod
+    def _comparison_compatible(a: BarmajaType, b: BarmajaType) -> bool:
+        if a.kind == b.kind:
+            return a.kind in SCALAR_KINDS
+        if a.kind in NUMERIC_KINDS and b.kind in NUMERIC_KINDS:
+            return True
+        if a.kind == TypeKind.TIME_U32 and b.kind == TypeKind.INT:
+            return True
+        if b.kind == TypeKind.TIME_U32 and a.kind == TypeKind.INT:
+            return True
+        return False
+
+    def _merge_symbol(self, symbol: Symbol, incoming: BarmajaType, node: ast.AST, strict: bool) -> None:
+        if incoming.kind in {TypeKind.UNKNOWN, TypeKind.VOID}:
+            if strict and incoming.kind == TypeKind.VOID:
+                raise self._error("Void cannot be stored in a variable.", node)
+            return
+        if incoming.kind == TypeKind.FIXED_LIST and symbol.kind == SymbolKind.PARAMETER:
+            # Python passes the list object itself (aliasing); a C++ array parameter
+            # is not expressible in the current backend, so reject it cleanly.
+            if strict:
+                raise self._error(
+                    f"Lists cannot be passed to functions in Barmaja PyArduino V1 (parameter '{symbol.name}'). "
+                    "Use the list's module-level name inside the function instead.",
+                    node,
+                )
+            return
+        if incoming.kind == TypeKind.HARDWARE:
+            # Hardware objects are created exactly once by their top-level constructor
+            # assignment (seeded directly, not merged).  Copying one into another
+            # variable/parameter would construct or copy a second C++ device object.
+            if strict:
+                raise self._error(
+                    f"'{symbol.name}' cannot hold a {incoming.hardware_class} object. Hardware objects cannot be copied, "
+                    "passed to functions, or assigned to other variables; use the original object name directly.",
+                    node,
+                )
+            return
+        current = self.symbol_types.get(symbol.symbol_id, UNKNOWN)
+        if (
+            symbol.kind != SymbolKind.PARAMETER
+            and {current.kind, incoming.kind} == {TypeKind.INT, TypeKind.TIME_U32}
+        ):
+            # Arduino timer idiom: `last = 0` ... `last = millis()`. The variable
+            # stores time; Int stores are checked non-negative by the backend.
+            joined = TIME_U32
+        else:
+            joined = self._join(current, incoming, node, strict)
+        if joined != current:
+            self.symbol_types[symbol.symbol_id] = joined
+            self._changed = True
+
+    def _merge_return(self, name: str, incoming: BarmajaType, node: ast.AST, strict: bool) -> None:
+        if incoming.kind == TypeKind.FIXED_LIST:
+            if strict:
+                raise self._error(
+                    f"Function '{name}' cannot return a list in Barmaja PyArduino V1. "
+                    "Change the module-level list inside the function (using its name) or return one element.",
+                    node,
+                )
+            return
+        if incoming.kind == TypeKind.HARDWARE:
+            if strict:
+                raise self._error(
+                    f"Function '{name}' cannot return a {incoming.hardware_class} object. Use the hardware object name directly.",
+                    node,
+                )
+            return
+        current = self._return_types[name]
+        if current.kind == TypeKind.VOID and incoming.kind != TypeKind.VOID:
+            current = UNKNOWN
+        joined = self._join(current, incoming, node, strict)
+        if joined != self._return_types[name]:
+            self._return_types[name] = joined
+            self._changed = True
+
+    def _join(self, a: BarmajaType, b: BarmajaType, node: ast.AST, strict: bool) -> BarmajaType:
+        if a.kind == TypeKind.UNKNOWN:
+            return b
+        if b.kind == TypeKind.UNKNOWN:
+            return a
+        if a == b:
+            return a
+        if a.kind in NUMERIC_KINDS and b.kind in NUMERIC_KINDS:
+            return FLOAT
+        if strict:
+            raise self._error(f"Incompatible types: {a.display_name} and {b.display_name}.", node)
+        # Do not hide an incompatible constraint during inference. The strict
+        # pass will report it at the source location.
+        return a
+
+    def _require_bool(self, typ: BarmajaType, node: ast.AST, strict: bool) -> None:
+        self._require_kind(typ, {TypeKind.BOOL}, node, "Condition/logical value must be Bool in Barmaja PyArduino V1.", strict)
+
+    def _require_kind(self, typ: BarmajaType, kinds: set[TypeKind], node: ast.AST, message: str, strict: bool) -> None:
+        if typ.kind == TypeKind.UNKNOWN and not strict:
+            return
+        if typ.kind not in kinds:
+            raise self._error(message, node)
+
+    def _require_resolved_user_symbols(self) -> None:
+        for symbol_id, typ in self.symbol_types.items():
+            if typ.kind == TypeKind.UNKNOWN:
+                symbol = self._symbol_by_id(symbol_id)
+                raise TypeCheckError(
+                    f"Could not infer a type for '{symbol.name}'.",
+                    line=symbol.declaration_line,
+                )
+        for name, typ in self._return_types.items():
+            if typ.kind == TypeKind.UNKNOWN:
+                fn = self._function_nodes[name]
+                raise self._error(f"Could not infer the return type of function '{name}'.", fn)
+
+    def _symbol_by_id(self, symbol_id: SymbolId) -> Symbol:
+        for symbol in self.resolved.module_scope.symbols.values():
+            if symbol.symbol_id == symbol_id:
+                return symbol
+        for scope in self.resolved.function_scopes.values():
+            for symbol in scope.symbols.values():
+                if symbol.symbol_id == symbol_id:
+                    return symbol
+        raise KeyError(symbol_id)
+
+    @staticmethod
+    def _error(message: str, node: ast.AST) -> TypeCheckError:
+        return TypeCheckError(
+            message,
+            line=getattr(node, "lineno", None),
+            column=(getattr(node, "col_offset", None) + 1) if getattr(node, "col_offset", None) is not None else None,
+            end_line=getattr(node, "end_lineno", None),
+            end_column=getattr(node, "end_col_offset", None),
+        )
+
+
+def analyze_types(flow: FlowAnalyzedModule) -> TypedModule:
+    return TypeAnalyzer(flow).analyze()