core.py

#!/usr/bin/env python3
import ast
import json
from typing import Dict, Optional, Tuple, List, Set

class TranspileError(Exception):
    def __init__(self, msg: str, node: Optional[ast.AST] = None):
        if node is not None and hasattr(node, 'lineno'):
            msg = f"line {node.lineno}: {msg}"
        super().__init__(msg)


# ----------------------------------------
# Exception mapping
# ----------------------------------------

CPP_RESERVED: Set[str] = {
    "auto", "break", "case", "char", "const", "continue", "default", "do",
    "double", "else", "enum", "extern", "float", "for", "goto", "if", "int",
    "long", "register", "return", "short", "signed", "sizeof", "static",
    "struct", "switch", "typedef", "union", "unsigned", "void", "volatile",
    "while", "class", "new", "delete", "virtual", "override", "final",
    "template", "typename", "namespace", "using", "public", "private",
    "protected", "friend", "operator", "bool", "true", "false", "catch",
    "throw", "try", "typeid", "mutable", "explicit", "export", "inline",
    "this", "and", "or", "not", "bitand", "bitor", "xor", "compl",
    "nullptr", "alignas", "alignof", "constexpr", "decltype", "noexcept",
    "static_assert", "thread_local", "wchar_t", "char16_t", "char32_t",
    "dynamic_cast", "static_cast", "reinterpret_cast", "const_cast",
    "concept", "requires", "co_await", "co_return", "co_yield",
}

EXCEPTION_MAP: Dict[str, str] = {
    "BaseException":       "std::exception",
    "Exception":           "std::runtime_error",
    "RuntimeError":        "std::runtime_error",
    "ValueError":          "std::invalid_argument",
    "TypeError":           "std::invalid_argument",
    "IndexError":          "std::out_of_range",
    "KeyError":            "std::out_of_range",
    "IOError":             "std::ios_base::failure",
    "OSError":             "std::ios_base::failure",
    "FileNotFoundError":   "std::ios_base::failure",
    "PermissionError":     "std::ios_base::failure",
    "NotImplementedError": "std::logic_error",
    "OverflowError":       "std::overflow_error",
    "ArithmeticError":     "std::overflow_error",
    "StopIteration":       "_StopIteration_",
    "AttributeError":      "std::runtime_error",
    "ImportError":         "std::runtime_error",
    "NameError":           "std::runtime_error",
    "AssertionError":      "std::runtime_error",
    "SystemExit":          "std::runtime_error",
    "UnicodeError":        "std::runtime_error",
    "UnicodeDecodeError":  "std::runtime_error",
    "UnicodeEncodeError":  "std::runtime_error",
}

# Base classes that are no-ops in C++ (transparent wrappers / abstract markers)
TRANSPARENT_BASES: Set[str] = {
    "object", "ABC", "ABCMeta", "Generic", "Protocol",
    "Enum", "IntEnum", "StrEnum", "Flag", "IntFlag",
    "NamedTuple",
}

# Base classes that mark a class as an Enum
ENUM_BASES: Set[str] = {"Enum", "IntEnum", "StrEnum", "Flag", "IntFlag"}

# Dunder methods → C++ names
DUNDER_CPP: Dict[str, str] = {
    "__len__":      "size",
    "__str__":      "to_string",
    "__repr__":     "to_string",
    "__eq__":       "operator==",
    "__ne__":       "operator!=",
    "__lt__":       "operator<",
    "__le__":       "operator<=",
    "__gt__":       "operator>",
    "__ge__":       "operator>=",
    "__add__":      "operator+",
    "__radd__":     "operator+",
    "__sub__":      "operator-",
    "__mul__":      "operator*",
    "__rmul__":     "operator*",
    "__truediv__":  "operator/",
    "__floordiv__": "operator/",
    "__mod__":      "operator%",
    "__neg__":      "operator-",
    "__pos__":      "operator+",
    "__iadd__":     "operator+=",
    "__isub__":     "operator-=",
    "__imul__":     "operator*=",
    "__itruediv__": "operator/=",
    "__bool__":     "operator bool",
    "__int__":      "operator int",
    "__float__":    "operator double",
    "__getitem__":  "operator[]",
    "__setitem__":  "set_item",
    "__contains__": "contains",
    "__hash__":     "_hash_",
    "__iter__":     "_iter_",
    "__next__":     "_next_",
}

# Conversion operators: explicit operator TYPE() — no return type prefix
CONVERSION_DUNDERS: Set[str] = {"__bool__", "__int__", "__float__"}

INPLACE_DUNDERS: Set[str] = {
    "__iadd__", "__isub__", "__imul__", "__itruediv__",
    "__ifloordiv__", "__imod__", "__setitem__",
    "__iter__", "__next__",
}

AST_OP_DUNDER: Dict[type, str] = {
    ast.Add: "__add__", ast.Sub: "__sub__", ast.Mult: "__mul__",
    ast.Div: "__truediv__", ast.FloorDiv: "__floordiv__", ast.Mod: "__mod__",
}

AST_OP_SYMBOL: Dict[type, str] = {
    ast.Add: "+", ast.Sub: "-", ast.Mult: "*",
    ast.Div: "/", ast.FloorDiv: "/", ast.Mod: "%",
}


# ----------------------------------------
# Type system
# ----------------------------------------

def split_type_args(s: str) -> List[str]:
    parts: List[str] = []
    depth = 0
    current: List[str] = []
    for ch in s:
        if ch == "[":
            depth += 1
            current.append(ch)
        elif ch == "]":
            depth -= 1
            current.append(ch)
        elif ch == "," and depth == 0:
            parts.append("".join(current).strip())
            current = []
        else:
            current.append(ch)
    if current:
        parts.append("".join(current).strip())
    return parts


def to_cpp_type(typ: str, class_names: Optional[Set[str]] = None) -> str:
    if typ == "int":     return "int"
    if typ == "float":   return "double"
    if typ == "bool":    return "bool"
    if typ == "string":  return "std::string"
    if typ == "void":    return "void"
    if typ == "bytes":   return "std::vector<uint8_t>"
    if typ == "any":     return "std::any"
    if typ.startswith("list["):
        return f"std::vector<{to_cpp_type(typ[5:-1], class_names)}>"
    if typ.startswith("deque["):
        return f"std::deque<{to_cpp_type(typ[6:-1], class_names)}>"
    if typ.startswith("frozenset["):
        return f"std::unordered_set<{to_cpp_type(typ[10:-1], class_names)}>"
    if typ.startswith("optional["):
        return f"std::optional<{to_cpp_type(typ[9:-1], class_names)}>"
    if typ.startswith("tuple["):
        parts = split_type_args(typ[6:-1])
        return f"std::tuple<{', '.join(to_cpp_type(p, class_names) for p in parts)}>"
    if typ.startswith("dict["):
        parts = split_type_args(typ[5:-1])
        if len(parts) != 2:
            raise TranspileError("dict requires exactly 2 type arguments")
        return f"std::unordered_map<{to_cpp_type(parts[0], class_names)}, {to_cpp_type(parts[1], class_names)}>"
    if typ.startswith("ordereddict["):
        parts = split_type_args(typ[12:-1])
        if len(parts) != 2:
            raise TranspileError("OrderedDict requires exactly 2 type arguments")
        return f"std::map<{to_cpp_type(parts[0], class_names)}, {to_cpp_type(parts[1], class_names)}>"
    if typ.startswith("set["):
        return f"std::unordered_set<{to_cpp_type(typ[4:-1], class_names)}>"
    if typ.startswith("variant["):
        parts = split_type_args(typ[8:-1])
        return f"std::variant<{', '.join(to_cpp_type(p, class_names) for p in parts)}>"
    if typ.startswith("vararg["):
        return f"std::vector<{to_cpp_type(typ[7:-1], class_names)}>"
    if typ.startswith("func["):
        # func[A,B->R] → std::function<R(A,B)>
        inner = typ[5:-1]
        arrow = inner.rfind("->")
        if arrow == -1:
            raise TranspileError(f"Invalid func type: '{typ}'")
        args_str = inner[:arrow]
        ret_cpp = to_cpp_type(inner[arrow + 2:], class_names)
        if args_str:
            args_cpp = ", ".join(to_cpp_type(a, class_names) for a in split_type_args(args_str))
        else:
            args_cpp = ""
        return f"std::function<{ret_cpp}({args_cpp})>"
    if class_names and typ in class_names:
        return typ
    # Generic class instantiation: ClassName[T1,T2,...] → ClassName<T1,T2,...>
    bracket = typ.find("[")
    if bracket != -1:
        base = typ[:bracket]
        if class_names and base in class_names:
            args = split_type_args(typ[bracket + 1:-1])
            return f"{base}<{', '.join(to_cpp_type(a, class_names) for a in args)}>"
    raise TranspileError(f"Unknown type: '{typ}'")


def element_type(list_type: str) -> str:
    if list_type.startswith("list["):
        return list_type[5:-1]
    raise TranspileError(f"'{list_type}' is not a list type")


def annotation_to_type(node: ast.expr, known_classes: Optional[Set[str]] = None) -> str:
    if isinstance(node, ast.Name):
        mapping = {
            "None": "void", "int": "int", "float": "float", "bool": "bool",
            "str": "string", "bytes": "bytes", "bytearray": "bytes", "Any": "any",
        }
        if node.id in mapping:
            return mapping[node.id]
        if known_classes and node.id in known_classes:
            return node.id
        raise TranspileError(f"Unknown type name: '{node.id}'")
    if isinstance(node, ast.Constant) and node.value is None:
        return "void"
    if isinstance(node, ast.Subscript) and isinstance(node.value, ast.Name):
        c = node.value.id
        if c == "list":
            return f"list[{annotation_to_type(node.slice, known_classes)}]"
        if c == "Optional":
            return f"optional[{annotation_to_type(node.slice, known_classes)}]"
        if c == "tuple":
            if isinstance(node.slice, ast.Tuple):
                elts = node.slice.elts
                # Homogeneous tuple: tuple[T, ...] → list[T]
                if (len(elts) == 2 and isinstance(elts[1], ast.Constant)
                        and elts[1].value is ...):
                    return f"list[{annotation_to_type(elts[0], known_classes)}]"
                parts = [annotation_to_type(e, known_classes) for e in elts]
                return f"tuple[{','.join(parts)}]"
            return f"tuple[{annotation_to_type(node.slice, known_classes)}]"
        if c == "Callable":
            if isinstance(node.slice, ast.Tuple) and len(node.slice.elts) == 2:
                args_node, ret_node = node.slice.elts
                if not isinstance(args_node, ast.List):
                    raise TranspileError("Callable: first argument must be a list of types")
                ret_t = annotation_to_type(ret_node, known_classes)
                arg_types = [annotation_to_type(e, known_classes) for e in args_node.elts]
                return f"func[{','.join(arg_types)}->{ret_t}]"
            raise TranspileError("Callable[[ArgTypes...], ReturnType] expected")
        if c == "dict":
            if isinstance(node.slice, ast.Tuple) and len(node.slice.elts) == 2:
                k = annotation_to_type(node.slice.elts[0], known_classes)
                v = annotation_to_type(node.slice.elts[1], known_classes)
                return f"dict[{k},{v}]"
            raise TranspileError("dict[K, V] requires exactly 2 type arguments")
        if c == "set":
            return f"set[{annotation_to_type(node.slice, known_classes)}]"
        if c == "deque":
            return f"deque[{annotation_to_type(node.slice, known_classes)}]"
        if c == "frozenset":
            return f"frozenset[{annotation_to_type(node.slice, known_classes)}]"
        if c == "defaultdict":
            if isinstance(node.slice, ast.Tuple) and len(node.slice.elts) == 2:
                k = annotation_to_type(node.slice.elts[0], known_classes)
                v = annotation_to_type(node.slice.elts[1], known_classes)
                return f"dict[{k},{v}]"
            raise TranspileError("defaultdict[K, V] requires exactly 2 type arguments")
        if c == "OrderedDict":
            if isinstance(node.slice, ast.Tuple) and len(node.slice.elts) == 2:
                k = annotation_to_type(node.slice.elts[0], known_classes)
                v = annotation_to_type(node.slice.elts[1], known_classes)
                return f"ordereddict[{k},{v}]"
            raise TranspileError("OrderedDict[K, V] requires exactly 2 type arguments")
        if c == "Counter":
            elem = annotation_to_type(node.slice, known_classes)
            return f"dict[{elem},int]"
        if c == "Union":
            if isinstance(node.slice, ast.Tuple):
                args = [annotation_to_type(e, known_classes) for e in node.slice.elts]
            else:
                args = [annotation_to_type(node.slice, known_classes)]
            return f"variant[{','.join(args)}]"
        if c in ("Generator", "Iterator", "Iterable"):
            # Generator[T, None, None] or Iterator[T] → list[T]
            if isinstance(node.slice, ast.Tuple):
                yield_t = annotation_to_type(node.slice.elts[0], known_classes)
            else:
                yield_t = annotation_to_type(node.slice, known_classes)
            return f"list[{yield_t}]"
        # Generic class instantiation: ClassName[T1,T2,...] e.g. Stack[int]
        if known_classes and c in known_classes:
            if isinstance(node.slice, ast.Tuple):
                args = [annotation_to_type(e, known_classes) for e in node.slice.elts]
            else:
                args = [annotation_to_type(node.slice, known_classes)]
            return f"{c}[{','.join(args)}]"
    # "ClassName" — string forward reference
    if isinstance(node, ast.Constant) and isinstance(node.value, str):
        name = node.value
        mapping = {"None": "void", "int": "int", "float": "float", "bool": "bool", "str": "string",
                   "bytes": "bytes", "bytearray": "bytes"}
        if name in mapping:
            return mapping[name]
        if known_classes and name in known_classes:
            return name
        raise TranspileError(f"Unknown type name (forward reference): '{name}'")
    # X | Y  (Python 3.10+ union syntax in annotations)
    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
        left = annotation_to_type(node.left, known_classes)
        right = annotation_to_type(node.right, known_classes)
        if left == "void":
            return f"optional[{right}]"
        if right == "void":
            return f"optional[{left}]"
        parts: List[str] = []
        for t in (left, right):
            if t.startswith("variant["):
                parts.extend(split_type_args(t[8:-1]))
            else:
                parts.append(t)
        return f"variant[{','.join(parts)}]"
    raise TranspileError(f"Unsupported type annotation: {ast.unparse(node)}")


def types_compatible(expected: str, got: str) -> bool:
    """int→float widening; concrete type assignable to variant/optional that contains it."""
    if expected == got:
        return True
    if expected == "any" or got == "any":
        return True
    if expected == "float" and got == "int":
        return True
    if expected.startswith("variant["):
        parts = split_type_args(expected[8:-1])
        return got in parts
    if expected.startswith("optional["):
        inner = expected[9:-1]
        return got == "nullopt" or got == inner or (got == "int" and inner == "float")
    return False


# ----------------------------------------
# ClassInfo
# ----------------------------------------

class ClassInfo:
    def __init__(self, name: str):
        self.name = name
        self.parent: Optional[str] = None
        self.extra_parents: List[str] = []          # additional bases beyond the first
        self.fields: Dict[str, str] = {}            # field -> type (insertion-ordered)
        self.methods: Dict[str, Tuple[str, list]] = {}  # method -> (ret, params_no_self)
        self.properties: Set[str] = set()           # methods decorated with @property
        self.property_setters: Dict[str, str] = {}  # prop_name -> value_type (@x.setter)
        self.abstract_methods: Set[str] = set()     # methods decorated with @abstractmethod
        self.type_params: List[str] = []            # TypeVar names from Generic[T, ...]
        self.is_exception: bool = False
        self.is_dataclass: bool = False
        self.is_frozen: bool = False                        # @dataclass(frozen=True)
        self.is_enum: bool = False
        self.is_int_enum: bool = False                  # IntEnum / IntFlag → values are int-compatible
        self.is_str_enum: bool = False                  # StrEnum / string-valued Enum → struct with constexpr
        self.enum_members: List[Tuple[str, str]] = []  # (member_name, cpp_value)
        self.class_vars: Dict[str, Tuple[str, Optional[str]]] = {}  # name → (type, cpp_init)
        self.method_param_names: Dict[str, List[str]] = {}  # method → param names (no self)


# ----------------------------------------
# Scope
# ----------------------------------------

class Scope:
    def __init__(self, parent: Optional["Scope"] = None):
        self.parent = parent
        self.vars: Dict[str, str] = {}

    def define(self, name: str, typ: str):
        self.vars[name] = typ

    def set(self, name: str, typ: str):
        if name in self.vars:
            self.vars[name] = typ
        elif self.parent:
            self.parent.set(name, typ)
        else:
            self.vars[name] = typ

    def lookup(self, name: str) -> Optional[str]:
        if name in self.vars:
            return self.vars[name]
        if self.parent:
            return self.parent.lookup(name)
        return None


# ----------------------------------------
# Transpiler
# ----------------------------------------

Param = Tuple[str, Optional[ast.expr]]


class Transpiler:
    def __init__(self, modules: List[ast.Module], module_names: List[str]):
        self.modules = modules
        self.module_names = module_names
        self.module_name_set = set(module_names)
        self.lines: List[str] = []
        self.indent_level = 0
        self.global_scope = Scope()
        self.functions: Dict[str, Tuple[str, List[Param]]] = {}
        self.classes: Dict[str, ClassInfo] = {}
        self.current_class: Optional[ClassInfo] = None
        self.main_guard_body: Optional[List[ast.stmt]] = None
        self.function_aliases: Dict[str, str] = {}
        self.function_cpp_names: Dict[str, str] = {}   # python name → C++ callable
        self.extra_includes: List[str] = []             # injected by stubs
        self.preamble_lines: List[str] = []             # injected by stubs
        self._generator_yield_type: Optional[str] = None
        self._narrow_counter: int = 0
        self.type_aliases: Dict[str, str] = {}
        self.type_vars: Set[str] = set()
        self.function_param_names: Dict[str, List[str]] = {}  # func → ordered param names
        self._needs_stop_iteration: bool = False
        self._skipped_functions: Dict[str, str] = {}   # name → reason
        self._skipped_classes: Dict[str, str] = {}     # name → reason
        self._has_kwargs: Dict[str, bool] = {}          # name → has **kwargs param

    # ---- emit ----

    def emit(self, line: str = ""):
        self.lines.append("    " * self.indent_level + line)

    def _safe_name(self, name: str) -> str:
        """Append '_' to Python identifiers that collide with C++ reserved words."""
        return name + "_" if name in CPP_RESERVED else name

    def _is_map_type(self, typ: str) -> bool:
        """True for dict[K,V] and ordereddict[K,V] (both map-like)."""
        return typ.startswith("dict[") or typ.startswith("ordereddict[")

    def _map_cpp_type(self, typ: str) -> str:
        """Return C++ type for a map type, defaulting to unordered_map."""
        if typ.startswith("ordereddict["):
            parts = split_type_args(typ[12:-1])
            return f"std::map<{to_cpp_type(parts[0], set(self.classes.keys()))}, {to_cpp_type(parts[1], set(self.classes.keys()))}>"
        return self.cpp_type(typ)

    def _error(self, msg: str, node: Optional[ast.AST] = None) -> str:
        """Format error message with file:line if node is provided."""
        if node is not None and hasattr(node, 'lineno'):
            src = getattr(node, 'end_lineno', None)
            if src:
                return f"{node.lineno}: {msg}"
        return msg

    def indent(self):
        self.indent_level += 1

    def dedent(self):
        self.indent_level = max(0, self.indent_level - 1)

    # ---- type helpers ----

    def cpp_type(self, typ: str) -> str:
        return to_cpp_type(typ, set(self.classes.keys()) | self.type_vars)

    def ann_to_type(self, node: ast.expr) -> str:
        if isinstance(node, ast.Name) and node.id in self.type_aliases:
            return self.type_aliases[node.id]
        known = set(self.classes.keys()) | self.type_vars
        return annotation_to_type(node, known)

    def exc_cpp_type(self, name: str) -> str:
        if name in EXCEPTION_MAP:
            return EXCEPTION_MAP[name]
        if name in self.classes and self.classes[name].is_exception:
            return name
        raise TranspileError(f"Unknown exception type: '{name}'")

    def lookup_field(self, class_name: str, field: str) -> Optional[str]:
        if class_name not in self.classes:
            return None
        info = self.classes[class_name]
        if field in info.fields:
            return info.fields[field]
        if info.parent:
            return self.lookup_field(info.parent, field)
        return None

    def lookup_method(self, class_name: str, method: str) -> Optional[Tuple[str, list]]:
        if class_name not in self.classes:
            return None
        info = self.classes[class_name]
        if method in info.methods:
            return info.methods[method]
        if info.parent:
            result = self.lookup_method(info.parent, method)
            if result is not None:
                return result
        for extra in info.extra_parents:
            result = self.lookup_method(extra, method)
            if result is not None:
                return result
        return None

    def method_is_virtual(self, class_name: str, method: str) -> bool:
        for other in self.classes.values():
            if other.parent == class_name and method in other.methods:
                return True
        return False

    def _method_is_const(self, f: ast.FunctionDef, class_name: str = "") -> bool:
        """True if a method body does not mutate self (can be marked const)."""
        info = self.classes.get(class_name)
        for node in ast.walk(f):
            if isinstance(node, ast.Assign):
                for target in node.targets:
                    if self._is_self_attr(target):
                        return False
            if isinstance(node, ast.AugAssign) and self._is_self_attr(node.target):
                return False
            # self.X.method() or self.method() calls that likely mutate
            if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
                func_val = node.func.value
                # self.X.method() — mutating through field
                if self._is_self_attr(func_val):
                    return False
                # self.method() — calling own non-const method
                if isinstance(func_val, ast.Name) and func_val.id == "self":
                    return False
        return True

    def _is_self_attr(self, node: ast.expr) -> bool:
        return (isinstance(node, ast.Attribute) and
                isinstance(node.value, ast.Name) and node.value.id == "self")

    def _class_is_polymorphic(self, class_name: str) -> bool:
        """True if any subclass overrides a method of this class."""
        if class_name not in self.classes:
            return False
        for other in self.classes.values():
            if other.parent == class_name and any(
                m in other.methods for m in self.classes[class_name].methods
            ):
                return True
        return False

    def method_overrides(self, class_name: str, method: str) -> bool:
        info = self.classes.get(class_name)
        if not info or not info.parent:
            return False
        return self.lookup_method(info.parent, method) is not None

    def _lookup_property_type(self, class_name: str, attr: str) -> Optional[str]:
        if class_name not in self.classes:
            return None
        info = self.classes[class_name]
        if attr in info.properties:
            m = info.methods.get(attr)
            return m[0] if m else None
        if info.parent:
            return self._lookup_property_type(info.parent, attr)
        return None

    # ---- generic / TypeVar helpers ----

    def _class_of(self, typ: str) -> Optional[str]:
        """Return the base class name for plain or generic types; None if not a class."""
        bracket = typ.find("[")
        base = typ[:bracket] if bracket != -1 else typ
        return base if base in self.classes else None

    def _is_subclass(self, child: str, parent: str) -> bool:
        """Return True if child class is parent or inherits from it (direct or transitive)."""
        if child == parent:
            return True
        if child not in self.classes:
            return False
        info = self.classes[child]
        if info.parent and self._is_subclass(info.parent, parent):
            return True
        for ep in info.extra_parents:
            if self._is_subclass(ep, parent):
                return True
        return False

    def _types_compat(self, expected: str, got: str) -> bool:
        """Like types_compatible() but also allows subclass assignment."""
        if types_compatible(expected, got):
            return True
        # subclass of a user class is assignable to parent type
        gc = self._class_of(got)
        ec = self._class_of(expected)
        if gc and ec and self._is_subclass(gc, ec):
            return True
        # IntEnum / IntFlag values are compatible with int
        if expected == "int" and gc and self.classes[gc].is_int_enum:
            return True
        # int is compatible with IntEnum parameter/variable
        if got == "int" and ec and self.classes[ec].is_int_enum:
            return True
        # StrEnum values are compatible with string
        if expected == "string" and gc and self.classes[gc].is_str_enum:
            return True
        if got == "string" and ec and self.classes[ec].is_str_enum:
            return True
        return False

    def _make_substitution(self, typ: str) -> Dict[str, str]:
        """For Stack[int], build {T: int} using the class's type_params list."""
        bracket = typ.find("[")
        if bracket == -1:
            return {}
        base = typ[:bracket]
        if base not in self.classes:
            return {}
        type_params = self.classes[base].type_params
        type_args = split_type_args(typ[bracket + 1:-1])
        if len(type_params) != len(type_args):
            return {}
        return dict(zip(type_params, type_args))

    def _substitute_typevars(self, typ: str, sub: Dict[str, str]) -> str:
        """Replace TypeVar names in a type string using a substitution dict."""
        if not sub:
            return typ
        if typ in sub:
            return sub[typ]
        for prefix in ("list[", "optional[", "set[", "vararg["):
            if typ.startswith(prefix):
                return f"{prefix[:-1]}[{self._substitute_typevars(typ[len(prefix):-1], sub)}]"
        if typ.startswith("tuple["):
            parts = [self._substitute_typevars(p, sub) for p in split_type_args(typ[6:-1])]
            return f"tuple[{','.join(parts)}]"
        if typ.startswith("dict["):
            parts = [self._substitute_typevars(p, sub) for p in split_type_args(typ[5:-1])]
            return f"dict[{','.join(parts)}]"
        if typ.startswith("func["):
            inner = typ[5:-1]
            arrow = inner.rfind("->")
            if arrow != -1:
                args_str = inner[:arrow]
                ret_str = inner[arrow + 2:]
                new_ret = self._substitute_typevars(ret_str, sub)
                if args_str:
                    new_args = ",".join(self._substitute_typevars(a, sub)
                                        for a in split_type_args(args_str))
                    return f"func[{new_args}->{new_ret}]"
                return f"func[->{new_ret}]"
        return typ

    def register_type_vars(self):
        """Detect T = TypeVar('T') at module level and register T in self.type_vars."""
        for mod in self.modules:
            for node in mod.body:
                if not (isinstance(node, ast.Assign) and len(node.targets) == 1
                        and isinstance(node.targets[0], ast.Name)):
                    continue
                name = node.targets[0].id
                val = node.value
                if (isinstance(val, ast.Call) and isinstance(val.func, ast.Name)
                        and val.func.id == "TypeVar"
                        and val.args and isinstance(val.args[0], ast.Constant)
                        and isinstance(val.args[0].value, str)):
                    self.type_vars.add(name)

    # ---- expression inference ----

    def infer_expr(self, node: ast.expr, scope: Scope,
                    expected_type: Optional[str] = None) -> Tuple[str, str]:
        if isinstance(node, ast.Constant):
            v = node.value
            if v is None:            return ("std::nullopt", "nullopt")
            if isinstance(v, bool):  return ("true" if v else "false", "bool")
            if isinstance(v, int):   return (str(v), "int")
            if isinstance(v, float): return (repr(v), "float")
            if isinstance(v, str):   return (json.dumps(v), "string")
            if isinstance(v, bytes):
                elems = ", ".join(str(b) for b in v)
                return (f"std::vector<uint8_t>{{{elems}}}", "bytes")
            raise TranspileError(f"Unsupported constant: {v!r}")

        if isinstance(node, ast.Name):
            name = node.id
            if name in self.function_aliases:
                name = self.function_aliases[name]
            if name == "None":
                return ("std::nullopt", "nullopt")
            t = scope.lookup(name)
            if t is None:
                if name in self.functions:
                    # Function used as a Callable value → build func[...] type
                    ret, fparams = self.functions[name]
                    arg_types = [pt for pt, _ in fparams if not pt.startswith("vararg[")]
                    return (name, f"func[{','.join(arg_types)}->{ret}]")
                raise TranspileError(f"Use of undefined variable '{node.id}'")
            # `self` → C++ `*this`
            if name == "self" and self.current_class is not None:
                return ("*this", self.current_class.name)
            return (self._safe_name(name), t)

        if isinstance(node, ast.Attribute):
            return self._infer_attr(node, scope)

        if isinstance(node, ast.UnaryOp):
            if isinstance(node.op, ast.USub):
                c, t = self.infer_expr(node.operand, scope)
                if t not in ("int", "float"):
                    if t in self.classes:
                        m = self.lookup_method(t, "__neg__")
                        if m:
                            return (f"(-{c})", m[0])
                    raise TranspileError("Unary - only for numbers or classes with __neg__")
                return (f"(-{c})", t)
            if isinstance(node.op, ast.UAdd):
                c, t = self.infer_expr(node.operand, scope)
                if t not in ("int", "float"):
                    if t in self.classes:
                        m = self.lookup_method(t, "__pos__")
                        if m:
                            return (f"(+{c})", m[0])
                    raise TranspileError("Unary + only for numbers or classes with __pos__")
                return (f"(+{c})", t)
            if isinstance(node.op, ast.Invert):
                c, t = self.infer_expr(node.operand, scope)
                if t != "int":
                    raise TranspileError("~ only for int")
                return (f"(~{c})", "int")
            if isinstance(node.op, ast.Not):
                c, t = self.infer_expr(node.operand, scope)
                if t == "bool":
                    return (f"(!{c})", "bool")
                # User class with __bool__: not obj → !(bool)obj
                base_cls = self._class_of(t)
                if base_cls and "__bool__" in self.classes[base_cls].methods:
                    return (f"(!(bool){c})", "bool")
                raise TranspileError("'not' only for bool")

        if isinstance(node, ast.BinOp):
            lc, lt = self.infer_expr(node.left, scope)
            rc, rt = self.infer_expr(node.right, scope)
            # Set binary operators: | & - ^
            if lt.startswith("set[") or lt.startswith("frozenset["):
                elem_t = lt[4:-1] if lt.startswith("set[") else lt[10:-1]
                result_t = f"set[{elem_t}]"
                cpp_t = self.cpp_type(result_t)
                if isinstance(node.op, ast.BitOr):
                    return (f"[&](){{{cpp_t} _r_={lc};for(auto& _e_:{rc})_r_.insert(_e_);return _r_;}}()", result_t)
                if isinstance(node.op, ast.BitAnd):
                    return (f"[&](){{{cpp_t} _r_;for(auto& _e_:{lc})if({rc}.count(_e_))_r_.insert(_e_);return _r_;}}()", result_t)
                if isinstance(node.op, ast.Sub):
                    return (f"[&](){{{cpp_t} _r_={lc};for(auto& _e_:{rc})_r_.erase(_e_);return _r_;}}()", result_t)
                if isinstance(node.op, ast.BitXor):
                    return (f"[&](){{{cpp_t} _r_;for(auto& _e_:{lc})if(!{rc}.count(_e_))_r_.insert(_e_);for(auto& _e_:{rc})if(!{lc}.count(_e_))_r_.insert(_e_);return _r_;}}()", result_t)
            if lt == rt == "string" and isinstance(node.op, ast.Add):
                return (f"({lc} + {rc})", "string")
            # string * int  or  int * string
            if isinstance(node.op, ast.Mult):
                if lt == "string" and rt == "int":
                    return (f'[&](){{std::string _r_;for(int _i=0;_i<{rc};++_i)_r_+={lc};return _r_;}}()', "string")
                if lt == "int" and rt == "string":
                    return (f'[&](){{std::string _r_;for(int _i=0;_i<{lc};++_i)_r_+={rc};return _r_;}}()', "string")
                # list * int  or  int * list
                if lt.startswith("list[") and rt == "int":
                    ct = self.cpp_type(lt)
                    return (f'[=](){{{ct} _s_={lc};{ct} _r_;for(int _i=0;_i<{rc};++_i)for(auto _e_:_s_)_r_.push_back(_e_);return _r_;}}()', lt)
                if lt == "int" and rt.startswith("list["):
                    ct = self.cpp_type(rt)
                    return (f'[=](){{{ct} _s_={rc};{ct} _r_;for(int _i=0;_i<{lc};++_i)for(auto _e_:_s_)_r_.push_back(_e_);return _r_;}}()', rt)
            # list + list  (concatenation)
            if isinstance(node.op, ast.Add) and lt.startswith("list[") and lt == rt:
                return (f"[&](){{auto _r_={lc};auto _rhs_={rc};_r_.insert(_r_.end(),_rhs_.begin(),_rhs_.end());return _r_;}}()", lt)
            # bytes + bytes (concatenation)
            if lt == rt == "bytes" and isinstance(node.op, ast.Add):
                return (f"[&](){{auto _r_={lc};_r_.insert(_r_.end(),{rc}.begin(),{rc}.end());return _r_;}}()", "bytes")
            # bytes * int / int * bytes (repetition)
            if isinstance(node.op, ast.Mult):
                if lt == "bytes" and rt == "int":
                    return (f"[&](){{decltype({lc}) _r_;for(int _i=0;_i<{rc};++_i)_r_.insert(_r_.end(),{lc}.begin(),{lc}.end());return _r_;}}()", "bytes")
                if lt == "int" and rt == "bytes":
                    return (f"[&](){{decltype({rc}) _r_;for(int _i=0;_i<{lc};++_i)_r_.insert(_r_.end(),{rc}.begin(),{rc}.end());return _r_;}}()", "bytes")
            if lt not in ("int", "float") or rt not in ("int", "float"):
                # Check for user-defined operator on the left operand
                dunder = AST_OP_DUNDER.get(type(node.op))
                if dunder and lt in self.classes:
                    m = self.lookup_method(lt, dunder)
                    if m:
                        ret_t, params = m
                        if params and params[0][0] == rt:
                            sym = AST_OP_SYMBOL[type(node.op)]
                            return (f"({lc} {sym} {rc})", ret_t)
                raise TranspileError(f"Binary op between '{lt}' and '{rt}' not supported")
            res = "float" if "float" in (lt, rt) else "int"
            op = node.op
            if isinstance(op, ast.Add):     return (f"({lc} + {rc})", res)
            if isinstance(op, ast.Sub):     return (f"({lc} - {rc})", res)
            if isinstance(op, ast.Mult):    return (f"({lc} * {rc})", res)
            if isinstance(op, ast.Div):     return (f"({lc} / {rc})", "float")
            if isinstance(op, ast.Mod):
                if res == "float": raise TranspileError("% not supported for float")
                return (f"({lc} % {rc})", "int")
            if isinstance(op, ast.FloorDiv):
                if res == "float": raise TranspileError("// not supported for float")
                return (f"({lc} / {rc})", "int")
            if isinstance(op, ast.Pow):
                if res == "int": return (f"((int)std::pow({lc}, {rc}))", "int")
                return (f"std::pow({lc}, {rc})", "float")
            if isinstance(op, ast.BitOr):    return (f"({lc} | {rc})", "int")
            if isinstance(op, ast.BitAnd):   return (f"({lc} & {rc})", "int")
            if isinstance(op, ast.BitXor):   return (f"({lc} ^ {rc})", "int")
            if isinstance(op, ast.LShift):   return (f"({lc} << {rc})", "int")
            if isinstance(op, ast.RShift):   return (f"({lc} >> {rc})", "int")
            raise TranspileError(f"Unsupported binary op: {type(op).__name__}")

        if isinstance(node, ast.BoolOp):
            op_str = "&&" if isinstance(node.op, ast.And) else "||"
            parts = []
            for v in node.values:
                c, t = self.infer_expr(v, scope)
                if t == "bool":
                    parts.append(c)
                else:
                    base_cls = self._class_of(t)
                    if base_cls and "__bool__" in self.classes[base_cls].methods:
                        parts.append(f"(bool){c}")
                    else:
                        raise TranspileError("Boolean ops only on bool")
            return (f"({f' {op_str} '.join(parts)})", "bool")

        if isinstance(node, ast.Compare):
            cmp_map = {ast.Eq:"==", ast.NotEq:"!=", ast.Lt:"<", ast.LtE:"<=", ast.Gt:">", ast.GtE:">="}
            # Chained comparisons: a < b < c → (a<b && b<c)
            if len(node.ops) > 1:
                operands = [node.left] + node.comparators
                parts = []
                for i, op in enumerate(node.ops):
                    lc, lt = self.infer_expr(operands[i], scope)
                    rc, rt = self.infer_expr(operands[i + 1], scope)
                    op_str = cmp_map.get(type(op))
                    if not op_str:
                        raise TranspileError(f"Unsupported comparison in chain: {type(op).__name__}")
                    parts.append(f"({lc} {op_str} {rc})")
                return ("(" + " && ".join(parts) + ")", "bool")
            lc, lt = self.infer_expr(node.left, scope)
            rc, rt = self.infer_expr(node.comparators[0], scope)
            op = node.ops[0]
            if isinstance(op, ast.Is) and rt == "nullopt":
                return (f"(!{lc}.has_value())", "bool")
            if isinstance(op, ast.IsNot) and rt == "nullopt":
                return (f"({lc}.has_value())", "bool")
            if isinstance(op, (ast.In, ast.NotIn)):
                negate = isinstance(op, ast.NotIn)
                if self._is_map_type(rt):
                    inner = rt[5:-1] if rt.startswith("dict[") else rt[12:-1]
                    k_t = split_type_args(inner)[0]
                    if lt != k_t:
                        raise TranspileError(f"'in' dict: key must be '{k_t}', got '{lt}'")
                    expr = f"({rc}.count({lc}) > 0)"
                elif rt.startswith("list["):
                    elem_t = element_type(rt)
                    if lt != elem_t:
                        raise TranspileError(f"'in' list: element must be '{elem_t}', got '{lt}'")
                    expr = f"(std::find({rc}.begin(), {rc}.end(), {lc}) != {rc}.end())"
                elif rt.startswith("deque["):
                    elem_t = rt[6:-1]
                    if lt != elem_t:
                        raise TranspileError(f"'in' deque: element must be '{elem_t}', got '{lt}'")
                    expr = f"(std::find({rc}.begin(), {rc}.end(), {lc}) != {rc}.end())"
                elif rt.startswith("set["):
                    elem_t = rt[4:-1]
                    if lt != elem_t:
                        raise TranspileError(f"'in' set: element must be '{elem_t}', got '{lt}'")
                    expr = f"({rc}.count({lc}) > 0)"
                elif rt.startswith("frozenset["):
                    elem_t = rt[10:-1]
                    if lt != elem_t:
                        raise TranspileError(f"'in' frozenset: element must be '{elem_t}', got '{lt}'")
                    expr = f"({rc}.count({lc}) > 0)"
                elif rt == "string":
                    if lt != "string":
                        raise TranspileError(f"'in' string: element must be 'string', got '{lt}'")
                    expr = f"({rc}.find({lc}) != std::string::npos)"
                else:
                    base_cls = self._class_of(rt)
                    if base_cls and "__contains__" in self.classes[base_cls].methods:
                        expr = f"({rc}.contains({lc}))"
                    else:
                        raise TranspileError(f"'in' not supported for type '{rt}'")
                return (f"(!{expr})" if negate else expr, "bool")
            op_str = cmp_map.get(type(op))
            if not op_str:
                raise TranspileError(f"Unsupported comparison: {type(op).__name__}")
            return (f"({lc} {op_str} {rc})", "bool")

        if isinstance(node, ast.List):
            if not node.elts:
                if expected_type and expected_type.startswith("list["):
                    return (f"{self.cpp_type(expected_type)}{{}}", expected_type)
                raise TranspileError("Empty list literals need an explicit type annotation")
            codes, elem_t = [], None
            for elt in node.elts:
                c, t = self.infer_expr(elt, scope)
                if elem_t is None: elem_t = t
                elif t != elem_t:
                    raise TranspileError(f"Mixed list element types: '{elem_t}' and '{t}'")
                codes.append(c)
            lt = f"list[{elem_t}]"
            return (f"{self.cpp_type(lt)}{{{', '.join(codes)}}}", lt)

        if isinstance(node, ast.Set):
            if not node.elts:
                raise TranspileError("Empty set literals need an explicit type annotation")
            codes, elem_t = [], None
            for elt in node.elts:
                c, t = self.infer_expr(elt, scope)
                if elem_t is None: elem_t = t
                elif t != elem_t:
                    raise TranspileError(f"Mixed set element types: '{elem_t}' and '{t}'")
                codes.append(c)
            st = f"set[{elem_t}]"
            return (f"{self.cpp_type(st)}{{{', '.join(codes)}}}", st)

        if isinstance(node, ast.Tuple):
            if not node.elts:
                raise TranspileError("Empty tuples not supported")
            codes, types = [], []
            for elt in node.elts:
                c, t = self.infer_expr(elt, scope)
                codes.append(c); types.append(t)
            tt = f"tuple[{','.join(types)}]"
            return (f"std::make_tuple({', '.join(codes)})", tt)

        if isinstance(node, ast.Dict):
            if not node.keys:
                raise TranspileError("Empty dict literals need an explicit type annotation")
            k_codes, v_codes, k_t, v_t = [], [], None, None
            for k, v in zip(node.keys, node.values):
                if k is None:
                    raise TranspileError("Dict unpacking (**) not supported")
                kc, kt = self.infer_expr(k, scope)
                vc, vt = self.infer_expr(v, scope)
                if k_t is None:
                    k_t = kt
                elif kt != k_t:
                    raise TranspileError(f"Mixed dict key types: '{k_t}' and '{kt}'")
                if v_t is None:
                    v_t = vt
                elif vt != v_t:
                    raise TranspileError(f"Mixed dict value types: '{v_t}' and '{vt}'")
                k_codes.append(kc)
                v_codes.append(vc)
            dt = f"dict[{k_t},{v_t}]"
            pairs = ", ".join(f"{{{kc}, {vc}}}" for kc, vc in zip(k_codes, v_codes))
            return (f"{self.cpp_type(dt)}{{{pairs}}}", dt)

        if isinstance(node, ast.Subscript):
            oc, ot = self.infer_expr(node.value, scope)

            # Slicing (ast.Slice: lst[a:b], s[a:b], lst[::-1], etc.)
            if isinstance(node.slice, ast.Slice):
                sl = node.slice
                def _slice_idx(expr_node, default: str, size_expr: str) -> str:
                    if expr_node is None: return default
                    c, _ = self.infer_expr(expr_node, scope)
                    return c
                # Sentinels for omitted bounds: 1<<30 = "use step-direction default"
                _SNONE = "1073741824"   # lower omitted
                _ENONE = "-1073741825"  # upper omitted
                if ot.startswith("list["):
                    cpp_t = self.cpp_type(ot)
                    lc = _SNONE if sl.lower is None else self.infer_expr(sl.lower, scope)[0]
                    uc = _ENONE if sl.upper is None else self.infer_expr(sl.upper, scope)[0]
                    if sl.step is None:
                        # No step: simple contiguous slice
                        return (
                            f"[&](){{{cpp_t} _r_;auto& _v={oc};int _n=(int)_v.size();"
                            f"int _a=({lc}>=1073741824)?0:({lc});"
                            f"int _b=({uc}<=-1073741825)?_n:({uc});"
                            f"if(_a<0)_a=std::max(0,_n+_a);else _a=std::min(_a,_n);"
                            f"if(_b<0)_b=std::max(0,_n+_b);else _b=std::min(_b,_n);"
                            f"if(_a<_b)_r_.assign(_v.begin()+_a,_v.begin()+_b);return _r_;}}()",
                            ot
                        )
                    sc, _ = self.infer_expr(sl.step, scope)
                    return (
                        f"[&](){{{cpp_t} _r_;auto& _v={oc};int _n=(int)_v.size();"
                        f"int _st=({sc});"
                        f"int _a=({lc}),_b=({uc});"
                        f"if(_a>=1073741824)_a=(_st>=0)?0:_n-1;"
                        f"else{{if(_a<0)_a=std::max(0,_n+_a);else _a=std::min(_a,(_st>=0)?_n:_n-1);}}"
                        f"if(_b<=-1073741825)_b=(_st>=0)?_n:-1;"
                        f"else{{if(_b<0)_b=std::max(-1,_n+_b);else _b=std::min(_b,_n);}}"
                        f"if(_st>0){{for(int _i=_a;_i<_b&&_i<_n;_i+=_st)_r_.push_back(_v[_i]);}}"
                        f"else if(_st<0){{for(int _i=_a;_i>_b&&_i>=0;_i+=_st)_r_.push_back(_v[_i]);}}"
                        f"return _r_;}}()",
                        ot
                    )
                if ot == "string":
                    lc = _SNONE if sl.lower is None else self.infer_expr(sl.lower, scope)[0]
                    uc = _ENONE if sl.upper is None else self.infer_expr(sl.upper, scope)[0]
                    if sl.step is None:
                        return (
                            f"[&](){{std::string _s={oc};int _n=(int)_s.size();"
                            f"int _a=({lc}>=1073741824)?0:({lc});"
                            f"int _b=({uc}<=-1073741825)?_n:({uc});"
                            f"if(_a<0)_a=std::max(0,_n+_a);else _a=std::min(_a,_n);"
                            f"if(_b<0)_b=std::max(0,_n+_b);else _b=std::min(_b,_n);"
                            f"return _a<_b?_s.substr(_a,_b-_a):std::string();}}()",
                            "string"
                        )
                    sc, _ = self.infer_expr(sl.step, scope)
                    return (
                        f"[&](){{std::string _src={oc};std::string _r;int _n=(int)_src.size();"
                        f"int _st=({sc});"
                        f"int _a=({lc}),_b=({uc});"
                        f"if(_a>=1073741824)_a=(_st>=0)?0:_n-1;"
                        f"else{{if(_a<0)_a=std::max(0,_n+_a);else _a=std::min(_a,(_st>=0)?_n:_n-1);}}"
                        f"if(_b<=-1073741825)_b=(_st>=0)?_n:-1;"
                        f"else{{if(_b<0)_b=std::max(-1,_n+_b);else _b=std::min(_b,_n);}}"
                        f"if(_st>0){{for(int _i=_a;_i<_b&&_i<_n;_i+=_st)_r+=_src[_i];}}"
                        f"else if(_st<0){{for(int _i=_a;_i>_b&&_i>=0;_i+=_st)_r+=_src[_i];}}"
                        f"return _r;}}()",
                        "string"
                    )
                raise TranspileError(f"Slicing not supported for type '{ot}'")

            if ot.startswith("list["):
                ic, it = self.infer_expr(node.slice, scope)
                if it != "int": raise TranspileError("List index must be int")
                if isinstance(node.slice, ast.UnaryOp) and isinstance(node.slice.op, ast.USub):
                    return (f"{oc}[(int){oc}.size() + ({ic})]", element_type(ot))
                return (f"{oc}[{ic}]", element_type(ot))
            if ot == "string":
                ic, it = self.infer_expr(node.slice, scope)
                if it != "int": raise TranspileError("String index must be int")
                if isinstance(node.slice, ast.UnaryOp) and isinstance(node.slice.op, ast.USub):
                    return (f"std::string(1, {oc}[(int){oc}.size() + ({ic})])", "string")
                return (f"std::string(1, {oc}[{ic}])", "string")
            if ot == "bytes":
                ic, it = self.infer_expr(node.slice, scope)
                if it != "int": raise TranspileError("Bytes index must be int")
                if isinstance(node.slice, ast.UnaryOp) and isinstance(node.slice.op, ast.USub):
                    return (f"{oc}[(int){oc}.size() + ({ic})]", "int")
                return (f"{oc}[{ic}]", "int")
            if ot.startswith("tuple["):
                if not isinstance(node.slice, ast.Constant) or not isinstance(node.slice.value, int):
                    raise TranspileError("Tuple index must be an integer literal")
                i = node.slice.value
                parts = split_type_args(ot[6:-1])
                if i < 0 or i >= len(parts):
                    raise TranspileError(f"Tuple index {i} out of range")
                return (f"std::get<{i}>({oc})", parts[i])
            if self._is_map_type(ot):
                ic, it = self.infer_expr(node.slice, scope)
                inner = ot[5:-1] if ot.startswith("dict[") else ot[12:-1]
                k_t, v_t = split_type_args(inner)
                if it != k_t: raise TranspileError(f"Dict key must be '{k_t}', got '{it}'")
                return (f"{oc}[{ic}]", v_t)
            if ot.startswith("deque["):
                ic, it = self.infer_expr(node.slice, scope)
                if it != "int": raise TranspileError("Deque index must be int")
                if isinstance(node.slice, ast.UnaryOp) and isinstance(node.slice.op, ast.USub):
                    return (f"{oc}[(int){oc}.size() + ({ic})]", ot[6:-1])
                return (f"{oc}[{ic}]", ot[6:-1])
            # User class with __getitem__
            base_cls = self._class_of(ot)
            if base_cls and "__getitem__" in self.classes[base_cls].methods:
                ic, _ = self.infer_expr(node.slice, scope)
                ret_t = self.classes[base_cls].methods["__getitem__"][0]
                return (f"{oc}[{ic}]", ret_t)
            raise TranspileError(f"Subscript not supported for type '{ot}'")

        if isinstance(node, ast.JoinedStr):
            parts = []
            for piece in node.values:
                if isinstance(piece, ast.Constant):
                    parts.append(json.dumps(str(piece.value)))
                elif isinstance(piece, ast.FormattedValue):
                    c, t = self.infer_expr(piece.value, scope)
                    if piece.format_spec is not None:
                        spec = "".join(
                            v.value for v in piece.format_spec.values
                            if isinstance(v, ast.Constant)
                        )
                        parts.append(self._format_spec_cpp(c, t, spec))
                    elif t == "exception":
                        parts.append(f"std::string({c}.what())")
                    else:
                        parts.append(self._to_string_expr(c, t))
                else:
                    raise TranspileError("Unsupported f-string component")
            if not parts:
                return ('std::string("")', "string")
            return ("(" + " + ".join(parts) + ")", "string")

        if isinstance(node, ast.IfExp):
            tc, tt = self.infer_expr(node.test, scope)
            if tt != "bool":
                raise TranspileError("Ternary condition must be bool")
            bc, bt = self.infer_expr(node.body, scope)
            oc, ot = self.infer_expr(node.orelse, scope)
            if bt != ot:
                raise TranspileError(
                    f"Ternary branches have different types: '{bt}' and '{ot}'"
                )
            return (f"({tc} ? {bc} : {oc})", bt)

        if isinstance(node, ast.Lambda):
            return self._infer_lambda(node, scope, expected_type)

        if isinstance(node, ast.ListComp):
            return self._infer_list_comp(node, scope)

        if isinstance(node, ast.DictComp):
            return self._infer_dict_comp(node, scope)

        if isinstance(node, ast.SetComp):
            return self._infer_set_comp(node, scope)

        if isinstance(node, ast.Call):
            return self._infer_call(node, scope)

        if isinstance(node, ast.NamedExpr):
            ec, et = self.infer_expr(node.value, scope)
            name = node.target.id
            safe = self._safe_name(name)
            existing = scope.lookup(name)
            if existing is None:
                scope.define(name, et)
            else:
                if not self._types_compat(existing, et):
                    raise TranspileError(
                        f"Walrus: cannot assign '{et}' to '{name}' of type '{existing}'"
                    )
            # Return assignment as an inline expression for use in conditions etc.
            return (f"({safe} = {ec})", et if existing is None else existing)

        raise TranspileError(f"Unsupported expression: {type(node).__name__}")

    def _infer_attr(self, node: ast.Attribute, scope: Scope) -> Tuple[str, str]:
        attr = node.attr
        # self.field / self.property / self.class_var
        if isinstance(node.value, ast.Name) and node.value.id == "self":
            if not self.current_class:
                raise TranspileError("'self' used outside a class method")
            ft = self.lookup_field(self.current_class.name, attr)
            if ft is not None:
                return (f"this->{attr}", ft)
            pt = self._lookup_property_type(self.current_class.name, attr)
            if pt is not None:
                return (f"this->{attr}()", pt)
            cv = self.current_class.class_vars.get(attr)
            if cv is not None:
                return (f"{self.current_class.name}::{attr}", cv[0])
            raise TranspileError(f"Class '{self.current_class.name}' has no field '{attr}'")
        # EnumClass.MEMBER or ClassName.class_var  →  ClassName::name
        if isinstance(node.value, ast.Name):
            cls_name = node.value.id
            if cls_name in self.classes:
                if self.classes[cls_name].is_enum:
                    if self.classes[cls_name].is_int_enum:
                        return (f"(int)({cls_name}::{attr})", "int")
                    if self.classes[cls_name].is_str_enum:
                        return (f"{cls_name}::{attr}", "string")
                    return (f"{cls_name}::{attr}", cls_name)
                cv = self.classes[cls_name].class_vars.get(attr)
                if cv is not None:
                    return (f"{cls_name}::{attr}", cv[0])
        # obj.field / obj.property / obj.class_var (including generic instances like Stack[int])
        oc, ot = self.infer_expr(node.value, scope)
        # optional[T]: auto-dereference when accessing attribute (programmer checks is-not-None)
        if ot.startswith("optional["):
            inner_t = ot[9:-1]
            inner_base = self._class_of(inner_t)
            if inner_base:
                sub = self._make_substitution(inner_t)
                ft = self.lookup_field(inner_base, attr)
                if ft is not None:
                    return (f"(*{oc}).{attr}", self._substitute_typevars(ft, sub))
                pt = self._lookup_property_type(inner_base, attr)
                if pt is not None:
                    return (f"(*{oc}).{attr}()", self._substitute_typevars(pt, sub))
        base_cls = self._class_of(ot)
        if base_cls:
            sub = self._make_substitution(ot)
            ft = self.lookup_field(base_cls, attr)
            if ft is not None:
                return (f"{oc}.{attr}", self._substitute_typevars(ft, sub))
            pt = self._lookup_property_type(base_cls, attr)
            if pt is not None:
                return (f"{oc}.{attr}()", self._substitute_typevars(pt, sub))
            cv = self.classes[base_cls].class_vars.get(attr)
            if cv is not None:
                return (f"{base_cls}::{attr}", cv[0])
        raise TranspileError(f"Attribute '.{attr}' not supported on type '{ot}'")

    def _infer_call(self, node: ast.Call, scope: Scope) -> Tuple[str, str]:
        # Generic class instantiation: Stack[int](...) via Subscript
        if isinstance(node.func, ast.Subscript) and isinstance(node.func.value, ast.Name):
            class_name = node.func.value.id
            if class_name in self.classes and self.classes[class_name].type_params:
                if isinstance(node.func.slice, ast.Tuple):
                    type_args = [self.ann_to_type(e) for e in node.func.slice.elts]
                else:
                    type_args = [self.ann_to_type(node.func.slice)]
                instance_type = f"{class_name}[{','.join(type_args)}]"
                sub = dict(zip(self.classes[class_name].type_params, type_args))
                info = self.classes[class_name]
                init = info.methods.get("__init__")
                params = init[1] if init else []
                n_req = sum(1 for _, d in params if d is None)
                if not (n_req <= len(node.args) <= len(params)):
                    raise TranspileError(
                        f"'{class_name}()' expects {n_req}–{len(params)} args, got {len(node.args)}"
                    )
                codes = []
                for i, arg in enumerate(node.args):
                    c, _ = self.infer_expr(arg, scope)
                    codes.append(c)
                cpp_args = ", ".join(self.cpp_type(a) for a in type_args)
                return (f"{class_name}<{cpp_args}>({', '.join(codes)})", instance_type)

        # Simple name call
        if isinstance(node.func, ast.Name):
            fname = node.func.id

            # Callable variable in scope: func[A,B->R] type
            var_type = scope.lookup(fname)
            if var_type is not None and var_type.startswith("func["):
                inner = var_type[5:-1]
                arrow = inner.rfind("->")
                if arrow != -1:
                    args_str = inner[:arrow]
                    ret_t = inner[arrow + 2:]
                    arg_types = split_type_args(args_str) if args_str else []
                    if len(node.args) != len(arg_types):
                        raise TranspileError(
                            f"Callable '{fname}' expects {len(arg_types)} args, got {len(node.args)}"
                        )
                    codes = []
                    for arg, expected_t in zip(node.args, arg_types):
                        c, t = self.infer_expr(arg, scope)
                        if not self._types_compat(expected_t, t):
                            raise TranspileError(
                                f"Callable '{fname}' arg: expected '{expected_t}', got '{t}'"
                            )
                        codes.append(c)
                    return (f"{fname}({', '.join(codes)})", ret_t)

            real = self.function_aliases.get(fname, fname)

            if real == "print":
                raise TranspileError("print() cannot be used as a value")
            if real == "range":
                # range() used as a value — materialise into std::vector<int>
                args = node.args
                if len(args) == 1:
                    sc, _ = self.infer_expr(args[0], scope)
                    return (f"[&](){{std::vector<int> _r;for(int _i=0;_i<{sc};++_i)_r.push_back(_i);return _r;}}()", "list[int]")
                if len(args) == 2:
                    s0, _ = self.infer_expr(args[0], scope)
                    s1, _ = self.infer_expr(args[1], scope)
                    return (f"[&](){{std::vector<int> _r;for(int _i={s0};_i<{s1};++_i)_r.push_back(_i);return _r;}}()", "list[int]")
                if len(args) == 3:
                    s0, _ = self.infer_expr(args[0], scope)
                    s1, _ = self.infer_expr(args[1], scope)
                    s2, _ = self.infer_expr(args[2], scope)
                    return (f"[&](){{std::vector<int> _r;for(int _i={s0};_i<{s1};_i+={s2})_r.push_back(_i);return _r;}}()", "list[int]")
                raise TranspileError("range() supports 1–3 arguments")

            if real == "len":
                if len(node.args) != 1:
                    raise TranspileError("len() requires 1 argument")
                c, t = self.infer_expr(node.args[0], scope)
                if t in self.classes and "__len__" in self.classes[t].methods:
                    return (f"{c}.size()", "int")
                if not (t.startswith("list[") or self._is_map_type(t) or
                        t.startswith("set[") or t.startswith("deque[") or
                        t.startswith("frozenset[") or t == "string" or t == "bytes"):
                    raise TranspileError(f"len() not supported for '{t}'")
                return (f"(int){c}.size()", "int")

            if real == "isinstance":
                if len(node.args) != 2:
                    raise TranspileError("isinstance() requires 2 arguments")
                c, t = self.infer_expr(node.args[0], scope)
                cls_arg = node.args[1]
                if not isinstance(cls_arg, ast.Name):
                    raise TranspileError("isinstance() second arg must be a class name")
                cls_name = cls_arg.id
                # Runtime isinstance for variant types
                if t.startswith("variant["):
                    return (f"std::holds_alternative<{cls_name}>({c})", "bool")
                # Compile-time type check: walk the inheritance chain
                cur = t
                while cur is not None:
                    if cur == cls_name:
                        return ("true", "bool")
                    cur = self.classes[cur].parent if cur in self.classes else None
                return ("false", "bool")

            if real == "abs":
                if len(node.args) != 1:
                    raise TranspileError("abs() requires 1 argument")
                c, t = self.infer_expr(node.args[0], scope)
                if t not in ("int", "float"):
                    raise TranspileError(f"abs() requires int or float, got '{t}'")
                return (f"std::abs({c})", t)

            if real == "Counter":
                # Counter(iterable) → unordered_map<T, int>
                if len(node.args) == 0:
                    raise TranspileError("Counter() with no args needs an annotation: 'x: dict[T,int] = Counter()'")
                if len(node.args) == 1:
                    lc, lt = self.infer_expr(node.args[0], scope)
                    if not lt.startswith("list["):
                        raise TranspileError(f"Counter() argument must be a list, got '{lt}'")
                    elem_t = element_type(lt)
                    result_t = f"dict[{elem_t},int]"
                    return (f"[&](){{ {self.cpp_type(result_t)} _r; for(auto& _e:{lc}) _r[_e]++; return _r; }}()", result_t)
                raise TranspileError("Counter() requires 0 or 1 arguments")

            if real == "cast":
                if len(node.args) != 2:
                    raise TranspileError("cast() requires 2 arguments (type, value)")
                if not isinstance(node.args[0], ast.Name):
                    raise TranspileError("cast() first argument must be a type name")
                target_type = self.ann_to_type(node.args[0])
                c, t = self.infer_expr(node.args[1], scope)
                if t != "any":
                    raise TranspileError(f"cast() second argument must be 'Any', got '{t}'")
                return (f"std::any_cast<{self.cpp_type(target_type)}>({c})", target_type)

            if real in ("min", "max"):
                if len(node.args) == 1:
                    c, t = self.infer_expr(node.args[0], scope)
                    if not t.startswith("list[") and not t.startswith("deque["):
                        raise TranspileError(f"{real}(iterable): argument must be a list or deque, got '{t}'")
                    elem_t = t[5:-1] if t.startswith("list[") else t[6:-1]
                    if elem_t not in ("int", "float"):
                        raise TranspileError(f"{real}() only for numeric collections")
                    fn = "min_element" if real == "min" else "max_element"
                    kw_mn = {k.arg: k.value for k in node.keywords}
                    if "key" in kw_mn:
                        key_expected = f"func[{elem_t}->int]"
                        kc, _ = self.infer_expr(kw_mn["key"], scope, expected_type=key_expected)
                        cmp = f"[&](const auto& _a,const auto& _b){{return {kc}(_a)<{kc}(_b);}}"
                        return (f"[&](){{auto& _v={c};return *std::{fn}(_v.begin(),_v.end(),{cmp});}}()", elem_t)
                    return (f"(*std::{fn}({c}.begin(), {c}.end()))", elem_t)
                if len(node.args) == 2:
                    c0, t0 = self.infer_expr(node.args[0], scope)
                    c1, t1 = self.infer_expr(node.args[1], scope)
                    if t0 != t1:
                        raise TranspileError(f"{real}() arguments must have the same type, got '{t0}' and '{t1}'")
                    if t0 not in ("int", "float"):
                        raise TranspileError(f"{real}() requires int or float arguments")
                    return (f"std::{real}({c0}, {c1})", t0)
                raise TranspileError(f"{real}() requires 1 or 2 arguments")

            if real == "sorted":
                if len(node.args) != 1:
                    raise TranspileError("sorted() requires 1 positional argument")
                c, t = self.infer_expr(node.args[0], scope)
                if not t.startswith("list["):
                    raise TranspileError(f"sorted() requires a list, got '{t}'")
                # keyword args: key=, reverse=
                kw = {k.arg: k.value for k in node.keywords}
                reverse = False
                if "reverse" in kw:
                    rv = kw["reverse"]
                    if isinstance(rv, ast.Constant) and isinstance(rv.value, bool):
                        reverse = rv.value
                if "key" in kw:
                    # Pass element type as expected input type for key lambda
                    key_expected = f"func[{t[5:-1]}->int]"
                    kc, kt = self.infer_expr(kw["key"], scope, expected_type=key_expected)
                    cmp_dir = ">" if reverse else "<"
                    return (
                        f"[&](){{ auto _v={c}; std::sort(_v.begin(), _v.end(), "
                        f"[&](const auto& _a, const auto& _b){{return ({kc})(_a) {cmp_dir} ({kc})(_b);}});"
                        f" return _v; }}()", t
                    )
                if reverse:
                    return (f"[&](){{ auto _v={c}; std::sort(_v.rbegin(), _v.rend()); return _v; }}()", t)
                return (f"[&](){{ auto _v={c}; std::sort(_v.begin(), _v.end()); return _v; }}()", t)

            if real == "round":
                if len(node.args) not in (1, 2):
                    raise TranspileError("round() requires 1 or 2 arguments")
                c, t = self.infer_expr(node.args[0], scope)
                if t not in ("int", "float"):
                    raise TranspileError(f"round() requires int or float, got '{t}'")
                if len(node.args) == 1:
                    if t == "int":
                        return (c, "int")
                    return (f"(int)std::round({c})", "int")
                nc, nt = self.infer_expr(node.args[1], scope)
                if nt != "int":
                    raise TranspileError("round() second argument must be int")
                return (f"(std::round({c} * std::pow(10.0, {nc})) / std::pow(10.0, {nc}))", "float")

            if real == "pow":
                if len(node.args) != 2:
                    raise TranspileError("pow() requires 2 arguments")
                bc, bt = self.infer_expr(node.args[0], scope)
                ec, et = self.infer_expr(node.args[1], scope)
                if bt not in ("int", "float") or et not in ("int", "float"):
                    raise TranspileError(f"pow() requires numeric arguments")
                res = "float" if "float" in (bt, et) else "int"
                if res == "int":
                    return (f"((int)std::pow({bc}, {ec}))", "int")
                return (f"std::pow({bc}, {ec})", "float")

            if real == "chr":
                if len(node.args) != 1:
                    raise TranspileError("chr() requires 1 argument")
                c, t = self.infer_expr(node.args[0], scope)
                if t != "int":
                    raise TranspileError(f"chr() requires int, got '{t}'")
                return (f"std::string(1, (char)({c}))", "string")

            if real == "ord":
                if len(node.args) != 1:
                    raise TranspileError("ord() requires 1 argument")
                c, t = self.infer_expr(node.args[0], scope)
                if t != "string":
                    raise TranspileError(f"ord() requires str, got '{t}'")
                return (f"(int)(({c})[0])", "int")

            if real == "map":
                if len(node.args) != 2:
                    raise TranspileError("map() requires 2 arguments")
                lc, lt = self.infer_expr(node.args[1], scope)
                if not lt.startswith("list["):
                    raise TranspileError(f"map() second argument must be a list, got '{lt}'")
                elem_t = element_type(lt)
                # Lambda: infer arg type from list element type
                if isinstance(node.args[0], ast.Lambda):
                    lambda_expected = f"func[{elem_t}->?]"  # return type unknown
                    fc, ft = self.infer_expr(node.args[0], scope, expected_type=lambda_expected)
                    # Extract return type from func[T->R]
                    inner = ft[5:-1]
                    arrow = inner.rfind("->")
                    ret_t = inner[arrow + 2:] if arrow != -1 else "int"
                    result_t = f"list[{ret_t}]"
                    cpp_rt = self.cpp_type(result_t)
                    return (f"[&](){{ {cpp_rt} _r; for(auto& _e:{lc}) _r.push_back({fc}(_e)); return _r; }}()", result_t)
                # Named function
                if not isinstance(node.args[0], ast.Name):
                    raise TranspileError("map() function argument must be a named function or lambda")
                fname = node.args[0].id
                if fname not in self.functions:
                    raise TranspileError(f"map(): unknown function '{fname}'")
                f_ret, f_params = self.functions[fname]
                if len(f_params) != 1:
                    raise TranspileError(f"map(): '{fname}' must take exactly 1 argument")
                result_t = f"list[{f_ret}]"
                cpp_rt = self.cpp_type(result_t)
                cpp_fn = self.function_cpp_names.get(fname, fname)
                return (f"[&](){{ {cpp_rt} _r; for(auto& _e:{lc}) _r.push_back({cpp_fn}(_e)); return _r; }}()", result_t)

            if real == "filter":
                if len(node.args) != 2:
                    raise TranspileError("filter() requires 2 arguments")
                lc, lt = self.infer_expr(node.args[1], scope)
                if not lt.startswith("list["):
                    raise TranspileError(f"filter() second argument must be a list, got '{lt}'")
                elem_t = element_type(lt)
                # Lambda: infer arg type from list element type, return must be bool
                if isinstance(node.args[0], ast.Lambda):
                    lambda_expected = f"func[{elem_t}->bool]"
                    fc, _ = self.infer_expr(node.args[0], scope, expected_type=lambda_expected)
                    return (f"[&](){{ {self.cpp_type(lt)} _r; for(auto& _e:{lc}) if({fc}(_e)) _r.push_back(_e); return _r; }}()", lt)
                # Named function
                if not isinstance(node.args[0], ast.Name):
                    raise TranspileError("filter() function argument must be a named function or lambda")
                fname = node.args[0].id
                if fname not in self.functions:
                    raise TranspileError(f"filter(): unknown function '{fname}'")
                f_ret, f_params = self.functions[fname]
                if f_ret != "bool":
                    raise TranspileError(f"filter(): '{fname}' must return bool")
                if len(f_params) != 1:
                    raise TranspileError(f"filter(): '{fname}' must take exactly 1 argument")
                cpp_fn = self.function_cpp_names.get(fname, fname)
                return (f"[&](){{ {self.cpp_type(lt)} _r; for(auto& _e:{lc}) if({cpp_fn}(_e)) _r.push_back(_e); return _r; }}()", lt)

            if real == "sum":
                if len(node.args) not in (1, 2):
                    raise TranspileError("sum() requires 1 or 2 arguments")
                c, t = self.infer_expr(node.args[0], scope)
                if not t.startswith("list["):
                    raise TranspileError(f"sum() requires a list, got '{t}'")
                et = element_type(t)
                if et not in ("int", "float"):
                    raise TranspileError(f"sum() only for numeric lists, got list[{et}]")
                if len(node.args) == 2:
                    sc, st = self.infer_expr(node.args[1], scope)
                    return (f"[&](){{{self.cpp_type(et)} _s={sc};for(auto& _e:{c})_s+=_e;return _s;}}()", et)
                return (f"[&](){{{self.cpp_type(et)} _s=0;for(auto& _e:{c})_s+=_e;return _s;}}()", et)

            if real in ("any", "all"):
                if len(node.args) != 1:
                    raise TranspileError(f"{real}() requires 1 argument")
                c, t = self.infer_expr(node.args[0], scope)
                if not t.startswith("list[") or element_type(t) != "bool":
                    raise TranspileError(f"{real}() requires list[bool], got '{t}'")
                if real == "any":
                    return (f"[&](){{for(auto _e:{c}){{if(_e)return true;}}return false;}}()", "bool")
                else:
                    return (f"[&](){{for(auto _e:{c}){{if(!_e)return false;}}return true;}}()", "bool")

            if real == "input":
                if len(node.args) not in (0, 1):
                    raise TranspileError("input() takes 0 or 1 arguments")
                if node.args:
                    pc, pt = self.infer_expr(node.args[0], scope)
                    if pt != "string":
                        raise TranspileError("input() prompt must be a string")
                    return (f"[&](){{std::cout << {pc}; std::string _in; std::getline(std::cin, _in); return _in;}}()", "string")
                return (f"[&](){{std::string _in; std::getline(std::cin, _in); return _in;}}()", "string")

            if real in ("int", "float", "str"):
                if real == "int" and len(node.args) == 2:
                    c, t = self.infer_expr(node.args[0], scope)
                    bc, bt = self.infer_expr(node.args[1], scope)
                    if t != "string" or bt != "int":
                        raise TranspileError("int(s, base) requires a string and an int base")
                    return (f"std::stoi({c}, nullptr, {bc})", "int")
                if len(node.args) != 1:
                    raise TranspileError(f"{real}() requires 1 argument")
                c, t = self.infer_expr(node.args[0], scope)
                if real == "int":
                    if t == "string": return (f"std::stoi({c})", "int")
                    if t in ("int","float","bool"): return (f"(int)({c})", "int")
                    base_cls = self._class_of(t)
                    if base_cls and "__int__" in self.classes[base_cls].methods:
                        return (f"(int)({c})", "int")
                    raise TranspileError(f"Cannot cast '{t}' to int")
                if real == "float":
                    if t == "string": return (f"std::stod({c})", "float")
                    if t in ("int","float","bool"): return (f"(double)({c})", "float")
                    base_cls = self._class_of(t)
                    if base_cls and "__float__" in self.classes[base_cls].methods:
                        return (f"(double)({c})", "float")
                    raise TranspileError(f"Cannot cast '{t}' to float")
                # str
                if t == "string":    return (c, "string")
                if t == "bool":      return (f"({c} ? std::string(\"true\") : std::string(\"false\"))", "string")
                if t == "exception": return (f"std::string({c}.what())", "string")
                if t in ("int","float"): return (f"std::to_string({c})", "string")
                if t in self.classes and "__str__" in self.classes[t].methods:
                    return (f"{c}.to_string()", "string")
                raise TranspileError(f"Cannot cast '{t}' to str")

            if real == "deque":
                if not node.args:
                    raise TranspileError(
                        "deque() with no args needs an annotation: 'x: deque[T] = deque()'"
                    )
                if len(node.args) == 1:
                    c, t = self.infer_expr(node.args[0], scope)
                    if t.startswith("list["):
                        elem_t = element_type(t)
                    elif t.startswith("deque["):
                        elem_t = t[6:-1]
                    else:
                        raise TranspileError(f"deque() argument must be a list, got '{t}'")
                    deq_t = f"deque[{elem_t}]"
                    cpp_deq = self.cpp_type(deq_t)
                    return (f"[&](){{auto _src_={c}; return {cpp_deq}(_src_.begin(), _src_.end());}}()", deq_t)
                raise TranspileError("deque() takes 0 or 1 arguments")

            if real == "frozenset":
                if not node.args:
                    raise TranspileError("frozenset() requires an argument")
                if len(node.args) == 1:
                    c, t = self.infer_expr(node.args[0], scope)
                    if t.startswith("set["):
                        elem_t = t[4:-1]
                    elif t.startswith("frozenset["):
                        elem_t = t[10:-1]
                    elif t.startswith("list["):
                        elem_t = element_type(t)
                    else:
                        raise TranspileError(f"frozenset() arg must be set or list, got '{t}'")
                    fs_t = f"frozenset[{elem_t}]"
                    cpp_fs = self.cpp_type(fs_t)
                    return (f"[&](){{auto _src_={c}; return {cpp_fs}(_src_.begin(), _src_.end());}}()", fs_t)
                raise TranspileError("frozenset() takes 1 argument")

            if real in ("bytes", "bytearray"):
                if len(node.args) == 1:
                    c, t = self.infer_expr(node.args[0], scope)
                    if t == "int":
                        return (f"std::vector<uint8_t>({c}, 0)", "bytes")
                    if t.startswith("list[") and element_type(t) == "int":
                        return (
                            f"[&](){{auto _src_={c}; return std::vector<uint8_t>(_src_.begin(), _src_.end());}}()",
                            "bytes"
                        )
                    raise TranspileError(f"bytes() arg must be int or list[int], got '{t}'")
                raise TranspileError("bytes() requires 1 argument")

            if real == "list":
                if len(node.args) == 1:
                    c, t = self.infer_expr(node.args[0], scope)
                    if t.startswith("list["):
                        return (c, t)
                    if t.startswith("set["):
                        elem_t = t[4:-1]
                    elif t.startswith("frozenset["):
                        elem_t = t[10:-1]
                    elif t.startswith("deque["):
                        elem_t = t[6:-1]
                    else:
                        raise TranspileError(f"list() cannot convert '{t}' to list")
                    lt = f"list[{elem_t}]"
                    cpp_et = self.cpp_type(elem_t)
                    return (
                        f"[&](){{std::vector<{cpp_et}> _r_({c}.begin(),{c}.end());return _r_;}}()",
                        lt
                    )
                if not node.args:
                    raise TranspileError("list() with no args needs an annotation: 'x: list[T] = list()'")
                raise TranspileError("list() takes exactly 1 argument")

            if real == "set":
                if len(node.args) == 1:
                    c, t = self.infer_expr(node.args[0], scope)
                    if t.startswith("set["):
                        return (c, t)
                    if t.startswith("list["):
                        elem_t = t[5:-1]
                    elif t.startswith("frozenset["):
                        elem_t = t[10:-1]
                    else:
                        raise TranspileError(f"set() cannot convert '{t}' to set")
                    st = f"set[{elem_t}]"
                    cpp_et = self.cpp_type(elem_t)
                    return (
                        f"[&](){{std::unordered_set<{cpp_et}> _r_({c}.begin(),{c}.end());return _r_;}}()",
                        st
                    )
                if not node.args:
                    raise TranspileError("set() with no args needs an annotation: 'x: set[T] = set()'")
                raise TranspileError("set() takes exactly 1 argument")

            # Class constructor
            if real in self.classes:
                info = self.classes[real]
                if info.is_exception:
                    if len(node.args) != 1:
                        raise TranspileError(f"Exception '{real}' takes 1 string arg")
                    c, t = self.infer_expr(node.args[0], scope)
                    if t != "string":
                        raise TranspileError("Exception message must be a string")
                    return (f"{real}({c})", real)
                init = info.methods.get("__init__")
                params = init[1] if init else []
                n_req = sum(1 for _, d in params if d is None)
                if not (n_req <= len(node.args) <= len(params)):
                    raise TranspileError(
                        f"'{real}()' expects {n_req}–{len(params)} args, got {len(node.args)}"
                    )
                codes = []
                for i, arg in enumerate(node.args):
                    c, t = self.infer_expr(arg, scope)
                    if not self._types_compat(params[i][0], t):
                        raise TranspileError(
                            f"Constructor arg {i+1} of '{real}': expected '{params[i][0]}', got '{t}'"
                        )
                    codes.append(c)
                return (f"{real}({', '.join(codes)})", real)

            # itertools builtins
            if real == "chain":
                if not node.args:
                    raise TranspileError("chain() needs at least 1 argument")
                c0, t0 = self.infer_expr(node.args[0], scope)
                if not t0.startswith("list["):
                    raise TranspileError("chain() arguments must be lists")
                cpp_t = self.cpp_type(t0)
                body = f"[&](){{{cpp_t} _r_={c0};"
                for extra in node.args[1:]:
                    ec, _ = self.infer_expr(extra, scope)
                    body += f"for(auto& _e_:{ec})_r_.push_back(_e_);"
                body += "return _r_;}()"
                return (body, t0)
            if real == "product":
                if len(node.args) != 2:
                    raise TranspileError("product() needs exactly 2 arguments")
                c0, t0 = self.infer_expr(node.args[0], scope)
                c1, t1 = self.infer_expr(node.args[1], scope)
                e0 = element_type(t0)
                e1 = element_type(t1)
                result_t = f"list[tuple[{e0},{e1}]]"
                cpp_t = self.cpp_type(result_t)
                return (
                    f"[&](){{{cpp_t} _r_;for(auto& _a_:{c0})for(auto& _b_:{c1})"
                    f"_r_.push_back(std::make_tuple(_a_,_b_));return _r_;}}()",
                    result_t
                )

            if real not in self.functions:
                raise TranspileError(f"Call to unknown function '{fname}'")
            ret, params = self.functions[real]
            n_extra_call = (1 if self._has_kwargs.get(real, False) else 0)
            has_vararg = bool(params) and len(params) > n_extra_call and params[-(1 + n_extra_call)][0].startswith("vararg[")
            has_kwargs = self._has_kwargs.get(real, False)
            cpp_name = self.function_cpp_names.get(real, real)
            if has_vararg:
                vararg_idx = -(1 + n_extra_call)
                regular_params = params[:len(params) - 1 - n_extra_call]
                vararg_elem_t = params[vararg_idx][0][7:-1]
                n_req = sum(1 for _, d in regular_params if d is None)
                if len(node.args) < n_req:
                    raise TranspileError(
                        f"'{real}' expects at least {n_req} args, got {len(node.args)}"
                    )
                codes = []
                for i, arg in enumerate(node.args[:len(regular_params)]):
                    c, t = self.infer_expr(arg, scope, expected_type=regular_params[i][0])
                    if not self._types_compat(regular_params[i][0], t):
                        raise TranspileError(
                            f"Arg {i+1} of '{real}': expected '{regular_params[i][0]}', got '{t}'"
                        )
                    codes.append(c)
                vararg_codes = []
                for arg in node.args[len(regular_params):]:
                    c, t = self.infer_expr(arg, scope)
                    if not self._types_compat(vararg_elem_t, t):
                        raise TranspileError(
                            f"Vararg of '{real}': expected '{vararg_elem_t}', got '{t}'"
                        )
                    vararg_codes.append(c)
                codes.append("{" + ", ".join(vararg_codes) + "}")
                # Handle keyword args as kwargs dict for functions with **kwargs
                if has_kwargs and node.keywords:
                    kw_val_type = params[-1][0][12:-1] if params[-1][0].startswith("dict[") else "string"
                    kw_pairs = []
                    for k in node.keywords:
                        vc, vt = self.infer_expr(k.value, scope)
                        kw_pairs.append(f'{{"{k.arg}", {vc}}}')
                    codes.append(f"{self.cpp_type(f'dict[string,{kw_val_type}]')}{{{', '.join(kw_pairs)}}}")
                return (f"{cpp_name}({', '.join(codes)})", ret)
            n_req = sum(1 for _, d in params if d is None)
            # Handle **kwargs unpacking: f(**some_dict) → pass dict as kwargs arg
            double_starred = [k for k in node.keywords if k.arg is None]
            if double_starred:
                if not has_kwargs:
                    raise TranspileError(f"'{real}' does not accept **kwargs")
                if len(double_starred) > 1:
                    raise TranspileError("Only one ** unpacking per call is supported")
                kw_dict_c, kw_dict_t = self.infer_expr(double_starred[0].value, scope)
                kw_val_type = params[-1][0][12:-1] if params[-1][0].startswith("dict[") else "string"
                expected_kw_t = f"dict[string,{kw_val_type}]"
                if not types_compatible(expected_kw_t, kw_dict_t):
                    raise TranspileError(f"** unpacking requires {expected_kw_t}, got '{kw_dict_t}'")
                # Pass kwargs dict as the last argument
                regular_kw = {k.arg: k.value for k in node.keywords if k.arg is not None}
                if regular_kw:
                    raise TranspileError("Cannot mix ** unpacking with keyword arguments")
                call_args = list(node.args) + [double_starred[0].value]
                # Skip the regular keyword handling below, go straight to arg check
            # If function has **kwargs and regular keyword args, build kwargs dict inline
            elif has_kwargs and node.keywords:
                kw_val_type = params[-1][0][12:-1] if params[-1][0].startswith("dict[") else "string"
                kw_cpp_type = self.cpp_type(f"dict[string,{kw_val_type}]")
                codes = [self.infer_expr(a, scope)[0] for a in node.args]
                kw_pairs = []
                for k in node.keywords:
                    vc, vt = self.infer_expr(k.value, scope)
                    if not types_compatible(kw_val_type, vt):
                        raise TranspileError(f"kwargs '{k.arg}': expected '{kw_val_type}', got '{vt}'")
                    kw_pairs.append(f'{{"{k.arg}", {vc}}}')
                codes.append(f"{kw_cpp_type}{{{', '.join(kw_pairs)}}}")
                cpp_name = self.function_cpp_names.get(real, real)
                return (f"{cpp_name}({', '.join(codes)})", ret)
            elif node.keywords and real in self.function_param_names:
                param_names = self.function_param_names[real]
                kw_map = {k.arg: k.value for k in node.keywords}
                ordered: list = list(node.args)
                for i in range(len(node.args), len(params)):
                    pname = param_names[i] if i < len(param_names) else None
                    if pname and pname in kw_map:
                        ordered.append(kw_map[pname])
                    elif params[i][1] is not None:
                        ordered.append(params[i][1])  # default AST node
                    else:
                        raise TranspileError(f"'{real}': missing required arg '{pname}'")
                call_args = ordered
            else:
                call_args = node.args
            # Expand starred args: f(*lst) or f(a, *lst) — before length check
            if any(isinstance(a, ast.Starred) for a in call_args):
                pre_codes: List[str] = []
                starred_code = ""
                for a in call_args:
                    if isinstance(a, ast.Starred):
                        sc, st = self.infer_expr(a.value, scope)
                        if not st.startswith("list["):
                            raise TranspileError("* unpacking requires a list[T]")
                        starred_code = sc
                    else:
                        c, _ = self.infer_expr(a, scope)
                        pre_codes.append(c)
                n_expand = len(params) - len(pre_codes)
                expand_codes = [f"{starred_code}[{k}]" for k in range(n_expand)]
                all_codes = pre_codes + expand_codes
                return (f"{cpp_name}({', '.join(all_codes)})", ret)

            if not (n_req <= len(call_args) <= len(params)):
                raise TranspileError(
                    f"'{real}' expects {n_req}–{len(params)} args, got {len(call_args)}"
                )
            # Build TypeVar substitution from actual arg types
            tvar_sub: Dict[str, str] = {}
            codes = []
            for i, arg in enumerate(call_args):
                c, t = self.infer_expr(arg, scope, expected_type=params[i][0])
                expected = params[i][0]
                if expected in self.type_vars:
                    tvar_sub[expected] = t  # infer T from first occurrence
                elif not self._types_compat(expected, t):
                    raise TranspileError(
                        f"Arg {i+1} of '{fname}': expected '{expected}', got '{t}'"
                    )
                codes.append(c)
            actual_ret = self._substitute_typevars(ret, tvar_sub)
            return (f"{cpp_name}({', '.join(codes)})", actual_ret)

        # Attribute call: obj.method(...)
        if isinstance(node.func, ast.Attribute):
            attr = node.func.attr
            obj = node.func.value

            # self.method(...)
            if isinstance(obj, ast.Name) and obj.id == "self":
                if not self.current_class:
                    raise TranspileError("'self' used outside a class method")
                m = self.lookup_method(self.current_class.name, attr)
                if m is None:
                    raise TranspileError(
                        f"Class '{self.current_class.name}' has no method '{attr}'"
                    )
                ret, params = m
                codes = self._check_call_args(attr, params, node.args, scope)
                cpp_attr = DUNDER_CPP.get(attr, attr)
                return (f"this->{cpp_attr}({', '.join(codes)})", ret)

            # super().method(...)
            if (isinstance(obj, ast.Call) and isinstance(obj.func, ast.Name)
                    and obj.func.id == "super"):
                if not self.current_class or not self.current_class.parent:
                    raise TranspileError("super() used outside class or without parent")
                parent = self.current_class.parent
                m = self.lookup_method(parent, attr)
                if m is None:
                    raise TranspileError(f"Parent class '{parent}' has no method '{attr}'")
                ret, params = m
                codes = self._check_call_args(attr, params, node.args, scope)
                cpp_attr = DUNDER_CPP.get(attr, attr)
                return (f"{parent}::{cpp_attr}({', '.join(codes)})", ret)

            # Named object
            if isinstance(obj, ast.Name):
                obj_name = obj.id
                obj_type = scope.lookup(obj_name)

                # Unknown name → cross-module function or static/class method
                if obj_type is None:
                    # Check if it's a static/class method on a known class
                    if obj_name in self.classes:
                        m = self.lookup_method(obj_name, attr)
                        if m is not None:
                            ret, params = m
                            cpp_attr = DUNDER_CPP.get(attr, attr)
                            codes = self._check_call_args(attr, params, node.args, scope)
                            return (f"{obj_name}::{cpp_attr}({', '.join(codes)})", ret)
                    real = self.function_aliases.get(attr, attr)
                    if real not in self.functions:
                        raise TranspileError(f"Unknown function '{obj_name}.{attr}'")
                    ret, params = self.functions[real]
                    codes = self._check_call_args(real, params, node.args, scope)
                    cpp_name = self.function_cpp_names.get(real, real)
                    return (f"{cpp_name}({', '.join(codes)})", ret)

                # Instance method (including generic instances like Stack[int])
                base_cls = self._class_of(obj_type) if obj_type else None
                if base_cls:
                    m = self.lookup_method(base_cls, attr)
                    if m is None:
                        raise TranspileError(f"Class '{base_cls}' has no method '{attr}'")
                    ret_raw, params = m
                    sub = self._make_substitution(obj_type)
                    ret = self._substitute_typevars(ret_raw, sub)
                    cpp_attr = DUNDER_CPP.get(attr, attr)
                    # keyword arg reordering for methods
                    if node.keywords and attr in self.classes[base_cls].method_param_names:
                        pnames = self.classes[base_cls].method_param_names[attr]
                        kw_map = {k.arg: k.value for k in node.keywords}
                        ordered: list = list(node.args)
                        for i in range(len(node.args), len(pnames)):
                            pn = pnames[i]
                            if pn in kw_map:
                                ordered.append(kw_map[pn])
                        codes = self._check_call_args_generic(attr, params, ordered, scope, sub)
                    else:
                        codes = self._check_call_args_generic(attr, params, node.args, scope, sub)
                    return (f"{obj_name}.{cpp_attr}({', '.join(codes)})", ret)

                # string methods
                if obj_type == "string":
                    if attr == "format":
                        return self._string_format(obj, node.args, scope)
                    return self._string_method(obj_name, attr, node.args, scope)

                # set/frozenset method-form operators
                if obj_type and (obj_type.startswith("set[") or obj_type.startswith("frozenset[")):
                    elem_t = obj_type[4:-1] if obj_type.startswith("set[") else obj_type[10:-1]
                    result_t = f"set[{elem_t}]"
                    cpp_t = self.cpp_type(result_t)
                    if attr == "union":
                        if len(node.args) != 1:
                            raise TranspileError("set.union() needs 1 arg")
                        c, _ = self.infer_expr(node.args[0], scope)
                        return (f"[&](){{{cpp_t} _r_={obj_name};for(auto& _e_:{c})_r_.insert(_e_);return _r_;}}()", result_t)
                    if attr == "intersection":
                        if len(node.args) != 1:
                            raise TranspileError("set.intersection() needs 1 arg")
                        c, _ = self.infer_expr(node.args[0], scope)
                        return (f"[&](){{{cpp_t} _r_;for(auto& _e_:{obj_name})if({c}.count(_e_))_r_.insert(_e_);return _r_;}}()", result_t)
                    if attr == "difference":
                        if len(node.args) != 1:
                            raise TranspileError("set.difference() needs 1 arg")
                        c, _ = self.infer_expr(node.args[0], scope)
                        return (f"[&](){{{cpp_t} _r_={obj_name};for(auto& _e_:{c})_r_.erase(_e_);return _r_;}}()", result_t)
                    if attr == "symmetric_difference":
                        if len(node.args) != 1:
                            raise TranspileError("set.symmetric_difference() needs 1 arg")
                        c, _ = self.infer_expr(node.args[0], scope)
                        return (f"[&](){{{cpp_t} _r_;for(auto& _e_:{obj_name})if(!{c}.count(_e_))_r_.insert(_e_);for(auto& _e_:{c})if(!{obj_name}.count(_e_))_r_.insert(_e_);return _r_;}}()", result_t)
                    if attr == "issubset":
                        if len(node.args) != 1:
                            raise TranspileError("set.issubset() needs 1 arg")
                        c, _ = self.infer_expr(node.args[0], scope)
                        return (f"[&](){{for(auto& _e_:{obj_name})if(!{c}.count(_e_))return false;return true;}}()", "bool")
                    if attr == "issuperset":
                        if len(node.args) != 1:
                            raise TranspileError("set.issuperset() needs 1 arg")
                        c, _ = self.infer_expr(node.args[0], scope)
                        return (f"[&](){{for(auto& _e_:{c})if(!{obj_name}.count(_e_))return false;return true;}}()", "bool")
                    if attr == "isdisjoint":
                        if len(node.args) != 1:
                            raise TranspileError("set.isdisjoint() needs 1 arg")
                        c, _ = self.infer_expr(node.args[0], scope)
                        return (f"[&](){{for(auto& _e_:{obj_name})if({c}.count(_e_))return false;return true;}}()", "bool")
                    if attr == "copy":
                        if node.args:
                            raise TranspileError("set.copy() takes no args")
                        return (f"{cpp_t}({obj_name})", result_t)

                # dict methods
                if obj_type and obj_type.startswith("dict["):
                    return self._dict_method(obj_name, obj_type, attr, node.args, scope)

                # list methods as value
                if obj_type and obj_type.startswith("list["):
                    elem_t = element_type(obj_type)
                    if attr == "pop":
                        cpp_elem = self.cpp_type(elem_t)
                        if node.args:
                            ic, it = self.infer_expr(node.args[0], scope)
                            if it != "int":
                                raise TranspileError("list.pop() index must be int")
                            return (
                                f"[&]() -> {cpp_elem} {{ auto _t = {obj_name}[{ic}]; "
                                f"{obj_name}.erase({obj_name}.begin() + {ic}); return _t; }}()",
                                elem_t
                            )
                        return (
                            f"[&]() -> {cpp_elem} {{ auto _t = {obj_name}.back(); "
                            f"{obj_name}.pop_back(); return _t; }}()",
                            elem_t
                        )
                    if attr == "copy":
                        if node.args:
                            raise TranspileError("list.copy() takes no args")
                        return (f"{self.cpp_type(obj_type)}({obj_name})", obj_type)
                    if attr == "index":
                        if len(node.args) != 1:
                            raise TranspileError("list.index() needs 1 arg")
                        c, t = self.infer_expr(node.args[0], scope)
                        if t != elem_t:
                            raise TranspileError(f"list.index(): expected '{elem_t}', got '{t}'")
                        return (
                            f"(int)(std::find({obj_name}.begin(), {obj_name}.end(), {c}) - {obj_name}.begin())",
                            "int"
                        )
                    if attr == "count":
                        if len(node.args) != 1:
                            raise TranspileError("list.count() needs 1 arg")
                        c, t = self.infer_expr(node.args[0], scope)
                        if t != elem_t:
                            raise TranspileError(f"list.count(): expected '{elem_t}', got '{t}'")
                        return (
                            f"(int)std::count({obj_name}.begin(), {obj_name}.end(), {c})",
                            "int"
                        )
                    raise TranspileError(f"list method '.{attr}()' not supported as value")

                # bytes/bytearray methods
                if obj_type == "bytes":
                    if attr == "decode":
                        return (f"std::string({obj_name}.begin(),{obj_name}.end())", "string")
                    raise TranspileError(f"bytes method '.{attr}()' not supported")

                raise TranspileError(
                    f"Method call '.{attr}()' on type '{obj_type}' not supported as value"
                )

            # General expr.method(...) — includes generic instances
            oc, ot = self.infer_expr(obj, scope)
            base_cls = self._class_of(ot)
            if base_cls:
                m = self.lookup_method(base_cls, attr)
                if m is None:
                    raise TranspileError(f"Class '{base_cls}' has no method '{attr}'")
                ret_raw, params = m
                sub = self._make_substitution(ot)
                ret = self._substitute_typevars(ret_raw, sub)
                cpp_attr = DUNDER_CPP.get(attr, attr)
                if node.keywords and attr in self.classes[base_cls].method_param_names:
                    pnames = self.classes[base_cls].method_param_names[attr]
                    kw_map = {k.arg: k.value for k in node.keywords}
                    ordered: list = list(node.args)
                    for i in range(len(node.args), len(pnames)):
                        pn = pnames[i]
                        if pn in kw_map:
                            ordered.append(kw_map[pn])
                    codes = self._check_call_args_generic(attr, params, ordered, scope, sub)
                else:
                    codes = self._check_call_args_generic(attr, params, node.args, scope, sub)
                return (f"{oc}.{cpp_attr}({', '.join(codes)})", ret)
            if ot == "string":
                if attr == "format":
                    return self._string_format(obj, node.args, scope)
                return self._string_method(oc, attr, node.args, scope)
            if self._is_map_type(ot):
                return self._dict_method(oc, ot, attr, node.args, scope)
            if ot.startswith("set[") or ot.startswith("frozenset["):
                elem_t = ot[4:-1] if ot.startswith("set[") else ot[10:-1]
                result_t = f"set[{elem_t}]"
                cpp_t = self.cpp_type(result_t)
                if attr == "union":
                    if len(node.args) != 1: raise TranspileError("set.union() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _s_={oc};{cpp_t} _r_=_s_;for(auto& _e_:{c})_r_.insert(_e_);return _r_;}}()", result_t)
                if attr == "intersection":
                    if len(node.args) != 1: raise TranspileError("set.intersection() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _s_={oc};{cpp_t} _r_;for(auto& _e_:_s_)if({c}.count(_e_))_r_.insert(_e_);return _r_;}}()", result_t)
                if attr == "difference":
                    if len(node.args) != 1: raise TranspileError("set.difference() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _s_={oc};{cpp_t} _r_=_s_;for(auto& _e_:{c})_r_.erase(_e_);return _r_;}}()", result_t)
                if attr == "symmetric_difference":
                    if len(node.args) != 1: raise TranspileError("set.symmetric_difference() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _s_={oc};{cpp_t} _r_;for(auto& _e_:_s_)if(!{c}.count(_e_))_r_.insert(_e_);for(auto& _e_:{c})if(!_s_.count(_e_))_r_.insert(_e_);return _r_;}}()", result_t)
                if attr == "issubset":
                    if len(node.args) != 1: raise TranspileError("set.issubset() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _s_={oc};for(auto& _e_:_s_)if(!{c}.count(_e_))return false;return true;}}()", "bool")
                if attr == "issuperset":
                    if len(node.args) != 1: raise TranspileError("set.issuperset() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _s_={oc};for(auto& _e_:{c})if(!_s_.count(_e_))return false;return true;}}()", "bool")
                if attr == "isdisjoint":
                    if len(node.args) != 1: raise TranspileError("set.isdisjoint() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _s_={oc};for(auto& _e_:_s_)if({c}.count(_e_))return false;return true;}}()", "bool")
                if attr == "copy":
                    if node.args: raise TranspileError("set.copy() takes no args")
                    return (f"{cpp_t}({oc})", result_t)
            if ot.startswith("list["):
                elem_t = ot[5:-1]
                if attr == "append":
                    if len(node.args) != 1: raise TranspileError("list.append() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"{oc}.push_back({c})", "void")
                if attr == "pop":
                    if not node.args:
                        return (f"[&](){{auto _t={oc}.back();{oc}.pop_back();return _t;}}()", elem_t)
                    ic, _ = self.infer_expr(node.args[0], scope)
                    return (f"[&](){{auto _t={oc}[{ic}];{oc}.erase({oc}.begin()+({ic}));return _t;}}()", elem_t)
                if attr in ("clear", "reverse"):
                    fn = "clear" if attr == "clear" else "reverse"
                    if attr == "reverse":
                        return (f"std::reverse({oc}.begin(),{oc}.end())", "void")
                    return (f"{oc}.{fn}()", "void")
                if attr == "sort":
                    return (f"std::sort({oc}.begin(),{oc}.end())", "void")
                if attr == "extend":
                    if len(node.args) != 1: raise TranspileError("list.extend() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"{oc}.insert({oc}.end(),{c}.begin(),{c}.end())", "void")
                if attr == "insert":
                    if len(node.args) != 2: raise TranspileError("list.insert() needs 2 args")
                    ic, _ = self.infer_expr(node.args[0], scope)
                    vc, _ = self.infer_expr(node.args[1], scope)
                    return (f"{oc}.insert({oc}.begin()+({ic}),{vc})", "void")
                if attr == "remove":
                    if len(node.args) != 1: raise TranspileError("list.remove() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"{{auto _it_=std::find({oc}.begin(),{oc}.end(),{c});if(_it_!={oc}.end()){oc}.erase(_it_);}}", "void")
            if ot.startswith("deque["):
                elem_t = ot[6:-1]
                if attr == "append":
                    if len(node.args) != 1: raise TranspileError("deque.append() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"{oc}.push_back({c})", "void")
                if attr == "appendleft":
                    if len(node.args) != 1: raise TranspileError("deque.appendleft() needs 1 arg")
                    c, _ = self.infer_expr(node.args[0], scope)
                    return (f"{oc}.push_front({c})", "void")
                if attr in ("pop", "popleft"):
                    fn = "back" if attr == "pop" else "front"
                    rm = "pop_back" if attr == "pop" else "pop_front"
                    return (f"[&](){{auto _t={oc}.{fn}();{oc}.{rm}();return _t;}}()", elem_t)
                if attr == "clear":
                    return (f"{oc}.clear()", "void")
            if ot == "bytes":
                if attr == "decode":
                    return (f"std::string({oc}.begin(),{oc}.end())", "string")

        raise TranspileError("Unsupported call expression")

    def _check_call_args(self, name: str, params: list, args, scope: Scope) -> List[str]:
        n_req = sum(1 for _, d in params if d is None)
        if not (n_req <= len(args) <= len(params)):
            raise TranspileError(
                f"'{name}' expects {n_req}–{len(params)} args, got {len(args)}"
            )
        codes = []
        for i, arg in enumerate(args):
            c, t = self.infer_expr(arg, scope, expected_type=params[i][0])
            if not self._types_compat(params[i][0], t):
                raise TranspileError(
                    f"Arg {i+1} of '{name}': expected '{params[i][0]}', got '{t}'"
                )
            codes.append(c)
        return codes

    def _check_call_args_generic(self, name: str, params: list, args, scope: Scope,
                                  sub: Dict[str, str]) -> List[str]:
        """Like _check_call_args but substitutes TypeVars in expected types."""
        n_req = sum(1 for _, d in params if d is None)
        if not (n_req <= len(args) <= len(params)):
            raise TranspileError(
                f"'{name}' expects {n_req}–{len(params)} args, got {len(args)}"
            )
        codes = []
        for i, arg in enumerate(args):
            expected = self._substitute_typevars(params[i][0], sub)
            c, t = self.infer_expr(arg, scope, expected_type=expected)
            if expected not in self.type_vars and not self._types_compat(expected, t):
                raise TranspileError(
                    f"Arg {i+1} of '{name}': expected '{expected}', got '{t}'"
                )
            codes.append(c)
        return codes

    # ---- statements ----

    def transpile_assign(self, node: ast.Assign, scope: Scope):
        # Multiple targets: a = b = expr  → emit as sequential assignments
        if len(node.targets) > 1:
            vc, vt = self.infer_expr(node.value, scope)
            for target in node.targets:
                if not isinstance(target, ast.Name):
                    raise TranspileError("Multiple assignment targets must be simple names")
                name = target.id
                existing = scope.lookup(name)
                if existing is None:
                    scope.define(name, vt)
                    self.emit(f"{self.cpp_type(vt)} {name} = {vc};")
                else:
                    if existing != vt:
                        raise TranspileError(
                            f"Cannot assign '{vt}' to '{name}' of type '{existing}'"
                        )
                    self.emit(f"{name} = {vc};")
            return
        target = node.targets[0]

        # self.x = expr
        if (isinstance(target, ast.Attribute) and
                isinstance(target.value, ast.Name) and target.value.id == "self"):
            if not self.current_class:
                raise TranspileError("'self' used outside a class method")
            attr = target.attr
            # Property setter takes priority over field
            if attr in self.current_class.property_setters:
                vc, vt = self.infer_expr(node.value, scope)
                expected = self.current_class.property_setters[attr]
                if not self._types_compat(expected, vt):
                    raise TranspileError(
                        f"Property setter '{attr}': expected '{expected}', got '{vt}'"
                    )
                self.emit(f"this->set_{attr}({vc});")
                return
            ft = self.lookup_field(self.current_class.name, attr)
            if ft is None:
                raise TranspileError(
                    f"Class '{self.current_class.name}' has no field '{attr}'"
                )
            # Empty collection literals: use field type's default constructor
            if isinstance(node.value, ast.List) and not node.value.elts:
                self.emit(f"this->{attr} = {self.cpp_type(ft)}{{}};")
                return
            if isinstance(node.value, ast.Dict) and not node.value.keys:
                self.emit(f"this->{attr} = {self.cpp_type(ft)}{{}};")
                return
            # [[] for _ in iter] when field type provides element context
            if (isinstance(node.value, ast.ListComp) and
                    isinstance(node.value.elt, ast.List) and
                    not node.value.elt.elts and ft.startswith("list[")):
                vc, vt = self._infer_list_comp_hinted(node.value, scope, ft[5:-1])
                self.emit(f"this->{attr} = {vc};")
                return
            vc, vt = self.infer_expr(node.value, scope)
            if not self._types_compat(ft, vt):
                raise TranspileError(f"Cannot assign '{vt}' to field '{attr}' of type '{ft}'")
            self.emit(f"this->{attr} = {vc};")
            return

        # obj.attr = val (non-self attribute assignment, including property setters)
        if isinstance(target, ast.Attribute):
            attr = target.attr
            # ClassName.class_var = val
            if isinstance(target.value, ast.Name):
                cls_name = target.value.id
                if cls_name in self.classes:
                    cv = self.classes[cls_name].class_vars.get(attr)
                    if cv is not None:
                        vc, vt = self.infer_expr(node.value, scope)
                        self.emit(f"{cls_name}::{attr} = {vc};")
                        return
            oc, ot = self.infer_expr(target.value, scope)
            vc, vt = self.infer_expr(node.value, scope)
            if ot in self.classes:
                obj_info = self.classes[ot]
                if attr in obj_info.property_setters:
                    expected = obj_info.property_setters[attr]
                    if not self._types_compat(expected, vt):
                        raise TranspileError(
                            f"Property setter '{attr}': expected '{expected}', got '{vt}'"
                        )
                    self.emit(f"{oc}.set_{attr}({vc});")
                    return
                ft = self.lookup_field(ot, attr)
                if ft is not None:
                    if not self._types_compat(ft, vt):
                        raise TranspileError(
                            f"Cannot assign '{vt}' to field '{attr}' of type '{ft}'"
                        )
                    self.emit(f"{oc}.{attr} = {vc};")
                    return
                cv = obj_info.class_vars.get(attr)
                if cv is not None:
                    self.emit(f"{ot}::{attr} = {vc};")
                    return
            raise TranspileError(f"Attribute assignment '.{attr}' not supported on type '{ot}'")

        # d[k] = v  or  lst[i] = v  or  lst[a:b] = new_list
        if isinstance(target, ast.Subscript):
            oc, ot = self.infer_expr(target.value, scope)
            # Slice assignment: lst[a:b] = new_list
            if isinstance(target.slice, ast.Slice):
                if not ot.startswith("list["):
                    raise TranspileError(f"Slice assignment only supported for lists, got '{ot}'")
                # Handle empty list literal [] for slice clearing
                if isinstance(node.value, ast.List) and not node.value.elts:
                    vc = f"{self.cpp_type(ot)}{{}}"
                    vt = ot
                else:
                    vc, vt = self.infer_expr(node.value, scope)
                if vt != ot:
                    raise TranspileError(f"Slice assignment: expected '{ot}', got '{vt}'")
                lo = "0"; hi = f"(int){oc}.size()"
                if target.slice.lower:
                    lo, _ = self.infer_expr(target.slice.lower, scope)
                if target.slice.upper:
                    hi, _ = self.infer_expr(target.slice.upper, scope)
                if target.slice.step:
                    step_c, _ = self.infer_expr(target.slice.step, scope)
                    src_ref = f"const auto& _src={vc}" if vt.startswith("list[") else f"auto _src={vc}"
                    self.emit(f"[&](){{ auto& _v={oc}; {src_ref}; ")
                    self.emit(f"  int _lo={lo}; int _hi={hi}; int _st={step_c}; ")
                    self.emit(f"  int _n=(int)_v.size(); ")
                    self.emit(f"  if(_lo<0)_lo=std::max(0,_n+_lo); else _lo=std::min(_lo,_n); ")
                    self.emit(f"  if(_hi<0)_hi=std::max(0,_n+_hi); else _hi=std::min(_hi,_n); ")
                    self.emit(f"  if(_st>0){{ for(int _i=_lo,_j=0;_i<_hi&&_j<(int)_src.size();_i+=_st,_j++) _v[_i]=_src[_j]; }}")
                    self.emit(f"  else if(_st<0){{ for(int _i=_lo,_j=0;_i>_hi&&_i>=0&&_j<(int)_src.size();_i+=_st,_j++) _v[_i]=_src[_j]; }}")
                    self.emit(f" }}();")
                    return
                src_ref = f"const auto& _src={vc}" if vt.startswith("list[") else f"auto _src={vc}"
                self.emit(f"[&](){{ auto& _v={oc}; {src_ref}; int _lo={lo}; int _hi={hi}; ")
                self.emit(f"  _v.erase(_v.begin()+_lo, _v.begin()+_hi); ")
                self.emit(f"  _v.insert(_v.begin()+_lo, _src.begin(), _src.end()); }}();")
                return
            vc, vt = self.infer_expr(node.value, scope)
            ic, it = self.infer_expr(target.slice, scope)
            if self._is_map_type(ot):
                inner = ot[5:-1] if ot.startswith("dict[") else ot[12:-1]
                parts = split_type_args(inner)
                k_t, v_t = parts[0], parts[1]
                if it != k_t:
                    raise TranspileError(f"Dict key must be '{k_t}', got '{it}'")
                if vt != v_t:
                    raise TranspileError(f"Dict value must be '{v_t}', got '{vt}'")
                self.emit(f"{oc}[{ic}] = {vc};")
                return
            if ot.startswith("list["):
                if it != "int":
                    raise TranspileError("List index must be int")
                elem_t = element_type(ot)
                if vt != elem_t:
                    raise TranspileError(f"List element must be '{elem_t}', got '{vt}'")
                self.emit(f"{oc}[{ic}] = {vc};")
                return
            # User class with __setitem__
            base_cls = self._class_of(ot)
            if base_cls and "__setitem__" in self.classes[base_cls].methods:
                self.emit(f"{oc}.set_item({ic}, {vc});")
                return
            raise TranspileError(f"Subscript assignment not supported for type '{ot}'")

        # Tuple unpacking: a, b = expr_returning_tuple
        if isinstance(target, ast.Tuple):
            vc, vt = self.infer_expr(node.value, scope)
            if not vt.startswith("tuple["):
                raise TranspileError(f"Cannot unpack non-tuple type '{vt}'")
            parts = split_type_args(vt[6:-1])
            elts = target.elts
            if len(elts) != len(parts):
                raise TranspileError(
                    f"Tuple unpack: expected {len(parts)} targets, got {len(elts)}"
                )
            if not all(isinstance(e, ast.Name) for e in elts):
                raise TranspileError("Tuple unpack targets must be simple names")
            names = [e.id for e in elts]
            all_declared = all(scope.lookup(n) is not None for n in names)
            none_declared = all(scope.lookup(n) is None for n in names)
            if none_declared:
                for n, t in zip(names, parts):
                    scope.define(n, t)
                self.emit(f"auto [{', '.join(names)}] = {vc};")
            elif all_declared:
                for n, t in zip(names, parts):
                    existing = scope.lookup(n)
                    if existing != t:
                        raise TranspileError(
                            f"Tuple unpack: '{n}' has type '{existing}', expected '{t}'"
                        )
                self.emit(f"std::tie({', '.join(names)}) = {vc};")
            else:
                raise TranspileError(
                    "Tuple unpack: all targets must be either all new or all declared"
                )
            return

        if not isinstance(target, ast.Name):
            raise TranspileError("Only simple assignments x = expr supported")
        name = target.id
        safe = self._safe_name(name)
        vc, vt = self.infer_expr(node.value, scope)
        existing = scope.lookup(name)
        if existing is None:
            scope.define(name, vt)
            self.emit(f"{self.cpp_type(vt)} {safe} = {vc};")
        else:
            if vt == "nullopt" and existing.startswith("optional["):
                self.emit(f"{safe} = std::nullopt;")
                return
            # optional[T] assigned to T (after is-not-None check) → implicit dereference
            if vt.startswith("optional[") and existing == vt[9:-1]:
                self.emit(f"{safe} = *({vc});")
                return
            if not self._types_compat(existing, vt):
                raise TranspileError(
                    f"Cannot assign '{vt}' to '{name}' of type '{existing}'"
                )
            self.emit(f"{safe} = {vc};")

    def transpile_ann_assign(self, node: ast.AnnAssign, scope: Scope):
        # self.attr: T = expr in __init__ — treat as field init and auto-register field
        if isinstance(node.target, ast.Attribute) and isinstance(node.target.value, ast.Name) and node.target.value.id == "self":
            attr = node.target.attr
            if node.value is None:
                return  # self.attr: T (declaration only, field already declared at class level)
            # Use annotation type for empty collection inference
            try:
                ann_type = self.ann_to_type(node.annotation)
            except TranspileError:
                ann_type = None
            vc, vt = self.infer_expr(node.value, scope, expected_type=ann_type)
            if self.current_class:
                ft = self.lookup_field(self.current_class.name, attr)
                if ft is None and ann_type:
                    # Auto-register field discovered in __init__
                    self.current_class.fields[attr] = ann_type
                    ft = ann_type
                if ft and not self._types_compat(ft, vt):
                    raise TranspileError(f"Cannot assign '{vt}' to field '{attr}' of type '{ft}'")
            self.emit(f"this->{attr} = {vc};")
            return
        if not isinstance(node.target, ast.Name):
            raise TranspileError("Only 'x: T = expr' supported")
        name = node.target.id
        safe = self._safe_name(name)
        var_type = self.ann_to_type(node.annotation)
        if node.value is None:
            scope.define(name, var_type)
            self.emit(f"{self.cpp_type(var_type)} {safe};")
            return
        # Empty collection literals: [] {} need type annotation context
        if isinstance(node.value, ast.List) and not node.value.elts:
            scope.define(name, var_type)
            self.emit(f"{self.cpp_type(var_type)} {safe};")
            return
        if isinstance(node.value, ast.Dict) and not node.value.keys:
            scope.define(name, var_type)
            self.emit(f"{self.cpp_type(var_type)} {safe};")
            return
        # Special-case container constructors that can't be inferred standalone
        if isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Name):
            ctor = self.function_aliases.get(node.value.func.id, node.value.func.id)
            if ctor == "deque" and not node.value.args:
                scope.define(name, var_type)
                self.emit(f"{self.cpp_type(var_type)} {safe};")
                return
            if ctor == "OrderedDict":
                scope.define(name, var_type)
                self.emit(f"{self.cpp_type(var_type)} {safe};")
                return
            if ctor == "defaultdict":
                # ignore the factory argument, map to an empty dict
                scope.define(name, var_type)
                self.emit(f"{self.cpp_type(var_type)} {safe};")
                return
            if ctor == "Counter":
                if not node.value.args:
                    scope.define(name, var_type)
                    self.emit(f"{self.cpp_type(var_type)} {safe};")
                    return
                if len(node.value.args) == 1:
                    lc, lt = self.infer_expr(node.value.args[0], scope)
                    if not lt.startswith("list["):
                        raise TranspileError(f"Counter() argument must be a list, got '{lt}'")
                    scope.define(name, var_type)
                    self.emit(f"{self.cpp_type(var_type)} {safe};")
                    self.emit(f"for (auto& _cnt_e_ : {lc}) {safe}[_cnt_e_]++;")
                    return
        # [[] for _ in iter] with annotated type providing element context
        if (isinstance(node.value, ast.ListComp) and
                isinstance(node.value.elt, ast.List) and
                not node.value.elt.elts and var_type.startswith("list[")):
            vc, vt = self._infer_list_comp_hinted(node.value, scope, var_type[5:-1])
            scope.define(name, var_type)
            self.emit(f"{self.cpp_type(var_type)} {safe} = {vc};")
            return
        vc, vt = self.infer_expr(node.value, scope, expected_type=var_type)
        if vt == "nullopt" and var_type.startswith("optional["):
            scope.define(name, var_type)
            self.emit(f"{self.cpp_type(var_type)} {safe} = {vc};")
            return
        # optional[T] assigned to T (after is-not-None check) → implicit dereference
        if vt.startswith("optional[") and var_type == vt[9:-1]:
            scope.define(name, var_type)
            self.emit(f"{self.cpp_type(var_type)} {safe} = *({vc});")
            return
        if not self._types_compat(var_type, vt):
            raise TranspileError(f"Annotated type '{var_type}' does not match '{vt}'")
        scope.define(name, var_type)
        # Use auto for polymorphic assignment to avoid object slicing
        if (var_type in self.classes and vt in self.classes
                and self._is_subclass(vt, var_type) and var_type != vt):
            self.emit(f"auto {safe} = {vc};")
        else:
            self.emit(f"{self.cpp_type(var_type)} {safe} = {vc};")

    def transpile_aug_assign(self, node: ast.AugAssign, scope: Scope):
        op_map = {ast.Add:"+=", ast.Sub:"-=", ast.Mult:"*=",
                  ast.Div:"/=", ast.Mod:"%=", ast.FloorDiv:"/="}

        # lst[i] op= v  or  d[k] op= v
        if isinstance(node.target, ast.Subscript):
            oc, ot = self.infer_expr(node.target.value, scope)
            ic, it = self.infer_expr(node.target.slice, scope)
            vc, vt = self.infer_expr(node.value, scope)
            op_str = op_map.get(type(node.op))
            if not op_str:
                raise TranspileError(f"Unsupported augmented op: {type(node.op).__name__}")
            if ot.startswith("list["):
                elem_t = element_type(ot)
                if it != "int":
                    raise TranspileError("List index must be int")
                if vt not in ("int", "float") or elem_t not in ("int", "float"):
                    raise TranspileError(f"'{op_str}' only for numeric list elements")
                self.emit(f"{oc}[{ic}] {op_str} {vc};")
                return
            if self._is_map_type(ot):
                inner = ot[5:-1] if ot.startswith("dict[") else ot[12:-1]
                k_t, v_t = split_type_args(inner)
                if it != k_t:
                    raise TranspileError(f"Dict key must be '{k_t}', got '{it}'")
                if vt not in ("int", "float") or v_t not in ("int", "float"):
                    raise TranspileError(f"'{op_str}' only for numeric dict values")
                self.emit(f"{oc}[{ic}] {op_str} {vc};")
                return
            raise TranspileError(f"Subscript augmented assignment not supported for '{ot}'")

        if not isinstance(node.target, ast.Name):
            raise TranspileError("Only 'x op= expr' and 'obj[i] op= expr' supported")
        name = node.target.id
        safe = self._safe_name(name)
        existing = scope.lookup(name)
        if existing is None:
            raise TranspileError(f"Augmented assignment to undefined '{name}'")
        vc, vt = self.infer_expr(node.value, scope)
        op = node.op
        if isinstance(op, ast.Add) and existing == "string" and vt == "string":
            self.emit(f"{safe} += {vc};")
            return
        # Set in-place operators: |= &= -= ^=
        if existing.startswith("set[") or existing.startswith("frozenset["):
            if isinstance(op, ast.BitOr):
                self.emit(f"for (auto& _e_ : {vc}) {safe}.insert(_e_);")
                return
            if isinstance(op, ast.BitAnd):
                self.emit(f"{{ {self.cpp_type(existing)} _tmp_; for (auto& _e_ : {safe}) if ({vc}.count(_e_)) _tmp_.insert(_e_); {safe} = std::move(_tmp_); }}")
                return
            if isinstance(op, ast.Sub):
                self.emit(f"for (auto& _e_ : {vc}) {safe}.erase(_e_);")
                return
            if isinstance(op, ast.BitXor):
                self.emit(f"for (auto& _e_ : {vc}) {{ if ({safe}.count(_e_)) {safe}.erase(_e_); else {safe}.insert(_e_); }}")
                return
        op_str = op_map.get(type(op))
        if not op_str:
            raise TranspileError(f"Unsupported augmented op: {type(op).__name__}")
        if existing not in ("int","float") or vt not in ("int","float"):
            # Check for user-defined in-place or binary operator
            if existing in self.classes:
                inplace_dunder = {
                    "+=":"__iadd__", "-=":"__isub__", "*=":"__imul__",
                    "/=":"__itruediv__", "%=":"__imod__",
                }
                binary_dunder = {
                    "+=":"__add__", "-=":"__sub__", "*=":"__mul__",
                    "/=":"__truediv__", "%=":"__mod__",
                }
                dn = inplace_dunder.get(op_str)
                if dn and self.lookup_method(existing, dn):
                    self.emit(f"{safe} {op_str} {vc};")
                    return
                fb = binary_dunder.get(op_str)
                if fb:
                    m = self.lookup_method(existing, fb)
                    if m and m[1] and m[1][0][0] == vt:
                        self.emit(f"{safe} = {safe} {op_str[0]} {vc};")
                        return
            raise TranspileError(f"'{op_str}' only for numeric types")
        self.emit(f"{safe} {op_str} {vc};")

    def transpile_if(self, node: ast.If, scope: Scope, func_return: Optional[str] = None):
        # Detect isinstance(x, T) where x: variant[...] → scope-narrowing
        narrowing = None
        if (isinstance(node.test, ast.Call) and
                isinstance(node.test.func, ast.Name) and
                node.test.func.id == "isinstance" and
                len(node.test.args) == 2 and
                isinstance(node.test.args[0], ast.Name) and
                isinstance(node.test.args[1], ast.Name)):
            var_name = node.test.args[0].id
            cls_name = node.test.args[1].id
            var_type = scope.lookup(var_name)
            if var_type and var_type.startswith("variant["):
                self._narrow_counter += 1
                temp = f"_viper_var_{var_name}_{self._narrow_counter}_"
                narrowing = (var_name, cls_name, temp)
                self.emit(f"auto& {temp} = {var_name};")

        if narrowing:
            var_name, cls_name, temp = narrowing
            tc = f"std::holds_alternative<{cls_name}>({temp})"
        else:
            tc, tt = self.infer_expr(node.test, scope)
            if tt != "bool":
                raise TranspileError("if condition must be bool")

        self.emit(f"if ({tc}) " + "{")
        self.indent()
        inner_scope = Scope(parent=scope)
        if narrowing:
            var_name, cls_name, temp = narrowing
            self.emit(f"{cls_name} {var_name} = std::get<{cls_name}>({temp});")
            inner_scope.define(var_name, cls_name)
        for s in node.body:
            self.transpile_stmt(s, inner_scope, func_return)
        self.dedent()
        self.emit("}")
        if node.orelse:
            self.emit("else {")
            self.indent()
            for s in node.orelse:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")

    def transpile_while(self, node: ast.While, scope: Scope, func_return: Optional[str] = None):
        tc, tt = self.infer_expr(node.test, scope)
        if tt != "bool":
            raise TranspileError("while condition must be bool")
        self.emit(f"while ({tc}) " + "{")
        self.indent()
        for s in node.body:
            self.transpile_stmt(s, scope, func_return)
        self.dedent()
        self.emit("}")
        if node.orelse:
            # else runs when loop exits without break (simplified: always runs)
            self.emit("{")
            self.indent()
            for s in node.orelse:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")

    def transpile_for(self, node: ast.For, scope: Scope, func_return: Optional[str] = None):
        self._emit_for_body(node, scope, func_return)
        if node.orelse:
            self.emit("{")
            self.indent()
            for s in node.orelse:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")

    def _emit_for_body(self, node: ast.For, scope: Scope, func_return: Optional[str] = None):
        # Tuple target: enumerate(), zip(), dict.items()
        if isinstance(node.target, ast.Tuple):
            self._transpile_for_tuple(node, scope, func_return)
            return

        if not isinstance(node.target, ast.Name):
            raise TranspileError("for target must be a simple name or (a, b) tuple")
        var = node.target.id

        # range(...)
        if (isinstance(node.iter, ast.Call) and
                isinstance(node.iter.func, ast.Name) and
                node.iter.func.id == "range"):
            args = node.iter.args
            if len(args) == 1:
                sc, st = self.infer_expr(args[0], scope)
                if st != "int": raise TranspileError("range() needs int")
                start, stop, step = "0", sc, "1"
            elif len(args) == 2:
                a0, t0 = self.infer_expr(args[0], scope)
                a1, t1 = self.infer_expr(args[1], scope)
                if t0 != "int" or t1 != "int": raise TranspileError("range() needs int")
                start, stop, step = a0, a1, "1"
            elif len(args) == 3:
                a0, t0 = self.infer_expr(args[0], scope)
                a1, t1 = self.infer_expr(args[1], scope)
                a2, t2 = self.infer_expr(args[2], scope)
                if t0 != "int" or t1 != "int" or t2 != "int":
                    raise TranspileError("range() needs int")
                start, stop, step = a0, a1, a2
            else:
                raise TranspileError("range() supports 1–3 args")
            scope.define(var, "int")
            self.emit(f"for (int {var} = {start}; {var} < {stop}; {var} += {step})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # dict.keys() — iterate over keys
        if (isinstance(node.iter, ast.Call) and
                isinstance(node.iter.func, ast.Attribute) and
                node.iter.func.attr == "keys"):
            dc, dt = self.infer_expr(node.iter.func.value, scope)
            if not dt.startswith("dict["):
                raise TranspileError(".keys() requires a dict")
            k_t = split_type_args(dt[5:-1])[0]
            scope.define(var, k_t)
            self.emit(f"for (auto& [{var}, _viper_val_] : {dc})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # dict.values() — iterate over values
        if (isinstance(node.iter, ast.Call) and
                isinstance(node.iter.func, ast.Attribute) and
                node.iter.func.attr == "values"):
            dc, dt = self.infer_expr(node.iter.func.value, scope)
            if not dt.startswith("dict["):
                raise TranspileError(".values() requires a dict")
            v_t = split_type_args(dt[5:-1])[1]
            scope.define(var, v_t)
            self.emit(f"for (auto& [_viper_key_, {var}] : {dc})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # reversed(lst)
        if (isinstance(node.iter, ast.Call) and
                isinstance(node.iter.func, ast.Name) and
                node.iter.func.id == "reversed"):
            if len(node.iter.args) != 1:
                raise TranspileError("reversed() requires 1 argument")
            rc, rt = self.infer_expr(node.iter.args[0], scope)
            if not rt.startswith("list["):
                raise TranspileError(f"reversed() requires a list, got '{rt}'")
            elem_t = element_type(rt)
            scope.define(var, elem_t)
            cpp_e = self.cpp_type(elem_t)
            self.emit(f"for (auto _it_={rc}.rbegin(); _it_!={rc}.rend(); ++_it_)" + " {")
            self.indent()
            self.emit(f"{cpp_e} {var} = *_it_;")
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        ic, it = self.infer_expr(node.iter, scope)

        # list iteration
        if it.startswith("list["):
            elem_t = element_type(it)
            scope.define(var, elem_t)
            self.emit(f"for ({self.cpp_type(elem_t)} {var} : {ic})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # direct map key iteration: for k in d
        if self._is_map_type(it):
            inner = it[5:-1] if it.startswith("dict[") else it[12:-1]
            k_t = split_type_args(inner)[0]
            scope.define(var, k_t)
            self.emit(f"for (auto& [{var}, _viper_val_] : {ic})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # set/frozenset iteration
        if it.startswith("set[") or it.startswith("frozenset["):
            elem_t = it[4:-1] if it.startswith("set[") else it[10:-1]
            scope.define(var, elem_t)
            self.emit(f"for ({self.cpp_type(elem_t)} {var} : {ic})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # deque iteration
        if it.startswith("deque["):
            elem_t = it[6:-1]
            scope.define(var, elem_t)
            self.emit(f"for ({self.cpp_type(elem_t)} {var} : {ic})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # bytes iteration
        if it == "bytes":
            scope.define(var, "int")
            self.emit(f"for (uint8_t {var} : {ic})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # string iteration: for c in "hello"
        if it == "string":
            scope.define(var, "string")
            self.emit(f"for (char _viper_c_ : std::string({ic}))" + " {")
            self.indent()
            self.emit(f"std::string {var}(1, _viper_c_);")
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # user-class iterator with __next__
        base_cls = self._class_of(it)
        if base_cls and "__next__" in self.classes[base_cls].methods:
            next_ret = self.classes[base_cls].methods["__next__"][0]
            cpp_next_t = self.cpp_type(next_ret)
            scope.define(var, next_ret)
            self._needs_stop_iteration = True
            self.emit("{")
            self.indent()
            self.emit(f"auto _it_obj_ = {ic};")
            self.emit("while (true) {")
            self.indent()
            self.emit(f"{cpp_next_t} {var};")
            self.emit(f"try {{ {var} = _it_obj_._next_(); }}")
            self.emit("catch (const _StopIteration_&) { break; }")
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            self.dedent()
            self.emit("}")
            return

        raise TranspileError("for must iterate over range(), a list, a dict, a set, enumerate(), or zip()")

    def _for_orelse(self, node: ast.For, scope: Scope, func_return: Optional[str] = None):
        if node.orelse:
            self.emit("{")
            self.indent()
            for s in node.orelse:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")

    def _transpile_for_tuple(self, node: ast.For, scope: Scope,
                              func_return: Optional[str] = None):
        elts = node.target.elts
        if not all(isinstance(e, ast.Name) for e in elts):
            raise TranspileError("for tuple target must be simple names")
        # zip(l1, l2, l3, ...) — handle before the len==2 check
        if (isinstance(node.iter, ast.Call) and
                isinstance(node.iter.func, ast.Name) and
                node.iter.func.id == "zip"):
            zargs = node.iter.args
            n = len(zargs)
            if n < 2:
                raise TranspileError("zip() requires at least 2 iterables")
            if len(elts) != n:
                raise TranspileError(f"zip() has {n} iterables but for-target has {len(elts)} vars")
            arg_codes, arg_elem_ts = [], []
            for a in zargs:
                ac, at = self.infer_expr(a, scope)
                if not at.startswith("list["):
                    raise TranspileError("zip() requires list iterables")
                arg_codes.append(ac)
                arg_elem_ts.append(element_type(at))
            var_names = [e.id for e in elts]
            for v, t in zip(var_names, arg_elem_ts):
                scope.define(v, t)
            # min of all sizes
            min_sz = f"(int){arg_codes[0]}.size()"
            for ac in arg_codes[1:]:
                min_sz = f"(int)std::min((size_t){min_sz}, {ac}.size())"
            self.emit(f"for (int _i_ = 0; _i_ < {min_sz}; ++_i_)" + " {")
            self.indent()
            for v, t, ac in zip(var_names, arg_elem_ts, arg_codes):
                self.emit(f"{self.cpp_type(t)} {v} = {ac}[_i_];")
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return
        if len(elts) != 2:
            raise TranspileError("for tuple target must be exactly 2 simple names (use zip for more)")
        var0, var1 = elts[0].id, elts[1].id

        # enumerate(lst) / enumerate(lst, start=N)
        if (isinstance(node.iter, ast.Call) and
                isinstance(node.iter.func, ast.Name) and
                node.iter.func.id == "enumerate"):
            call = node.iter
            if len(call.args) not in (1, 2):
                raise TranspileError("enumerate() takes 1 or 2 arguments")
            lc, lt = self.infer_expr(call.args[0], scope)
            if not lt.startswith("list["):
                raise TranspileError("enumerate() requires a list")
            # start value: second positional arg or start= keyword
            start = "0"
            if len(call.args) == 2:
                sc, _ = self.infer_expr(call.args[1], scope)
                start = sc
            else:
                kw = {k.arg: k.value for k in call.keywords}
                if "start" in kw:
                    sc, _ = self.infer_expr(kw["start"], scope)
                    start = sc
            elem_t = element_type(lt)
            scope.define(var0, "int")
            scope.define(var1, elem_t)
            self.emit(f"for (int {var0} = {start}; {var0} < (int){lc}.size() + ({start}); ++{var0})" + " {")
            self.indent()
            self.emit(f"{self.cpp_type(elem_t)} {var1} = {lc}[{var0} - ({start})];")
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        # dict.items()
        if (isinstance(node.iter, ast.Call) and
                isinstance(node.iter.func, ast.Attribute) and
                node.iter.func.attr == "items"):
            dc, dt = self.infer_expr(node.iter.func.value, scope)
            if not self._is_map_type(dt):
                raise TranspileError(".items() requires a dict or OrderedDict")
            inner = dt[5:-1] if dt.startswith("dict[") else dt[12:-1]
            k_t, v_t = split_type_args(inner)
            scope.define(var0, k_t)
            scope.define(var1, v_t)
            self.emit(f"for (auto& [{var0}, {var1}] : {dc})" + " {")
            self.indent()
            for s in node.body:
                self.transpile_stmt(s, scope, func_return)
            self.dedent()
            self.emit("}")
            return

        raise TranspileError(
            "for (a, b) in ... requires enumerate(), zip(...), or dict.items()"
        )

    def transpile_expr_stmt(self, node: ast.Expr, scope: Scope):
        value = node.value
        if isinstance(value, ast.Constant) and isinstance(value.value, str):
            return

        if isinstance(value, ast.Yield):
            if self._generator_yield_type is None:
                raise TranspileError("yield outside generator function")
            if value.value is None:
                raise TranspileError("bare yield not supported; use 'yield expr'")
            c, t = self.infer_expr(value.value, scope)
            if not self._types_compat(self._generator_yield_type, t):
                raise TranspileError(
                    f"yield type '{t}' does not match generator type '{self._generator_yield_type}'"
                )
            self.emit(f"_result.push_back({c});")
            return

        if isinstance(value, ast.Call):
            # print(...)
            if isinstance(value.func, ast.Name) and value.func.id == "print":
                kw = {k.arg: k.value for k in value.keywords}
                sep = '" "'; end = 'std::endl'
                if "sep" in kw:
                    sc, _ = self.infer_expr(kw["sep"], scope)
                    sep = sc
                if "end" in kw:
                    ec, et = self.infer_expr(kw["end"], scope)
                    end = f'"\\n"' if ec == '"\\n"' else ec
                    end = f"std::endl" if end in ('"\\n"', r'"\n"') else end
                pieces = []
                for i, arg in enumerate(value.args):
                    c, t = self.infer_expr(arg, scope)
                    if t == "exception":
                        c = f"{c}.what()"
                    elif t not in ("int", "float", "string"):
                        c = self._to_string_expr(c, t)
                    if i > 0:
                        pieces.append(sep)
                    pieces.append(c)
                if not pieces:
                    if end == "std::endl":
                        self.emit("std::cout << std::endl;")
                    else:
                        self.emit(f"std::cout << {end};")
                else:
                    tail = " << std::endl" if end == "std::endl" else f" << {end}"
                    self.emit("std::cout << " + " << ".join(pieces) + tail + ";")
                return

            if isinstance(value.func, ast.Attribute):
                obj = value.func.value
                method = value.func.attr

                # self.method(...)
                if isinstance(obj, ast.Name) and obj.id == "self":
                    if not self.current_class:
                        raise TranspileError("'self' outside a class method")
                    m = self.lookup_method(self.current_class.name, method)
                    if m is None:
                        raise TranspileError(
                            f"Class '{self.current_class.name}' has no method '{method}'"
                        )
                    ret, params = m
                    codes = self._check_call_args(method, params, value.args, scope)
                    cpp_method = DUNDER_CPP.get(method, method)
                    self.emit(f"this->{cpp_method}({', '.join(codes)});")
                    return

                if isinstance(obj, ast.Name):
                    obj_name = obj.id
                    obj_type = scope.lookup(obj_name)

                    # list methods
                    if obj_type and obj_type.startswith("list["):
                        elem_t = element_type(obj_type)
                        if method == "append":
                            if len(value.args) != 1:
                                raise TranspileError("list.append() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if not self._types_compat(elem_t, t):
                                raise TranspileError(
                                    f"list.append(): expected '{elem_t}', got '{t}'"
                                )
                            self.emit(f"{obj_name}.push_back({c});")
                            return
                        if method == "pop":
                            if value.args:
                                ic, it = self.infer_expr(value.args[0], scope)
                                if it != "int":
                                    raise TranspileError("list.pop() index must be int")
                                self.emit(f"{obj_name}.erase({obj_name}.begin() + {ic});")
                            else:
                                self.emit(f"{obj_name}.pop_back();")
                            return
                        if method == "remove":
                            if len(value.args) != 1:
                                raise TranspileError("list.remove() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != elem_t:
                                raise TranspileError(f"list.remove(): expected '{elem_t}', got '{t}'")
                            self.emit(f"{{ auto _it_ = std::find({obj_name}.begin(), {obj_name}.end(), {c}); if (_it_ != {obj_name}.end()) {obj_name}.erase(_it_); }}")
                            return
                        if method == "clear":
                            self.emit(f"{obj_name}.clear();")
                            return
                        if method == "extend":
                            if len(value.args) != 1:
                                raise TranspileError("list.extend() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != obj_type:
                                raise TranspileError(f"list.extend(): expected '{obj_type}', got '{t}'")
                            self.emit(f"{obj_name}.insert({obj_name}.end(), {c}.begin(), {c}.end());")
                            return
                        if method == "reverse":
                            if value.args:
                                raise TranspileError("list.reverse() takes no args")
                            self.emit(f"std::reverse({obj_name}.begin(), {obj_name}.end());")
                            return
                        if method == "sort":
                            if value.args:
                                raise TranspileError("list.sort() takes no args")
                            self.emit(f"std::sort({obj_name}.begin(), {obj_name}.end());")
                            return
                        if method == "insert":
                            if len(value.args) != 2:
                                raise TranspileError("list.insert() needs 2 args")
                            ic, it = self.infer_expr(value.args[0], scope)
                            vc, vt = self.infer_expr(value.args[1], scope)
                            if it != "int":
                                raise TranspileError("list.insert() index must be int")
                            if vt != elem_t:
                                raise TranspileError(f"list.insert(): expected '{elem_t}', got '{vt}'")
                            self.emit(f"{obj_name}.insert({obj_name}.begin() + {ic}, {vc});")
                            return
                        raise TranspileError(f"list method '.{method}()' not supported")

                    # set methods
                    if obj_type and obj_type.startswith("set["):
                        elem_t = obj_type[4:-1]
                        if method == "add":
                            if len(value.args) != 1:
                                raise TranspileError("set.add() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != elem_t:
                                raise TranspileError(f"set.add(): expected '{elem_t}', got '{t}'")
                            self.emit(f"{obj_name}.insert({c});")
                            return
                        if method in ("remove", "discard"):
                            if len(value.args) != 1:
                                raise TranspileError(f"set.{method}() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != elem_t:
                                raise TranspileError(f"set.{method}(): expected '{elem_t}', got '{t}'")
                            self.emit(f"{obj_name}.erase({c});")
                            return
                        if method == "clear":
                            self.emit(f"{obj_name}.clear();")
                            return
                        raise TranspileError(f"set method '.{method}()' not supported")

                    # deque methods
                    if obj_type and obj_type.startswith("deque["):
                        elem_t = obj_type[6:-1]
                        if method == "append":
                            if len(value.args) != 1:
                                raise TranspileError("deque.append() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != elem_t:
                                raise TranspileError(f"deque.append(): expected '{elem_t}', got '{t}'")
                            self.emit(f"{obj_name}.push_back({c});")
                            return
                        if method == "appendleft":
                            if len(value.args) != 1:
                                raise TranspileError("deque.appendleft() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != elem_t:
                                raise TranspileError(f"deque.appendleft(): expected '{elem_t}', got '{t}'")
                            self.emit(f"{obj_name}.push_front({c});")
                            return
                        if method == "pop":
                            if value.args:
                                raise TranspileError("deque.pop() takes no args")
                            self.emit(f"{obj_name}.pop_back();")
                            return
                        if method == "popleft":
                            if value.args:
                                raise TranspileError("deque.popleft() takes no args")
                            self.emit(f"{obj_name}.pop_front();")
                            return
                        if method == "clear":
                            self.emit(f"{obj_name}.clear();")
                            return
                        if method == "extend":
                            if len(value.args) != 1:
                                raise TranspileError("deque.extend() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if not (t == obj_type or t == f"list[{elem_t}]"):
                                raise TranspileError(f"deque.extend(): incompatible type '{t}'")
                            self.emit(f"{obj_name}.insert({obj_name}.end(), {c}.begin(), {c}.end());")
                            return
                        if method == "extendleft":
                            if len(value.args) != 1:
                                raise TranspileError("deque.extendleft() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if not (t == obj_type or t == f"list[{elem_t}]"):
                                raise TranspileError(f"deque.extendleft(): incompatible type '{t}'")
                            self.emit(f"for (auto _it_ = {c}.rbegin(); _it_ != {c}.rend(); ++_it_) {obj_name}.push_front(*_it_);")
                            return
                        if method == "remove":
                            if len(value.args) != 1:
                                raise TranspileError("deque.remove() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != elem_t:
                                raise TranspileError(f"deque.remove(): expected '{elem_t}', got '{t}'")
                            self.emit(f"{{ auto _it_ = std::find({obj_name}.begin(), {obj_name}.end(), {c}); if (_it_ != {obj_name}.end()) {obj_name}.erase(_it_); }}")
                            return
                        if method == "rotate":
                            if len(value.args) != 1:
                                raise TranspileError("deque.rotate() needs 1 arg")
                            nc, nt = self.infer_expr(value.args[0], scope)
                            if nt != "int":
                                raise TranspileError("deque.rotate() argument must be int")
                            self.emit(
                                f"{{auto _n_={nc};"
                                f"if(_n_>0)std::rotate({obj_name}.begin(),{obj_name}.end()-_n_,{obj_name}.end());"
                                f"else if(_n_<0)std::rotate({obj_name}.begin(),{obj_name}.begin()-_n_,{obj_name}.end());}}"
                            )
                            return
                        raise TranspileError(f"deque method '.{method}()' not supported")

                    # dict methods
                    if obj_type and obj_type.startswith("dict["):
                        if method == "clear":
                            self.emit(f"{obj_name}.clear();")
                            return
                        if method == "update":
                            if len(value.args) != 1:
                                raise TranspileError("dict.update() needs 1 arg")
                            c, t = self.infer_expr(value.args[0], scope)
                            if t != obj_type:
                                raise TranspileError(f"dict.update(): expected '{obj_type}', got '{t}'")
                            self.emit(f"for (auto& [_k_, _v_] : {c}) " + "{")
                            self.indent()
                            self.emit(f"{obj_name}[_k_] = _v_;")
                            self.dedent()
                            self.emit("}")
                            return
                        if method == "pop":
                            if not value.args:
                                raise TranspileError("dict.pop() requires at least 1 arg")
                            kc, _ = self.infer_expr(value.args[0], scope)
                            self.emit(f"{obj_name}.erase({kc});")
                            return
                        raise TranspileError(f"dict method '.{method}()' not supported")

                    # instance method as statement (including generic instances)
                    base_cls = self._class_of(obj_type) if obj_type else None
                    if base_cls:
                        m = self.lookup_method(base_cls, method)
                        if m is None:
                            raise TranspileError(
                                f"Class '{base_cls}' has no method '{method}'"
                            )
                        ret, params = m
                        sub = self._make_substitution(obj_type)
                        # keyword arg reordering for method statements
                        if value.keywords and method in self.classes[base_cls].method_param_names:
                            pnames = self.classes[base_cls].method_param_names[method]
                            kw_map = {k.arg: k.value for k in value.keywords}
                            ordered: list = list(value.args)
                            for i in range(len(value.args), len(pnames)):
                                pn = pnames[i]
                                if pn in kw_map:
                                    ordered.append(kw_map[pn])
                            stmt_args = ordered
                        else:
                            stmt_args = value.args
                        codes = self._check_call_args_generic(method, params, stmt_args, scope, sub)
                        cpp_method = DUNDER_CPP.get(method, method)
                        self.emit(f"{obj_name}.{cpp_method}({', '.join(codes)});")
                        return

            call_code, _ = self.infer_expr(value, scope)
            self.emit(f"{call_code};")
            return

        raise TranspileError(f"Unsupported expression statement: {type(value).__name__}")

    def transpile_return(self, node: ast.Return, scope: Scope, ret_type: str):
        # Inside a generator, any return means "done collecting"
        if self._generator_yield_type is not None:
            if node.value is not None:
                raise TranspileError("return with value not supported in generator")
            self.emit("return _result;")
            return
        if node.value is None:
            if ret_type != "void":
                raise TranspileError("return without value in non-void function")
            self.emit("return;")
            return
        # return [] / return {} — use the declared return type
        if isinstance(node.value, ast.List) and not node.value.elts:
            if not ret_type.startswith("list["):
                raise TranspileError("Cannot return [] from non-list function")
            self.emit(f"return {self.cpp_type(ret_type)}{{}};")
            return
        if isinstance(node.value, ast.Dict) and not node.value.keys:
            if not ret_type.startswith("dict["):
                raise TranspileError("Cannot return {{}} from non-dict function")
            self.emit(f"return {self.cpp_type(ret_type)}{{}};")
            return
        if isinstance(node.value, ast.Tuple) and ret_type.startswith("tuple["):
            parts = split_type_args(ret_type[6:-1])
            if len(parts) != len(node.value.elts):
                raise TranspileError("Return tuple size mismatch")
            codes = []
            for elt, expected in zip(node.value.elts, parts):
                c, t = self.infer_expr(elt, scope)
                if t != expected:
                    raise TranspileError(
                        f"Return tuple element: expected '{expected}', got '{t}'"
                    )
                codes.append(c)
            self.emit(f"return std::make_tuple({', '.join(codes)});")
            return
        c, t = self.infer_expr(node.value, scope, expected_type=ret_type)
        if t == "nullopt" and ret_type.startswith("optional["):
            self.emit("return std::nullopt;")
            return
        # optional[T] returned where T expected → dereference
        if t.startswith("optional[") and t[9:-1] == ret_type:
            self.emit(f"return *{c};")
            return
        if t != ret_type and not self._types_compat(ret_type, t):
            raise TranspileError(f"Return type '{t}' does not match declared '{ret_type}'")
        self.emit(f"return {c};")

    def transpile_raise(self, node: ast.Raise, scope: Scope):
        if node.exc is None:
            self.emit("throw;")
            return
        if isinstance(node.exc, ast.Call) and isinstance(node.exc.func, ast.Name):
            exc_name = node.exc.func.id
            cpp_exc = self.exc_cpp_type(exc_name)
            if cpp_exc == "_StopIteration_":
                self._needs_stop_iteration = True
                self.emit("throw _StopIteration_{};")
                return
            msg = '""'
            if node.exc.args:
                c, t = self.infer_expr(node.exc.args[0], scope)
                if t != "string":
                    raise TranspileError("Exception message must be a string")
                msg = c
            self.emit(f'throw {cpp_exc}({msg});')
            return
        if isinstance(node.exc, ast.Name):
            c, _ = self.infer_expr(node.exc, scope)
            self.emit(f"throw {c};")
            return
        raise TranspileError("Unsupported raise expression")

    def transpile_try(self, node: ast.Try, scope: Scope, func_return: Optional[str] = None):
        self.emit("try {")
        self.indent()
        for s in node.body:
            self.transpile_stmt(s, scope, func_return)
        self.dedent()
        self.emit("}")

        for handler in node.handlers:
            if handler.type is None:
                exc_names = [None]
            elif isinstance(handler.type, ast.Name):
                exc_names = [handler.type.id]
            elif isinstance(handler.type, ast.Tuple):
                exc_names = [e.id for e in handler.type.elts if isinstance(e, ast.Name)]
            else:
                raise TranspileError("Unsupported except clause")

            for i, exc_name in enumerate(exc_names):
                if exc_name is None:
                    self.emit("catch (...) {")
                else:
                    cpp_exc = self.exc_cpp_type(exc_name)
                    var_part = f" {handler.name}" if handler.name and i == 0 else ""
                    self.emit(f"catch (const {cpp_exc}&{var_part}) " + "{")
                self.indent()
                h_scope = Scope(parent=scope)
                if handler.name and i == 0:
                    h_scope.define(handler.name, "exception")
                for s in handler.body:
                    self.transpile_stmt(s, h_scope, func_return)
                self.dedent()
                self.emit("}")

        if node.orelse:
            for s in node.orelse:
                self.transpile_stmt(s, scope, func_return)
        if node.finalbody:
            for s in node.finalbody:
                self.transpile_stmt(s, scope, func_return)

    def transpile_delete(self, node: ast.Delete, scope: Scope):
        for target in node.targets:
            if isinstance(target, ast.Subscript):
                oc, ot = self.infer_expr(target.value, scope)
                if self._is_map_type(ot):
                    ic, it = self.infer_expr(target.slice, scope)
                    inner = ot[5:-1] if ot.startswith("dict[") else ot[12:-1]
                    k_t = split_type_args(inner)[0]
                    if it != k_t:
                        raise TranspileError(f"del dict: key must be '{k_t}', got '{it}'")
                    self.emit(f"{oc}.erase({ic});")
                else:
                    raise TranspileError(f"del not supported for type '{ot}'")
            elif isinstance(target, ast.Name):
                existing = scope.lookup(target.id)
                if existing and existing.startswith("optional["):
                    self.emit(f"{target.id} = std::nullopt;")
                # else: no-op (C++ can't delete local vars)
            else:
                raise TranspileError("del only supported for subscript (d[k]) or variable")

    def _to_string_expr(self, c: str, t: str) -> str:
        """Return a C++ expression of type std::string for value c of type t."""
        if t == "string":
            return c
        if t == "bool":
            return f'std::string({c} ? "true" : "false")'
        if t in ("int", "float"):
            return f"std::to_string({c})"
        if self._class_of(t):
            return f"{c}.to_string()"
        if t.startswith("list["):
            elem_t = element_type(t)
            elem_str = self._to_string_expr("_e_", elem_t)
            return (
                f'[&](){{std::string _r_="[";bool _f_=true;'
                f'for(auto& _e_:{c}){{if(!_f_)_r_+=", ";_f_=false;_r_+={elem_str};}}'
                f'_r_+="]";return _r_;}}()'
            )
        if t.startswith("dict["):
            parts = split_type_args(t[5:-1])
            k_t, v_t = parts[0], parts[1]
            k_str = self._to_string_expr("_k_", k_t)
            v_str = self._to_string_expr("_v_", v_t)
            return (
                f'[&](){{std::string _r_="{{";bool _f_=true;'
                f'for(auto& [_k_,_v_]:{c}){{if(!_f_)_r_+=", ";_f_=false;_r_+={k_str}+": "+{v_str};}}'
                f'_r_+="}}";return _r_;}}()'
            )
        if t.startswith("set["):
            elem_t = t[4:-1]
            elem_str = self._to_string_expr("_e_", elem_t)
            return (
                f'[&](){{std::string _r_="{{";bool _f_=true;'
                f'for(auto& _e_:{c}){{if(!_f_)_r_+=", ";_f_=false;_r_+={elem_str};}}'
                f'_r_+="}}";return _r_;}}()'
            )
        if t.startswith("deque["):
            elem_t = t[6:-1]
            elem_str = self._to_string_expr("_e_", elem_t)
            return (
                f'[&](){{std::string _r_="deque([";bool _f_=true;'
                f'for(auto& _e_:{c}){{if(!_f_)_r_+=", ";_f_=false;_r_+={elem_str};}}'
                f'_r_+="])";return _r_;}}()'
            )
        if t.startswith("frozenset["):
            elem_t = t[10:-1]
            elem_str = self._to_string_expr("_e_", elem_t)
            return (
                f'[&](){{std::string _r_="frozenset({{";bool _f_=true;'
                f'for(auto& _e_:{c}){{if(!_f_)_r_+=", ";_f_=false;_r_+={elem_str};}}'
                f'_r_+="}})" ;return _r_;}}()'
            )
        if t == "bytes":
            return (
                f'[&](){{std::string _r_="b\'";'
                f'for(auto _b_:{c}){{_r_+="\\\\x";'
                f'char _hex_[3];snprintf(_hex_,3,"%02x",(unsigned)_b_);_r_+=_hex_;}}'
                f'_r_+="\'";return _r_;}}()'
            )
        if t.startswith("variant["):
            parts = split_type_args(t[8:-1])
            cases = " ".join(
                f"if (std::holds_alternative<{self.cpp_type(p)}>({c})) "
                f"return {self._to_string_expr(f'std::get<{self.cpp_type(p)}>({c})', p)};"
                for p in parts
            )
            return f"[&](){{ {cases} return std::string(); }}()"
        return c  # fallback: let C++ handle it

    def _format_spec_cpp(self, c: str, t: str, spec: str) -> str:
        """Convert a Python format spec string to a C++ std::string expression."""
        import re
        # :.Nf  :.Ne  :.Ng  (precision + type)
        m = re.match(r'^\.(\d+)([fFeEgG])$', spec)
        if m:
            prec, fc = m.group(1), m.group(2).lower()
            if fc == 'f':
                manip = f"std::fixed<<std::setprecision({prec})"
            elif fc == 'e':
                manip = f"std::scientific<<std::setprecision({prec})"
            else:  # g
                manip = f"std::setprecision({prec})"
            return (f"[&](){{std::ostringstream _ss;_ss<<{manip}<<({c});return _ss.str();}}()")
        # :[fill]align[width][type]  e.g.  >10  <10s  010d
        m = re.match(r'^([<>^]?)(\d+)([sdf]?)$', spec)
        if m:
            align, width, fc = m.group(1), m.group(2), m.group(3)
            align_cpp = {'<': 'std::left', '>': 'std::right', '^': 'std::internal'}.get(align, 'std::right')
            return (f"[&](){{std::ostringstream _ss;_ss<<{align_cpp}<<std::setw({width})<<({c});return _ss.str();}}()")
        # fallback: default conversion
        return self._to_string_expr(c, t)

    def _string_method(self, obj: str, attr: str, args: list, scope: Scope) -> Tuple[str, str]:
        if attr == "upper":
            if args:
                raise TranspileError("str.upper() takes no arguments")
            return (f"[&](){{std::string _s={obj}; std::transform(_s.begin(),_s.end(),_s.begin(),::toupper); return _s;}}()", "string")
        if attr == "lower":
            if args:
                raise TranspileError("str.lower() takes no arguments")
            return (f"[&](){{std::string _s={obj}; std::transform(_s.begin(),_s.end(),_s.begin(),::tolower); return _s;}}()", "string")
        if attr == "find":
            if len(args) != 1:
                raise TranspileError("str.find() requires 1 argument")
            ac, at = self.infer_expr(args[0], scope)
            if at != "string":
                raise TranspileError("str.find() argument must be a string")
            return (f"[&](){{std::string _s={obj}; auto _p=_s.find({ac}); return _p==std::string::npos ? -1 : (int)_p;}}()", "int")
        if attr == "startswith":
            if len(args) != 1:
                raise TranspileError("str.startswith() requires 1 argument")
            ac, at = self.infer_expr(args[0], scope)
            if at != "string":
                raise TranspileError("str.startswith() argument must be a string")
            return (f"[&](){{std::string _s={obj}; std::string _p={ac}; return _s.compare(0, _p.size(), _p) == 0;}}()", "bool")
        if attr == "endswith":
            if len(args) != 1:
                raise TranspileError("str.endswith() requires 1 argument")
            ac, at = self.infer_expr(args[0], scope)
            if at != "string":
                raise TranspileError("str.endswith() argument must be a string")
            return (f"[&](){{std::string _s={obj}; std::string _x={ac}; return _s.size()>=_x.size()&&_s.compare(_s.size()-_x.size(),_x.size(),_x)==0;}}()", "bool")
        if attr == "strip":
            if args:
                raise TranspileError("str.strip() takes no arguments")
            return (
                f"[&](){{ std::string _s={obj}; "
                f"size_t _a=_s.find_first_not_of(\" \\t\\n\\r\\f\\v\"); "
                f"size_t _b=_s.find_last_not_of(\" \\t\\n\\r\\f\\v\"); "
                f"return (_a==std::string::npos) ? std::string(\"\") : _s.substr(_a,_b-_a+1); }}()",
                "string"
            )
        if attr == "lstrip":
            if args:
                raise TranspileError("str.lstrip() takes no arguments")
            return (
                f"[&](){{ std::string _s={obj}; "
                f"size_t _a=_s.find_first_not_of(\" \\t\\n\\r\\f\\v\"); "
                f"return (_a==std::string::npos) ? std::string(\"\") : _s.substr(_a); }}()",
                "string"
            )
        if attr == "rstrip":
            if args:
                raise TranspileError("str.rstrip() takes no arguments")
            return (
                f"[&](){{ std::string _s={obj}; "
                f"size_t _b=_s.find_last_not_of(\" \\t\\n\\r\\f\\v\"); "
                f"return (_b==std::string::npos) ? std::string(\"\") : _s.substr(0,_b+1); }}()",
                "string"
            )
        if attr == "split":
            if not args:
                return (
                    f"[&](){{std::vector<std::string> _r_;std::istringstream _iss_({obj});"
                    f"std::string _tok_;while(_iss_>>_tok_)_r_.push_back(_tok_);return _r_;}}()",
                    "list[string]"
                )
            if len(args) != 1:
                raise TranspileError("str.split() requires 0 or 1 arguments")
            ac, at = self.infer_expr(args[0], scope)
            if at != "string":
                raise TranspileError("str.split() separator must be a string")
            return (
                f"[&](){{ std::vector<std::string> _r; std::string _s={obj}; "
                f"std::string _d={ac}; size_t _p=0,_n; "
                f"while((_n=_s.find(_d,_p))!=std::string::npos)"
                f"{{_r.push_back(_s.substr(_p,_n-_p));_p=_n+_d.size();}}"
                f"_r.push_back(_s.substr(_p)); return _r; }}()",
                "list[string]"
            )
        if attr == "join":
            if len(args) != 1:
                raise TranspileError("str.join() requires 1 argument")
            ac, at = self.infer_expr(args[0], scope)
            if at != "list[string]":
                raise TranspileError("str.join() requires a list[str]")
            return (
                f"[&](){{ std::string _r; std::string _sep={obj}; "
                f"for(size_t _i=0;_i<{ac}.size();++_i)"
                f"{{if(_i>0)_r+=_sep;_r+={ac}[_i];}} return _r; }}()",
                "string"
            )
        if attr == "replace":
            if len(args) != 2:
                raise TranspileError("str.replace() requires 2 arguments")
            ac, at = self.infer_expr(args[0], scope)
            bc, bt = self.infer_expr(args[1], scope)
            if at != "string" or bt != "string":
                raise TranspileError("str.replace() arguments must be strings")
            return (
                f"[&](){{ std::string _s={obj}; std::string _o={ac}; std::string _n={bc}; "
                f"size_t _p=0; while((_p=_s.find(_o,_p))!=std::string::npos)"
                f"{{_s.replace(_p,_o.size(),_n);_p+=_n.size();}} return _s; }}()",
                "string"
            )
        if attr == "count":
            if len(args) != 1:
                raise TranspileError("str.count() requires 1 argument")
            ac, at = self.infer_expr(args[0], scope)
            if at != "string":
                raise TranspileError("str.count() argument must be a string")
            return (
                f"[&](){{int _c=0;std::string _s={obj};std::string _sub={ac};"
                f"size_t _p=0;while((_p=_s.find(_sub,_p))!=std::string::npos){{++_c;_p+=_sub.size();}}"
                f"return _c;}}()",
                "int"
            )
        if attr in ("isdigit", "isalpha", "isspace", "isupper", "islower", "isalnum"):
            if args:
                raise TranspileError(f"str.{attr}() takes no arguments")
            fn_map = {
                "isdigit": "::isdigit", "isalpha": "::isalpha", "isspace": "::isspace",
                "isupper": "::isupper", "islower": "::islower", "isalnum": "::isalnum",
            }
            fn = fn_map[attr]
            return (
                f"[&](){{std::string _s={obj};return !_s.empty()&&std::all_of(_s.begin(),_s.end(),{fn});}}()",
                "bool"
            )
        if attr == "zfill":
            if len(args) != 1:
                raise TranspileError("str.zfill() requires 1 argument")
            nc, nt = self.infer_expr(args[0], scope)
            if nt != "int":
                raise TranspileError("str.zfill() argument must be int")
            return (
                f"[&](){{std::string _s={obj};int _n={nc};"
                f"if((int)_s.size()<_n)_s.insert(0,_n-_s.size(),'0');return _s;}}()",
                "string"
            )
        if attr in ("ljust", "rjust", "center"):
            if len(args) not in (1, 2):
                raise TranspileError(f"str.{attr}() requires 1 or 2 arguments")
            nc, nt = self.infer_expr(args[0], scope)
            if nt != "int":
                raise TranspileError(f"str.{attr}() width must be int")
            fill = "'\\\\'"
            if len(args) == 2:
                fc, ft = self.infer_expr(args[1], scope)
                if ft != "string":
                    raise TranspileError(f"str.{attr}() fill must be str")
                fill = f"({fc})[0]"
            if attr == "ljust":
                return (
                    f"[&](){{std::string _s={obj};int _n={nc};char _f={fill};"
                    f"if((int)_s.size()<_n)_s.append(_n-_s.size(),_f);return _s;}}()",
                    "string"
                )
            if attr == "rjust":
                return (
                    f"[&](){{std::string _s={obj};int _n={nc};char _f={fill};"
                    f"if((int)_s.size()<_n)_s.insert(0,_n-_s.size(),_f);return _s;}}()",
                    "string"
                )
            # center
            return (
                f"[&](){{std::string _s={obj};int _n={nc};char _f={fill};"
                f"if((int)_s.size()<_n){{int _t=_n-(int)_s.size();"
                f"_s.insert(0,_t/2,_f);_s.append((_t+1)/2,_f);}}return _s;}}()",
                "string"
            )
        if attr == "removeprefix":
            if len(args) != 1:
                raise TranspileError("str.removeprefix() requires 1 argument")
            ac, at = self.infer_expr(args[0], scope)
            if at != "string":
                raise TranspileError("str.removeprefix() argument must be a string")
            return (
                f"[&](){{std::string _s={obj};std::string _p={ac};"
                f"if(_s.size()>=_p.size()&&_s.compare(0,_p.size(),_p)==0)_s=_s.substr(_p.size());"
                f"return _s;}}()",
                "string"
            )
        if attr == "removesuffix":
            if len(args) != 1:
                raise TranspileError("str.removesuffix() requires 1 argument")
            ac, at = self.infer_expr(args[0], scope)
            if at != "string":
                raise TranspileError("str.removesuffix() argument must be a string")
            return (
                f"[&](){{std::string _s={obj};std::string _x={ac};"
                f"if(_s.size()>=_x.size()&&_s.compare(_s.size()-_x.size(),_x.size(),_x)==0)"
                f"_s=_s.substr(0,_s.size()-_x.size());return _s;}}()",
                "string"
            )
        if attr == "encode":
            # ignore encoding arg; works for ASCII/UTF-8 round-trips
            return (
                f"[&](){{std::vector<uint8_t> _r_;std::string _s_={obj};"
                f"for(char _c_:_s_)_r_.push_back((uint8_t)_c_);return _r_;}}()",
                "bytes"
            )
        if attr == "format":
            raise TranspileError("str.format() is only supported on string literals; use f-strings instead")
        raise TranspileError(f"str method '.{attr}()' not supported")

    def _string_format(self, obj_node, args: list, scope: Scope) -> Tuple[str, str]:
        """Handle 'fmt'.format(*args) — receiver must be a string literal."""
        import re
        if not isinstance(obj_node, ast.Constant) or not isinstance(obj_node.value, str):
            raise TranspileError("str.format() requires a string literal receiver; use f-strings instead")
        fmt = obj_node.value
        tokens = re.split(r'\{([^}]*)\}', fmt)
        auto_idx = 0
        parts: List[str] = []
        for i in range(0, len(tokens), 2):
            literal = tokens[i]
            if literal:
                parts.append(f'std::string({json.dumps(literal)})')
            if i + 1 >= len(tokens):
                break
            spec = tokens[i + 1]
            if spec == "" or (spec.startswith(":") and not spec[1:2].isdigit()):
                idx = auto_idx; auto_idx += 1
                fmt_spec = spec[1:] if spec.startswith(":") else ""
            elif spec.isdigit():
                idx = int(spec); fmt_spec = ""
            elif ":" in spec:
                head, fmt_spec = spec.split(":", 1)
                idx = int(head) if head.isdigit() else auto_idx
                if not head.isdigit(): auto_idx += 1
            else:
                raise TranspileError(f"str.format(): unsupported placeholder '{{{spec}}}'")
            if idx >= len(args):
                raise TranspileError(f"str.format(): index {idx} out of range ({len(args)} args given)")
            ac, at = self.infer_expr(args[idx], scope)
            parts.append(self._format_spec_cpp(ac, at, fmt_spec) if fmt_spec else self._to_string_expr(ac, at))
        return (" + ".join(parts) if parts else 'std::string("")', "string")

    def _dict_method(self, obj: str, obj_type: str, attr: str, args: list, scope: Scope) -> Tuple[str, str]:
        parts = split_type_args(obj_type[5:-1])
        k_t, v_t = parts[0], parts[1]
        if attr == "keys":
            if args:
                raise TranspileError("dict.keys() takes no arguments")
            k_cpp = self.cpp_type(k_t)
            return (
                f"[&](){{std::vector<{k_cpp}> _r_;for(auto& [_k_,_v_]:{obj})_r_.push_back(_k_);return _r_;}}()",
                f"list[{k_t}]"
            )
        if attr == "values":
            if args:
                raise TranspileError("dict.values() takes no arguments")
            v_cpp = self.cpp_type(v_t)
            return (
                f"[&](){{std::vector<{v_cpp}> _r_;for(auto& [_k_,_v_]:{obj})_r_.push_back(_v_);return _r_;}}()",
                f"list[{v_t}]"
            )
        if attr == "get":
            if len(args) == 2:
                kc, kt = self.infer_expr(args[0], scope)
                dc, dt = self.infer_expr(args[1], scope)
                if kt != k_t:
                    raise TranspileError(f"dict.get() key must be '{k_t}', got '{kt}'")
                if dt != v_t:
                    raise TranspileError(f"dict.get() default must be '{v_t}', got '{dt}'")
                return (f"({obj}.count({kc}) ? {obj}[{kc}] : {dc})", v_t)
            if len(args) == 1:
                kc, kt = self.infer_expr(args[0], scope)
                if kt != k_t:
                    raise TranspileError(f"dict.get() key must be '{k_t}', got '{kt}'")
                cpp_v_t = self.cpp_type(v_t)
                return (f"({obj}.count({kc}) ? std::optional<{cpp_v_t}>({obj}[{kc}]) : std::nullopt)", f"optional[{v_t}]")
            raise TranspileError("dict.get() requires 1 or 2 arguments")
        if attr == "setdefault":
            if len(args) != 2:
                raise TranspileError("dict.setdefault() requires 2 arguments")
            kc, kt = self.infer_expr(args[0], scope)
            dc, dt = self.infer_expr(args[1], scope)
            if kt != k_t:
                raise TranspileError(f"dict.setdefault() key must be '{k_t}', got '{kt}'")
            if dt != v_t:
                raise TranspileError(f"dict.setdefault() default must be '{v_t}', got '{dt}'")
            return (
                f"[&](){{if(!{obj}.count({kc})){obj}[{kc}]={dc};return {obj}[{kc}];}}()",
                v_t
            )
        raise TranspileError(f"dict method '.{attr}()' not supported")

    def _infer_lambda(self, node: ast.Lambda, scope: Scope,
                       expected_type: Optional[str] = None) -> Tuple[str, str]:
        """Lambda → typed std::function. Infers arg types from expected_type if unannotated."""
        args = node.args.args
        if node.args.vararg or node.args.kwarg or node.args.kwonlyargs:
            raise TranspileError("Lambda with *args/**kwargs not supported")
        # Try to infer arg types from expected func[...] type if args are unannotated
        arg_types: List[str] = []
        needs_infer = any(a.annotation is None for a in args)
        if needs_infer and expected_type and expected_type.startswith("func["):
            inner = expected_type[5:-1]
            arrow = inner.rfind("->")
            if arrow != -1:
                inferred_args = [a.strip() for a in split_type_args(inner[:arrow])]
                if inferred_args and inferred_args[0]:
                    if len(inferred_args) == len(args):
                        arg_types = inferred_args
        # Fall back to explicit annotations
        if not arg_types:
            if any(a.annotation is None for a in args):
                raise TranspileError("Lambda arguments must be annotated")
            arg_types = [self.ann_to_type(a.annotation) for a in args]
        inner_scope = Scope(parent=scope)
        param_strs = []
        for a, t in zip(args, arg_types):
            inner_scope.define(a.arg, t)
            param_strs.append(f"{self.cpp_type(t)} {a.arg}")
        body_c, body_t = self.infer_expr(node.body, inner_scope)
        ret_cpp = self.cpp_type(body_t)
        params_cpp = ", ".join(param_strs)
        # Use [=] when lambda may escape (stored as std::function), [&] otherwise
        capture = "[=]" if (expected_type and expected_type.startswith("func[")) else "[&]"
        lambda_code = f"{capture}({params_cpp}) -> {ret_cpp} {{ return {body_c}; }}"
        fn_type = f"func[{','.join(arg_types)}->{body_t}]"
        return (lambda_code, fn_type)

    def _make_comp_loop(self, gen: ast.comprehension, scope: Scope) -> Tuple[str, str, Scope]:
        """Return (loop_header, filter_code, inner_scope) for one comprehension generator."""
        inner_scope = Scope(parent=scope)
        if not isinstance(gen.target, ast.Name):
            raise TranspileError("Comprehension target must be a simple name")
        var = gen.target.id
        if (isinstance(gen.iter, ast.Call) and
                isinstance(gen.iter.func, ast.Name) and
                gen.iter.func.id == "range"):
            args = gen.iter.args
            if len(args) == 1:
                s0, _ = self.infer_expr(args[0], scope)
                loop = f"for (int {var} = 0; {var} < {s0}; ++{var})"
            elif len(args) == 2:
                s0, _ = self.infer_expr(args[0], scope)
                s1, _ = self.infer_expr(args[1], scope)
                loop = f"for (int {var} = {s0}; {var} < {s1}; ++{var})"
            elif len(args) == 3:
                s0, _ = self.infer_expr(args[0], scope)
                s1, _ = self.infer_expr(args[1], scope)
                s2, _ = self.infer_expr(args[2], scope)
                loop = f"for (int {var} = {s0}; {var} < {s1}; {var} += {s2})"
            else:
                raise TranspileError("range() supports 1–3 args")
            inner_scope.define(var, "int")
        else:
            ic, it = self.infer_expr(gen.iter, scope)
            if not it.startswith("list["):
                raise TranspileError(
                    f"Comprehension iter must be a list or range(), got '{it}'"
                )
            elem_t = element_type(it)
            inner_scope.define(var, elem_t)
            loop = f"for ({self.cpp_type(elem_t)} {var} : {ic})"
        filter_code = ""
        if gen.ifs:
            parts = []
            for cond in gen.ifs:
                cc, ct = self.infer_expr(cond, inner_scope)
                if ct != "bool":
                    raise TranspileError("Comprehension condition must be bool")
                parts.append(cc)
            filter_code = f"if ({' && '.join(parts)}) "
        return loop, filter_code, inner_scope

    def _infer_list_comp(self, node: ast.ListComp, scope: Scope) -> Tuple[str, str]:
        # Build nested loops for multiple generators
        loops: List[Tuple[str, str]] = []
        cur_scope = scope
        for gen in node.generators:
            loop, flt, cur_scope = self._make_comp_loop(gen, cur_scope)
            loops.append((loop, flt))

        ec, et = self.infer_expr(node.elt, cur_scope)
        result_t = f"list[{et}]"
        cpp_t = self.cpp_type(result_t)

        # Build nested loop string (inner-most filter applies to the push_back)
        body = f"_r.push_back({ec});"
        for loop, flt in reversed(loops):
            if flt:
                body = f"{loop} {{ {flt}{{ {body} }} }}"
            else:
                body = f"{loop} {{ {body} }}"
        code = f"[&](){{ {cpp_t} _r; {body} return _r; }}()"
        return (code, result_t)

    def _infer_list_comp_hinted(self, node: ast.ListComp, scope: Scope, elem_hint: str) -> Tuple[str, str]:
        """Like _infer_list_comp but uses elem_hint when the element is an empty list literal."""
        loops: List[Tuple[str, str]] = []
        cur_scope = scope
        for gen in node.generators:
            loop, flt, cur_scope = self._make_comp_loop(gen, cur_scope)
            loops.append((loop, flt))
        if isinstance(node.elt, ast.List) and not node.elt.elts:
            et = elem_hint
            ec = f"{self.cpp_type(et)}{{}}"
        else:
            ec, et = self.infer_expr(node.elt, cur_scope)
        result_t = f"list[{et}]"
        cpp_t = self.cpp_type(result_t)
        body = f"_r.push_back({ec});"
        for loop, flt in reversed(loops):
            body = f"{loop} {{ {flt}{{ {body} }} }}" if flt else f"{loop} {{ {body} }}"
        return (f"[&](){{ {cpp_t} _r; {body} return _r; }}()", result_t)

    def _infer_set_comp(self, node: ast.SetComp, scope: Scope) -> Tuple[str, str]:
        loops: List[Tuple[str, str]] = []
        cur_scope = scope
        for gen in node.generators:
            loop, flt, cur_scope = self._make_comp_loop(gen, cur_scope)
            loops.append((loop, flt))

        ec, et = self.infer_expr(node.elt, cur_scope)
        result_t = f"set[{et}]"
        cpp_t = self.cpp_type(result_t)

        body = f"_r.insert({ec});"
        for loop, flt in reversed(loops):
            if flt:
                body = f"{loop} {{ {flt}{{ {body} }} }}"
            else:
                body = f"{loop} {{ {body} }}"
        code = f"[&](){{ {cpp_t} _r; {body} return _r; }}()"
        return (code, result_t)

    def _infer_dict_comp(self, node: ast.DictComp, scope: Scope) -> Tuple[str, str]:
        # Multi-generator support: build loops like list comp
        loops: List[Tuple[str, str]] = []
        cur_scope = scope
        for gen in node.generators:
            # dict comp also supports (k, v) tuple targets in the first generator
            if (isinstance(gen.target, ast.Tuple) and len(gen.target.elts) == 2 and
                    all(isinstance(e, ast.Name) for e in gen.target.elts)):
                kv = [e.id for e in gen.target.elts]
                ic, it = self.infer_expr(gen.iter, cur_scope)
                if not it.startswith("list["):
                    raise TranspileError(f"Dict comprehension iter must be a list, got '{it}'")
                elem_t = element_type(it)
                if not elem_t.startswith("tuple["):
                    raise TranspileError("Dict comprehension (k,v) unpacking requires list[tuple[...]]")
                tparts = split_type_args(elem_t[6:-1])
                if len(tparts) != 2:
                    raise TranspileError("Tuple unpacking in dict comprehension requires 2-tuple")
                inner_scope = Scope(parent=cur_scope)
                inner_scope.define(kv[0], tparts[0])
                inner_scope.define(kv[1], tparts[1])
                loop = f"for (auto& [{kv[0]}, {kv[1]}] : {ic})"
                flt = ""
                if gen.ifs:
                    parts = []
                    for cond in gen.ifs:
                        cc, ct = self.infer_expr(cond, inner_scope)
                        if ct != "bool":
                            raise TranspileError("Comprehension condition must be bool")
                        parts.append(cc)
                    flt = f"if ({' && '.join(parts)}) "
                loops.append((loop, flt))
                cur_scope = inner_scope
            else:
                loop, flt, cur_scope = self._make_comp_loop(gen, cur_scope)
                loops.append((loop, flt))

        kc, kt = self.infer_expr(node.key, cur_scope)
        vc, vt = self.infer_expr(node.value, cur_scope)
        result_t = f"dict[{kt},{vt}]"
        cpp_t = self.cpp_type(result_t)

        body = f"_r[{kc}] = {vc};"
        for loop, flt in reversed(loops):
            if flt:
                body = f"{loop} {{ {flt}{{ {body} }} }}"
            else:
                body = f"{loop} {{ {body} }}"
        code = f"[&](){{ {cpp_t} _r; {body} return _r; }}()"
        return (code, result_t)

    def transpile_assert(self, node: ast.Assert, scope: Scope):
        tc, tt = self.infer_expr(node.test, scope)
        if tt != "bool":
            raise TranspileError("assert condition must be bool")
        if node.msg is not None:
            mc, mt = self.infer_expr(node.msg, scope)
            if mt != "string":
                raise TranspileError("assert message must be a string")
            self.emit(f"if (!({tc})) throw std::runtime_error({mc});")
        else:
            self.emit(f"if (!({tc})) throw std::runtime_error(\"AssertionError\");")

    def transpile_with(self, node: ast.With, scope: Scope, func_return: Optional[str] = None):
        # Multiple items: with A() as a, B() as b  → nested scoped blocks
        if len(node.items) > 1:
            # Wrap body in nested single-item with statements
            inner = ast.With(
                items=[node.items[-1]],
                body=node.body,
                type_comment=None,
            )
            for item in reversed(node.items[:-1]):
                inner = ast.With(items=[item], body=[inner], type_comment=None)
            self.transpile_with(inner, scope, func_return)
            return

        item = node.items[0]
        inner_scope = Scope(parent=scope)

        vc, vt = self.infer_expr(item.context_expr, scope)
        cls = self._class_of(vt)

        # User-defined context manager (__enter__ / __exit__)
        if cls and "__enter__" in self.classes[cls].methods and "__exit__" in self.classes[cls].methods:
            enter_ret, _ = self.classes[cls].methods["__enter__"]
            self.emit("{")
            self.indent()
            self.emit(f"{self.cpp_type(vt)} _ctx_ = {vc};")
            if item.optional_vars is not None:
                if not isinstance(item.optional_vars, ast.Name):
                    raise TranspileError("'with ... as' target must be a simple name")
                var = item.optional_vars.id
                inner_scope.define(var, enter_ret)
                enter_cpp = self.cpp_type(enter_ret)
                self.emit(f"{enter_cpp} {var} = _ctx_.__enter__();")
            else:
                self.emit("_ctx_.__enter__();")
            self.emit("try {")
            self.indent()
            for stmt in node.body:
                self.transpile_stmt(stmt, inner_scope, func_return)
            self.dedent()
            self.emit("} catch (...) {")
            self.indent()
            self.emit("_ctx_.__exit__();")
            self.emit("throw;")
            self.dedent()
            self.emit("}")
            self.emit("_ctx_.__exit__();")
            self.dedent()
            self.emit("}")
            return

        # RAII-style with (plain scoped block)
        self.emit("{")
        self.indent()
        if item.optional_vars is not None:
            if not isinstance(item.optional_vars, ast.Name):
                raise TranspileError("'with ... as' target must be a simple name")
            var = item.optional_vars.id
            inner_scope.define(var, vt)
            self.emit(f"{self.cpp_type(vt)} {var} = {vc};")
        else:
            self.emit(f"{vc};")
        for stmt in node.body:
            self.transpile_stmt(stmt, inner_scope, func_return)
        self.dedent()
        self.emit("}")

    def _transpile_nested_function(self, f: ast.FunctionDef, scope: Scope,
                                    func_return: Optional[str] = None):
        name = f.name
        if f.returns is None or f.args.kwarg or f.args.vararg or f.args.kwonlyargs:
            return
        if any(a.annotation is None for a in f.args.args):
            return
        params = []
        for a in f.args.args:
            try:
                t = self.ann_to_type(a.annotation)
            except TranspileError:
                return
            params.append(t)
        try:
            ret = self.ann_to_type(f.returns)
        except TranspileError:
            return

        self.functions[name] = (ret, [(t, None) for t in params])
        param_strs = [f"{self.cpp_type(t)} {a.arg}" for a, t in zip(f.args.args, params)]
        self.emit(f"auto {name} = [=]({', '.join(param_strs)}) -> {self.cpp_type(ret)} " + "{")
        self.indent()

        inner_scope = Scope(parent=scope)
        for a, t in zip(f.args.args, params):
            inner_scope.define(a.arg, t)

        saved_gen = self._generator_yield_type
        self._generator_yield_type = None
        for stmt in f.body:
            self.transpile_stmt(stmt, inner_scope, func_return=ret)
        self._generator_yield_type = saved_gen

        self.dedent()
        self.emit("};")

    def _transpile_match(self, node, scope: Scope, func_return: Optional[str] = None):
        sc, st = self.infer_expr(node.subject, scope)
        cpp_st = self.cpp_type(st)
        self.emit("{")
        self.indent()
        self.emit(f"{cpp_st} _ms_ = {sc};")
        first = True
        for case in node.cases:
            cond, capture, cap_type = self._match_pattern_cond(case.pattern, "_ms_", st, scope)
            if case.guard is not None:
                gc, gt = self.infer_expr(case.guard, scope)
                if gt != "bool":
                    raise TranspileError("match guard must be bool")
                cond = f"({cond} && {gc})" if cond else gc
            inner_scope = Scope(parent=scope)
            if capture is not None and cap_type is not None:
                inner_scope.define(capture, cap_type)
            if cond is not None:
                self.emit(("if" if first else "else if") + f" ({cond}) " + "{")
            else:
                self.emit("else {")
            self.indent()
            if capture is not None and cap_type is not None:
                self.emit(f"{self.cpp_type(cap_type)} {capture} = _ms_;")
            for stmt in case.body:
                self.transpile_stmt(stmt, inner_scope, func_return)
            self.dedent()
            self.emit("}")
            first = False
        self.dedent()
        self.emit("}")

    def _match_pattern_cond(self, pattern, subj: str, subj_type: str,
                             scope: Scope) -> Tuple[Optional[str], Optional[str], Optional[str]]:
        if hasattr(ast, "MatchAs") and isinstance(pattern, ast.MatchAs):
            if pattern.pattern is None:
                if pattern.name is None:
                    return (None, None, None)        # wildcard `_`
                return (None, pattern.name, subj_type)  # capture `case x:`
            cond, _, _ = self._match_pattern_cond(pattern.pattern, subj, subj_type, scope)
            return (cond, pattern.name, subj_type)
        if hasattr(ast, "MatchValue") and isinstance(pattern, ast.MatchValue):
            vc, _ = self.infer_expr(pattern.value, scope)
            return (f"({subj} == {vc})", None, None)
        if hasattr(ast, "MatchSingleton") and isinstance(pattern, ast.MatchSingleton):
            val = pattern.value
            if val is None: vc = "std::nullopt"
            elif val is True: vc = "true"
            else: vc = "false"
            return (f"({subj} == {vc})", None, None)
        if hasattr(ast, "MatchOr") and isinstance(pattern, ast.MatchOr):
            conds = [
                c for c, _, _ in (
                    self._match_pattern_cond(p, subj, subj_type, scope)
                    for p in pattern.patterns
                ) if c is not None
            ]
            return (("(" + " || ".join(conds) + ")") if conds else None, None, None)
        raise TranspileError(f"Unsupported match pattern: {type(pattern).__name__}")

    def transpile_stmt(self, node: ast.stmt, scope: Scope, func_return: Optional[str] = None):
        if isinstance(node, ast.Assign):          self.transpile_assign(node, scope)
        elif isinstance(node, ast.AnnAssign):     self.transpile_ann_assign(node, scope)
        elif isinstance(node, ast.AugAssign):     self.transpile_aug_assign(node, scope)
        elif isinstance(node, ast.If):            self.transpile_if(node, scope, func_return)
        elif isinstance(node, ast.While):         self.transpile_while(node, scope, func_return)
        elif isinstance(node, ast.For):           self.transpile_for(node, scope, func_return)
        elif isinstance(node, ast.Expr):          self.transpile_expr_stmt(node, scope)
        elif isinstance(node, ast.Return):
            if func_return is None:
                raise TranspileError("return outside function")
            self.transpile_return(node, scope, func_return)
        elif isinstance(node, ast.Raise):         self.transpile_raise(node, scope)
        elif isinstance(node, ast.Try):           self.transpile_try(node, scope, func_return)
        elif isinstance(node, ast.Assert):          self.transpile_assert(node, scope)
        elif isinstance(node, ast.With):           self.transpile_with(node, scope, func_return)
        elif isinstance(node, ast.Break):         self.emit("break;")
        elif isinstance(node, ast.Continue):      self.emit("continue;")
        elif isinstance(node, ast.Pass):          return
        elif isinstance(node, ast.Delete):        self.transpile_delete(node, scope)
        elif isinstance(node, (ast.Import, ast.ImportFrom)): return
        elif isinstance(node, (ast.Global, ast.Nonlocal)): return  # vars already in scope via global_scope
        elif isinstance(node, ast.FunctionDef):
            self._transpile_nested_function(node, scope, func_return)
        elif isinstance(node, ast.ClassDef):
            raise TranspileError("Class definitions must be at module top level")
        elif hasattr(ast, "Match") and isinstance(node, ast.Match):
            self._transpile_match(node, scope, func_return)
        else:
            raise TranspileError(f"Unsupported statement: {type(node).__name__}")

    def _register_global_scope(self):
        """Pre-populate global_scope with module-level variable types (no emit)."""
        if not self.modules:
            return
        scope = self.global_scope
        for node in self.modules[0].body:
            if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.Import,
                                  ast.ImportFrom, ast.If, ast.Expr, ast.Pass)):
                continue
            if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
                name = node.target.id
                try:
                    var_type = self.ann_to_type(node.annotation)
                    scope.define(name, var_type)
                except TranspileError:
                    continue
            elif (isinstance(node, ast.Assign) and
                  len(node.targets) == 1 and
                  isinstance(node.targets[0], ast.Name)):
                name = node.targets[0].id
                try:
                    _, vt = self.infer_expr(node.value, scope)
                    scope.define(name, vt)
                except TranspileError:
                    continue

    def transpile_global_vars(self):
        """Emit module-level variable declarations from the user's entry module."""
        if not self.modules:
            return
        saved = len(self.lines)
        scope = self.global_scope
        for node in self.modules[0].body:
            if isinstance(node, (ast.ClassDef, ast.FunctionDef, ast.Import,
                                  ast.ImportFrom, ast.If, ast.Expr, ast.Pass)):
                continue
            if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
                name = node.target.id
                try:
                    var_type = self.ann_to_type(node.annotation)
                    if node.value is not None:
                        vc, _ = self.infer_expr(node.value, scope)
                        self.emit(f"{self.cpp_type(var_type)} {name} = {vc};")
                    else:
                        self.emit(f"{self.cpp_type(var_type)} {name};")
                except TranspileError:
                    continue
            elif (isinstance(node, ast.Assign) and
                  len(node.targets) == 1 and
                  isinstance(node.targets[0], ast.Name)):
                name = node.targets[0].id
                try:
                    vc, vt = self.infer_expr(node.value, scope)
                    self.emit(f"const {self.cpp_type(vt)} {name} = {vc};")
                except TranspileError:
                    continue
        if len(self.lines) > saved:
            self.emit("")

    # ---- class registration ----

    def register_class_signatures(self):
        # First pass: register all names so annotation_to_type can resolve them
        for mod in self.modules:
            _, _, _, is_stub = self._load_stub_meta(mod)
            if is_stub:
                continue
            for node in mod.body:
                if isinstance(node, ast.ClassDef):
                    self.classes[node.name] = ClassInfo(node.name)
        # Second pass: process each class fully
        for mod in self.modules:
            _, _, _, is_stub = self._load_stub_meta(mod)
            if is_stub:
                continue
            for node in mod.body:
                if isinstance(node, ast.ClassDef):
                    self._process_class(node)

    def _process_class(self, node: ast.ClassDef):
        info = self.classes[node.name]

        # Parent — filter out transparent no-op bases (object, ABC, Generic, ...)
        # and non-name expressions (e.g. collections.abc.ABC); keywords like
        # metaclass= are silently ignored.
        real_bases = [
            b.id for b in node.bases
            if isinstance(b, ast.Name) and b.id not in TRANSPARENT_BASES
        ]
        if real_bases:
            parent_name = real_bases[0]
            if parent_name in EXCEPTION_MAP:
                info.is_exception = True
            elif parent_name in self.classes:
                if self.classes[parent_name].is_exception:
                    info.is_exception = True
                info.parent = parent_name
            # else: unknown base (built-in type, external lib) — skip silently
            for extra in real_bases[1:]:
                if extra in self.classes:
                    info.extra_parents.append(extra)

        # Detect Generic[T1, T2, ...] in bases → store type parameters
        for base in node.bases:
            if (isinstance(base, ast.Subscript) and
                    isinstance(base.value, ast.Name) and
                    base.value.id == "Generic"):
                if isinstance(base.slice, ast.Tuple):
                    tvars = [e.id for e in base.slice.elts if isinstance(e, ast.Name)]
                elif isinstance(base.slice, ast.Name):
                    tvars = [base.slice.id]
                else:
                    tvars = []
                info.type_params = [t for t in tvars if t in self.type_vars]

        # Enum detection: class Color(Enum) / class Status(IntEnum)
        enum_base = next(
            (b.id for b in node.bases if isinstance(b, ast.Name) and b.id in ENUM_BASES),
            None
        )
        if enum_base:
            info.is_enum = True
            info.is_int_enum = enum_base in ("IntEnum", "IntFlag")
            info.is_str_enum = enum_base in ("StrEnum",)
            for item in node.body:
                if isinstance(item, ast.Assign) and len(item.targets) == 1:
                    target = item.targets[0]
                    if not isinstance(target, ast.Name):
                        continue
                    member_name = target.id
                    val = item.value
                    if isinstance(val, ast.Constant):
                        if isinstance(val.value, int):
                            cpp_val = str(val.value)
                        elif isinstance(val.value, str):
                            cpp_val = json.dumps(val.value)
                            info.is_str_enum = True  # auto-detect string-valued enums
                        else:
                            cpp_val = ""
                    else:
                        cpp_val = ""
                    info.enum_members.append((member_name, cpp_val))
            return  # no methods / fields for enums

        # NamedTuple detection: treat as dataclass with auto-generated init/eq/str
        namedtuple_base = any(
            isinstance(b, ast.Name) and b.id == "NamedTuple"
            for b in node.bases
        )
        if namedtuple_base:
            info.is_dataclass = True

        # @dataclass detection
        is_dataclass = any(
            (isinstance(d, ast.Name) and d.id == "dataclass") or
            (isinstance(d, ast.Call) and isinstance(d.func, ast.Name) and d.func.id == "dataclass")
            for d in node.decorator_list
        )
        if is_dataclass:
            info.is_dataclass = True
            # Check for frozen=True
            for d in node.decorator_list:
                if isinstance(d, ast.Call) and isinstance(d.func, ast.Name) and d.func.id == "dataclass":
                    for kw in d.keywords:
                        if kw.arg == "frozen" and isinstance(kw.value, ast.Constant) and kw.value.value is True:
                            info.is_frozen = True

        # Class-level annotated fields (and ClassVar statics)
        for item in node.body:
            if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
                ann = item.annotation
                # ClassVar[T] → static member
                if (isinstance(ann, ast.Subscript) and
                        isinstance(ann.value, ast.Name) and ann.value.id == "ClassVar"):
                    try:
                        inner_t = self.ann_to_type(ann.slice)
                        init_c = None
                        if item.value is not None:
                            init_c, _ = self.infer_expr(item.value, self.global_scope)
                        info.class_vars[item.target.id] = (inner_t, init_c)
                    except TranspileError:
                        pass
                else:
                    try:
                        info.fields[item.target.id] = self.ann_to_type(ann)
                    except TranspileError:
                        pass  # skip unresolvable field types

        # For dataclasses, auto-generate __init__ / __eq__ / __str__
        # (only for methods NOT already defined by the user in the class body)
        if info.is_dataclass:
            user_methods = {i.name for i in node.body if isinstance(i, ast.FunctionDef)}
            if "__init__" not in user_methods:
                params = []
                for fname, ftype in info.fields.items():
                    # look for a default value on the annotation
                    default_node = None
                    for item in node.body:
                        if (isinstance(item, ast.AnnAssign) and
                                isinstance(item.target, ast.Name) and
                                item.target.id == fname and item.value is not None):
                            default_node = item.value
                            break
                    params.append((ftype, default_node))
                info.methods["__init__"] = ("void", params)
            if "__eq__" not in user_methods:
                info.methods["__eq__"] = ("bool", [(info.name, None)])
            if "__str__" not in user_methods:
                info.methods["__str__"] = ("string", [])

        # Methods
        for item in node.body:
            if not isinstance(item, ast.FunctionDef):
                continue

            if any((isinstance(d, ast.Name) and d.id == "overload") or
                   (isinstance(d, ast.Attribute) and d.attr == "overload")
                   for d in item.decorator_list):
                continue

            is_static = any(
                isinstance(d, ast.Name) and d.id == "staticmethod"
                for d in item.decorator_list
            )
            is_classmethod = any(
                isinstance(d, ast.Name) and d.id == "classmethod"
                for d in item.decorator_list
            )
            is_property = any(
                isinstance(d, ast.Name) and d.id == "property"
                for d in item.decorator_list
            )
            is_abstract = any(
                isinstance(d, ast.Name) and d.id == "abstractmethod"
                for d in item.decorator_list
            )
            is_setter = any(
                isinstance(d, ast.Attribute) and d.attr == "setter"
                for d in item.decorator_list
            )
            is_deleter = any(
                isinstance(d, ast.Attribute) and d.attr == "deleter"
                for d in item.decorator_list
            )
            if is_deleter:
                continue
            if is_setter:
                prop_name = item.name
                args_no_self = item.args.args[1:]
                if len(args_no_self) == 1 and args_no_self[0].annotation is not None:
                    try:
                        val_type = self.ann_to_type(args_no_self[0].annotation)
                        info.property_setters[prop_name] = val_type
                        info.methods[f"set_{prop_name}"] = ("void", [(val_type, None)])
                    except TranspileError:
                        pass
                continue

            mname = item.name

            if mname == "__init__":
                if info.is_exception:
                    info.methods["__init__"] = ("void", [])
                    continue
                # Skip __init__ with *args / **kwargs / keyword-only args
                if item.args.vararg or item.args.kwarg or item.args.kwonlyargs:
                    continue
                if not item.args.args or item.args.args[0].arg != "self":
                    continue
                param_nodes = item.args.args[1:]
                if any(a.annotation is None for a in param_nodes):
                    continue
                n_args = len(param_nodes)
                n_defaults = len(item.args.defaults)
                param_types: Dict[str, str] = {}
                params = []
                ok = True
                for i, arg in enumerate(param_nodes):
                    try:
                        t = self.ann_to_type(arg.annotation)
                    except TranspileError:
                        ok = False
                        break
                    param_types[arg.arg] = t
                    di = i - (n_args - n_defaults)
                    params.append((t, item.args.defaults[di] if di >= 0 else None))
                if not ok:
                    continue
                self._discover_fields(item, param_types, info.fields)
                info.methods["__init__"] = ("void", params)

            elif is_property:
                # @property: self-only, no params, returns T
                if item.returns is None:
                    continue
                try:
                    ret = self.ann_to_type(item.returns)
                except TranspileError:
                    continue
                info.methods[mname] = (ret, [])
                info.properties.add(mname)

            elif mname == "__del__":
                info.methods["__del__"] = ("void", [])

            else:
                # Skip methods with unannotated *args; **kwargs needs annotation or defaults to string
                if item.args.vararg and item.args.vararg.annotation is None:
                    continue
                if any(a.annotation is None for a in item.args.kwonlyargs):
                    continue
                # classmethod: drop cls; staticmethod: keep all; else: drop self
                if is_static:
                    args = item.args.args
                else:
                    args = item.args.args[1:]
                    if not item.args.args or item.args.args[0].arg not in ("self", "cls"):
                        continue
                if item.returns is None:
                    continue
                if any(a.annotation is None for a in args):
                    continue
                try:
                    ret = self.ann_to_type(item.returns)
                except TranspileError:
                    continue
                n_args = len(args)
                n_defaults = len(item.args.defaults)
                params = []
                ok = True
                for i, arg in enumerate(args):
                    try:
                        t = self.ann_to_type(arg.annotation)
                    except TranspileError:
                        ok = False
                        break
                    di = i - (n_args - n_defaults)
                    params.append((t, item.args.defaults[di] if di >= 0 else None))
                if not ok:
                    continue
                # keyword-only args: treated as additional positional C++ params
                for i, arg in enumerate(item.args.kwonlyargs):
                    try:
                        t = self.ann_to_type(arg.annotation)
                    except TranspileError:
                        ok = False
                        break
                    kw_def = item.args.kw_defaults[i]
                    params.append((t, kw_def))
                if not ok:
                    continue
                # *args: T → vararg[T]
                if item.args.vararg and item.args.vararg.annotation is not None:
                    try:
                        elem_t = self.ann_to_type(item.args.vararg.annotation)
                        params.append((f"vararg[{elem_t}]", None))
                    except TranspileError:
                        pass
                # **kwargs → dict[string, V]
                if item.args.kwarg:
                    val_type = "string"
                    if item.args.kwarg.annotation is not None:
                        try:
                            val_type = self.ann_to_type(item.args.kwarg.annotation)
                        except TranspileError:
                            pass
                    params.append((f"dict[string,{val_type}]", "{}"))
                    self._has_kwargs[mname] = True
                info.methods[mname] = (ret, params)
                kw_names = [a.arg for a in item.args.kwonlyargs]
                info.method_param_names[mname] = [a.arg for a in args] + kw_names
                if is_abstract:
                    info.abstract_methods.add(mname)
                if mname == "__next__":
                    self._needs_stop_iteration = True

        # Inherit __init__ from parent if not defined
        if "__init__" not in info.methods and info.parent:
            parent_info = self.classes.get(info.parent)
            if parent_info and "__init__" in parent_info.methods:
                info.methods["__init__"] = parent_info.methods["__init__"]
                info.method_param_names["__init__"] = parent_info.method_param_names.get("__init__", [])

    def _discover_fields(self, init_def: ast.FunctionDef,
                          param_types: Dict[str, str], fields: Dict[str, str]):
        for stmt in init_def.body:
            # self.x: T = expr (annotated assignment in __init__)
            if isinstance(stmt, ast.AnnAssign):
                t = stmt.target
                if not (isinstance(t, ast.Attribute) and
                        isinstance(t.value, ast.Name) and t.value.id == "self"):
                    continue
                fname = t.attr
                if fname in fields:
                    continue
                if stmt.annotation:
                    try:
                        fields[fname] = self.ann_to_type(stmt.annotation)
                    except TranspileError:
                        pass
                continue
            if not isinstance(stmt, ast.Assign) or len(stmt.targets) != 1:
                continue
            t = stmt.targets[0]
            if not (isinstance(t, ast.Attribute) and
                    isinstance(t.value, ast.Name) and t.value.id == "self"):
                continue
            fname = t.attr
            if fname in fields:
                continue
            val = stmt.value
            if isinstance(val, ast.Name) and val.id in param_types:
                fields[fname] = param_types[val.id]
            elif isinstance(val, ast.Constant):
                v = val.value
                if isinstance(v, bool):    fields[fname] = "bool"
                elif isinstance(v, int):   fields[fname] = "int"
                elif isinstance(v, float): fields[fname] = "float"
                elif isinstance(v, str):   fields[fname] = "string"

    # ---- class emit ----

    def _is_super_init(self, stmt: ast.stmt) -> bool:
        if not isinstance(stmt, ast.Expr): return False
        call = stmt.value
        if not isinstance(call, ast.Call): return False
        func = call.func
        if not (isinstance(func, ast.Attribute) and func.attr == "__init__"): return False
        if not isinstance(func.value, ast.Call): return False
        return isinstance(func.value.func, ast.Name) and func.value.func.id == "super"

    def _is_py2_super_init(self, stmt: ast.stmt) -> bool:
        """Match ParentClass.__init__(self, ...) — Python 2 / explicit super call."""
        if not isinstance(stmt, ast.Expr): return False
        call = stmt.value
        if not isinstance(call, ast.Call): return False
        func = call.func
        if not (isinstance(func, ast.Attribute) and func.attr == "__init__"): return False
        return isinstance(func.value, ast.Name) and func.value.id in self.classes

    def transpile_class(self, node: ast.ClassDef):
        info = self.classes[node.name]

        # Enum class
        if info.is_enum:
            if not info.enum_members:
                return
            # StrEnum: generate struct with static constexpr const char* members
            if info.is_str_enum:
                self.emit(f"struct {node.name} {{")
                for name, val in info.enum_members:
                    self.emit(f"    static constexpr const char* {name} = {val};")
                self.emit("};")
                self.emit("")
                return
            members_str = ", ".join(
                f"{name} = {val}" if val else name
                for name, val in info.enum_members
            )
            self.emit(f"enum class {node.name} {{ {members_str} }};")
            self.emit("")
            return

        # Exception class
        if info.is_exception:
            if info.parent and info.parent in self.classes:
                parent_cpp = info.parent
            elif info.parent and info.parent in EXCEPTION_MAP:
                parent_cpp = EXCEPTION_MAP[info.parent]
            else:
                parent_cpp = "std::runtime_error"
            self.emit(f"class {node.name} : public {parent_cpp} " + "{")
            self.emit("public:")
            self.indent()
            self.emit(
                f"explicit {node.name}(const std::string& msg) "
                f": {parent_cpp}(msg) " + "{}"
            )
            self.dedent()
            self.emit("};")
            self.emit("")
            return

        # Regular class (emit template prefix for generic classes)
        if info.type_params:
            self.emit(f"template<{', '.join('typename ' + t for t in info.type_params)}>")
        header = f"class {node.name}"
        all_parents = ([info.parent] if info.parent else []) + info.extra_parents
        if all_parents:
            header += " : " + ", ".join(f"public {p}" for p in all_parents)
        self.emit(header + " {")
        self.emit("public:")
        self.indent()

        # Static class variables
        for cvname, (cvtype, _) in info.class_vars.items():
            self.emit(f"static {self.cpp_type(cvtype)} {cvname};")
        if info.class_vars:
            self.emit("")

        # Instance fields
        const = "const " if info.is_frozen else ""
        for fname, ftype in info.fields.items():
            self.emit(f"{const}{self.cpp_type(ftype)} {fname};")
        if info.fields:
            self.emit("")

        # Constructor
        user_methods = {i.name for i in node.body if isinstance(i, ast.FunctionDef)}
        init_def = next(
            (i for i in node.body if isinstance(i, ast.FunctionDef) and i.name == "__init__"),
            None
        )
        if info.is_dataclass and init_def is None:
            self._emit_dataclass_constructor(info, node.name)
        else:
            self._emit_constructor(init_def, info, node.name)

        # Methods
        for item in node.body:
            if not isinstance(item, ast.FunctionDef) or item.name in ("__init__", "__del__"):
                continue
            self._emit_class_method(item, info, node.name)

        # Auto-generated dataclass methods (__eq__, __str__) for non-user-defined ones
        if info.is_dataclass:
            self._emit_dataclass_methods(info, node.name, user_methods)

        # Destructor
        del_def = next(
            (i for i in node.body if isinstance(i, ast.FunctionDef) and i.name == "__del__"),
            None
        )
        if del_def is not None and "__del__" in info.methods:
            self._emit_destructor(del_def, info, node.name)

        self.dedent()
        self.emit("};")
        # Static class variable out-of-class definitions
        for cvname, (cvtype, cvinit) in info.class_vars.items():
            init_str = f" = {cvinit}" if cvinit is not None else ""
            self.emit(f"{self.cpp_type(cvtype)} {node.name}::{cvname}{init_str};")
        # std::hash specialization for __hash__
        if "__hash__" in info.methods:
            n = node.name
            self.emit(f"namespace std {{ template<> struct hash<{n}> {{")
            self.emit(f"    size_t operator()(const {n}& _x) const {{ return (size_t)_x._hash_(); }}")
            self.emit("};}")
        self.emit("")

    def _emit_constructor(self, init_def: Optional[ast.FunctionDef],
                           info: ClassInfo, class_name: str):
        if init_def is None or "__init__" not in info.methods:
            # Inherit constructors from parent via using-declaration
            if init_def is None and info.parent and info.parent in self.classes:
                parent_info = self.classes[info.parent]
                if "__init__" in parent_info.methods:
                    self.emit(f"using {info.parent}::{info.parent};")
                    self.emit("")
                    return
            self.emit(f"{class_name}() " + "{}")
            self.emit("")
            return

        params = info.methods["__init__"][1]
        args = init_def.args.args[1:]  # exclude self

        # Build param strings
        tmp_scope = Scope(parent=self.global_scope)
        for a, (t, _) in zip(args, params):
            tmp_scope.define(a.arg, t)

        param_strs = []
        for a, (t, default_node) in zip(args, params):
            cpp_t = self.cpp_type(t)
            if default_node is not None:
                dc, _ = self.infer_expr(default_node, tmp_scope)
                param_strs.append(f"{cpp_t} {a.arg} = {dc}")
            else:
                param_strs.append(f"{cpp_t} {a.arg}")

        # Collect super().__init__(...) → initializer list
        init_list = []
        body_stmts = []
        for stmt in init_def.body:
            if isinstance(stmt, ast.Pass):
                continue
            if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Constant):
                continue
            if self._is_super_init(stmt) and info.parent:
                super_args = [
                    self.infer_expr(a, tmp_scope)[0]
                    for a in stmt.value.args
                ]
                init_list.insert(0, f"{info.parent}({', '.join(super_args)})")
            elif self._is_py2_super_init(stmt) and info.parent:
                # ParentClass.__init__(self, arg1, arg2, ...) — skip first arg (self)
                super_args = [
                    self.infer_expr(a, tmp_scope)[0]
                    for a in stmt.value.args[1:]
                ]
                init_list.insert(0, f"{info.parent}({', '.join(super_args)})")
            else:
                body_stmts.append(stmt)

        # Emit default constructor so derived classes can omit super().__init__()
        # Skip if all params have defaults (parametrized ctor already handles no-arg case)
        all_have_defaults = all(d is not None for _, d in params)
        if param_strs and not all_have_defaults:
            self.emit(f"{class_name}() " + "{}")
            self.emit("")

        if init_list:
            self.emit(
                f"{class_name}({', '.join(param_strs)}) : {', '.join(init_list)} " + "{"
            )
        else:
            self.emit(f"{class_name}({', '.join(param_strs)}) " + "{")

        self.indent()
        prev = self.current_class
        self.current_class = info
        scope = Scope(parent=self.global_scope)
        for a, (t, _) in zip(args, params):
            scope.define(a.arg, t)
        for stmt in body_stmts:
            self.transpile_stmt(stmt, scope, func_return="void")
        self.current_class = prev
        self.dedent()
        self.emit("}")
        self.emit("")

    def _emit_dataclass_constructor(self, info: ClassInfo, class_name: str):
        params = info.methods.get("__init__", ("void", []))[1]
        field_names = list(info.fields.keys())
        param_strs = []
        for fname, (ftype, default_node) in zip(field_names, params):
            cpp_t = self.cpp_type(ftype)
            if default_node is not None:
                dc, _ = self.infer_expr(default_node, self.global_scope)
                param_strs.append(f"{cpp_t} {fname} = {dc}")
            else:
                param_strs.append(f"{cpp_t} {fname}")
        # Only emit empty default ctor if not all params have defaults and not frozen
        all_have_defaults = all(d is not None for _, d in params)
        if not all_have_defaults and not info.is_frozen:
            self.emit(f"{class_name}() " + "{}")
            self.emit("")
        if param_strs:
            init_list = ", ".join(f"{f}({f})" for f in field_names)
            post_init = " this->__post_init__();" if "__post_init__" in info.methods else ""
            self.emit(f"{class_name}({', '.join(param_strs)}) : {init_list} {{ {post_init} }}")
            self.emit("")

    def _emit_dataclass_methods(self, info: ClassInfo, class_name: str, user_methods: Set[str]):
        field_items = list(info.fields.items())

        if "__eq__" not in user_methods:
            self.emit(f"bool operator==(const {class_name}& other) const " + "{")
            self.indent()
            if not field_items:
                self.emit("return true;")
            else:
                cmp = " && ".join(f"{f} == other.{f}" for f, _ in field_items)
                self.emit(f"return {cmp};")
            self.dedent()
            self.emit("}")
            self.emit("")

        if "__str__" not in user_methods:
            self.emit("std::string to_string() {")
            self.indent()
            if not field_items:
                self.emit(f'return "{class_name}()";')
            else:
                parts = []
                for fname, ftype in field_items:
                    if ftype == "string":
                        parts.append(f'"{fname}=" + {fname}')
                    elif ftype in ("int", "float"):
                        parts.append(f'"{fname}=" + std::to_string({fname})')
                    elif ftype == "bool":
                        parts.append(f'"{fname}=" + std::string({fname} ? "true" : "false")')
                    else:
                        parts.append(f'"{fname}=" + {fname}.to_string()')
                inner = ' + ", " + '.join(parts)
                self.emit(f'return std::string("{class_name}(") + {inner} + ")";')
            self.dedent()
            self.emit("}")
            self.emit("")

    def _emit_class_method(self, item: ast.FunctionDef, info: ClassInfo, class_name: str):
        mname = item.name

        # Property deleter: skip silently
        if any(isinstance(d, ast.Attribute) and d.attr == "deleter"
               for d in item.decorator_list):
            return

        # Property setter: emit as set_<name>
        if any(isinstance(d, ast.Attribute) and d.attr == "setter"
               for d in item.decorator_list):
            if mname not in info.property_setters:
                return
            val_type = info.property_setters[mname]
            val_arg = item.args.args[1].arg
            self.emit(f"void set_{mname}({self.cpp_type(val_type)} {val_arg}) " + "{")
            self.indent()
            prev = self.current_class
            self.current_class = info
            inner_scope = Scope(parent=self.global_scope)
            inner_scope.define("self", class_name)
            inner_scope.define(val_arg, val_type)
            for stmt in item.body:
                self.transpile_stmt(stmt, inner_scope, func_return="void")
            self.current_class = prev
            self.dedent()
            self.emit("}")
            self.emit("")
            return

        # __del__ is emitted as destructor by transpile_class
        if mname == "__del__":
            return

        if mname not in info.methods:
            return

        is_static = any(
            isinstance(d, ast.Name) and d.id == "staticmethod"
            for d in item.decorator_list
        )
        is_classmethod = any(
            isinstance(d, ast.Name) and d.id == "classmethod"
            for d in item.decorator_list
        )
        ret, params = info.methods[mname]
        # static: all args; classmethod: drop cls; else: drop self
        if is_static:
            args = item.args.args
        else:
            args = item.args.args[1:]
        # append keyword-only args so they appear in the C++ signature
        args = list(args) + list(item.args.kwonlyargs)

        # Pure virtual (@abstractmethod)
        if mname in info.abstract_methods:
            ret, params = info.methods[mname]
            if mname in DUNDER_CPP:
                cpp_name = DUNDER_CPP[mname]
                const_s = "" if mname in INPLACE_DUNDERS else " const"
                tmp_strs = [f"{self.cpp_type(t)} {a.arg}" for a, (t, _) in zip(item.args.args[1:], params)]
                self.emit(f"virtual {self.cpp_type(ret)} {cpp_name}({', '.join(tmp_strs)}){const_s} = 0;")
            else:
                tmp_strs = [f"{self.cpp_type(t)} {a.arg}" for a, (t, _) in zip(item.args.args[1:], params)]
                self.emit(f"virtual {self.cpp_type(ret)} {mname}({', '.join(tmp_strs)}) = 0;")
            self.emit("")
            return

        is_operator = mname in DUNDER_CPP and DUNDER_CPP[mname].startswith("operator")
        is_inplace = mname in INPLACE_DUNDERS

        # Separate regular params from vararg/kwargs
        n_extra = (1 if item.args.kwarg else 0)
        has_vararg = bool(params) and len(params) > n_extra and params[-(1 + n_extra)][0].startswith("vararg[")
        regular_params = params[:len(params) - (1 if has_vararg else 0) - n_extra]

        param_strs = []
        for a, (t, default_node) in zip(args, regular_params):
            cpp_t = self.cpp_type(t)
            if is_operator and not is_inplace and t in self.classes:
                cpp_t = f"const {cpp_t}&"
            if t in self.classes and self._class_is_polymorphic(t):
                cpp_t = f"const {cpp_t}&"
            if default_node is not None:
                dc, _ = self.infer_expr(default_node, self.global_scope)
                param_strs.append(f"{cpp_t} {a.arg} = {dc}")
            else:
                param_strs.append(f"{cpp_t} {a.arg}")

        if has_vararg and item.args.vararg:
            vararg_idx = -(1 + n_extra)
            elem_t = params[vararg_idx][0][7:-1]
            param_strs.append(f"{self.cpp_type(f'list[{elem_t}]')} {item.args.vararg.arg}")

        if item.args.kwarg:
            kwarg_type = params[-1][0]
            param_strs.append(f"{self.cpp_type(kwarg_type)} {item.args.kwarg.arg} = {{}}")

        if mname in CONVERSION_DUNDERS:
            # explicit operator bool/int/double() const
            cpp_name = DUNDER_CPP[mname]  # e.g. "operator bool"
            self.emit(f"explicit {cpp_name}() const " + "{")
        elif mname in DUNDER_CPP:
            cpp_name = DUNDER_CPP[mname]
            const_suffix = "" if is_inplace else " const"
            self.emit(f"{self.cpp_type(ret)} {cpp_name}({', '.join(param_strs)}){const_suffix} " + "{")
        else:
            prefix = "static " if (is_static or is_classmethod) else (
                "virtual " if self.method_is_virtual(class_name, mname) else ""
            )
            suffix = " override" if (not is_static and self.method_overrides(class_name, mname)) else ""
            const_s = " const" if (not is_static and not is_classmethod and self._method_is_const(item, class_name)) else ""
            self.emit(
                f"{prefix}{self.cpp_type(ret)} {mname}({', '.join(param_strs)}){const_s}{suffix} " + "{"
            )
        self.indent()

        prev = self.current_class
        self.current_class = info
        scope = Scope(parent=self.global_scope)
        if not is_static:
            scope.define("self", class_name)
        for a, (t, _) in zip(args, regular_params):
            scope.define(a.arg, t)
        if has_vararg and item.args.vararg:
            vararg_idx = -(1 + n_extra)
            elem_t = params[vararg_idx][0][7:-1]
            scope.define(item.args.vararg.arg, f"list[{elem_t}]")
        if item.args.kwarg:
            scope.define(item.args.kwarg.arg, params[-1][0])
        for stmt in item.body:
            self.transpile_stmt(stmt, scope, func_return=ret)
        self.current_class = prev

        self.dedent()
        self.emit("}")
        self.emit("")

    def _emit_destructor(self, f: ast.FunctionDef, info: ClassInfo, class_name: str):
        self.emit(f"~{class_name}() " + "{")
        self.indent()
        prev = self.current_class
        self.current_class = info
        scope = Scope(parent=self.global_scope)
        for stmt in f.body:
            if isinstance(stmt, ast.Pass):
                continue
            if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Constant):
                continue
            self.transpile_stmt(stmt, scope, func_return="void")
        self.current_class = prev
        self.dedent()
        self.emit("}")
        self.emit("")

    # ---- stub helpers ----

    def _is_stub_function(self, f: ast.FunctionDef) -> bool:
        if len(f.body) != 1:
            return False
        stmt = f.body[0]
        return (isinstance(stmt, ast.Expr) and
                isinstance(stmt.value, ast.Constant) and
                stmt.value.value is ...)

    def _is_generator(self, f: ast.FunctionDef) -> bool:
        for node in ast.walk(f):
            if isinstance(node, ast.Yield):
                return True
        return False

    def _load_stub_meta(self, mod: ast.Module):
        """Extract CPP_INCLUDE, CPP_NAMESPACE, CPP_PREAMBLE from a stub module.
        Returns (includes, namespace, preamble, is_stub) where is_stub is True
        whenever any CPP_* sentinel is present (even if all are empty)."""
        includes: List[str] = []
        namespace = ""
        preamble = ""
        is_stub = False
        for node in mod.body:
            if not isinstance(node, ast.Assign):
                continue
            for target in node.targets:
                if not isinstance(target, ast.Name):
                    continue
                if target.id not in ("CPP_INCLUDE", "CPP_NAMESPACE", "CPP_PREAMBLE"):
                    continue
                is_stub = True
                val = node.value
                if target.id == "CPP_INCLUDE":
                    if isinstance(val, ast.Constant) and isinstance(val.value, str):
                        includes = [val.value]
                    elif isinstance(val, ast.List):
                        includes = [e.value for e in val.elts
                                    if isinstance(e, ast.Constant) and isinstance(e.value, str)]
                elif target.id == "CPP_NAMESPACE":
                    if isinstance(val, ast.Constant) and isinstance(val.value, str):
                        namespace = val.value
                elif target.id == "CPP_PREAMBLE":
                    if isinstance(val, ast.Constant) and isinstance(val.value, str):
                        preamble = val.value
        return includes, namespace, preamble, is_stub

    # ---- function registration ----

    def register_function_signatures(self):
        for mod in self.modules:
            includes, namespace, preamble, is_stub = self._load_stub_meta(mod)
            if is_stub:
                for inc in includes:
                    if inc not in self.extra_includes:
                        self.extra_includes.append(inc)
                if preamble and preamble not in self.preamble_lines:
                    self.preamble_lines.append(preamble)

            for node in mod.body:
                if not isinstance(node, ast.FunctionDef):
                    continue
                name = node.name
                if name in self.functions:
                    continue  # first definition wins; duplicates silently skipped
                if any((isinstance(d, ast.Name) and d.id == "overload") or
                       (isinstance(d, ast.Attribute) and d.attr == "overload")
                       for d in node.decorator_list):
                    continue  # @overload stubs: only the undecorated impl is transpiled
                # Skip functions that can't be fully typed:
                # missing return annotation, missing param annotation, **kwargs
                is_stub = self._is_stub_function(node)
                if node.returns is None:
                    if not is_stub:
                        self._skipped_functions[name] = "missing return type annotation"
                    continue
                if node.args.kwarg:
                    if not is_stub:
                        # Basic **kwargs → std::unordered_map<std::string, std::string>
                        pass  # fall through, will be handled below
                if node.args.vararg and node.args.vararg.annotation is None:
                    if not is_stub:
                        self._skipped_functions[name] = "unannotated *args"
                    continue
                if any(arg.annotation is None for arg in node.args.args):
                    if not is_stub:
                        self._skipped_functions[name] = "missing parameter type annotation"
                    continue
                if any(arg.annotation is None for arg in node.args.kwonlyargs):
                    if not is_stub:
                        self._skipped_functions[name] = "missing keyword-only argument type annotation"
                    continue
                try:
                    ret = self.ann_to_type(node.returns)
                except TranspileError as e:
                    if not is_stub:
                        self._skipped_functions[name] = f"unsupported return type: {e}"
                    continue
                n_args = len(node.args.args)
                n_defaults = len(node.args.defaults)
                params = []
                ok = True
                for i, arg in enumerate(node.args.args):
                    try:
                        t = self.ann_to_type(arg.annotation)
                    except TranspileError:
                        ok = False
                        break
                    di = i - (n_args - n_defaults)
                    params.append((t, node.args.defaults[di] if di >= 0 else None))
                if not ok:
                    continue
                # keyword-only args (after *): treated as regular positional C++ params
                for i, arg in enumerate(node.args.kwonlyargs):
                    try:
                        t = self.ann_to_type(arg.annotation)
                    except TranspileError:
                        ok = False
                        break
                    kw_def = node.args.kw_defaults[i]
                    params.append((t, kw_def))
                if not ok:
                    continue
                if node.args.vararg and node.args.vararg.annotation is not None:
                    try:
                        elem_t = self.ann_to_type(node.args.vararg.annotation)
                        params.append((f"vararg[{elem_t}]", None))
                    except TranspileError:
                        continue
                # **kwargs → dict[str, V] with empty default
                if node.args.kwarg:
                    val_type = "string"  # default
                    if node.args.kwarg.annotation is not None:
                        try:
                            val_type = self.ann_to_type(node.args.kwarg.annotation)
                        except TranspileError:
                            pass
                    params.append((f"dict[string,{val_type}]", "{}"))
                    self._has_kwargs[name] = True
                self.functions[name] = (ret, params)
                all_param_names = [a.arg for a in node.args.args] + [a.arg for a in node.args.kwonlyargs]
                self.function_param_names[name] = all_param_names

                if is_stub and namespace:
                    self.function_cpp_names[name] = f"{namespace}::{name}"

    def validate_imports(self):
        for mod in self.modules:
            for node in mod.body:
                if isinstance(node, ast.Import):
                    for alias in node.names:
                        m = alias.name.split(".")[0]
                        if m not in self.module_name_set:
                            raise TranspileError(f"Imported module '{m}' not provided as input")
                elif isinstance(node, ast.ImportFrom):
                    if node.level > 0:
                        continue  # relative imports are intra-package, always valid
                    if node.module is None:
                        continue
                    m = node.module.split(".")[0]
                    if m not in self.module_name_set:
                        raise TranspileError(f"Imported module '{m}' not provided as input")

    def register_import_aliases(self):
        for mod in self.modules:
            for node in mod.body:
                if not isinstance(node, ast.ImportFrom) or node.module is None:
                    continue
                if node.level > 0:
                    continue  # relative imports are intra-package, handled at load time
                for a in node.names:
                    orig = a.name
                    alias = a.asname or a.name
                    if orig in self.functions and alias not in self.function_aliases:
                        self.function_aliases[alias] = orig
                    # else: class import or unknown name — skip silently

    def register_type_aliases(self):
        """Detect module-level type aliases like MyList = list[int] and register them."""
        known = set(self.classes.keys())
        for mod in self.modules:
            for node in mod.body:
                if not (isinstance(node, ast.Assign) and
                        len(node.targets) == 1 and
                        isinstance(node.targets[0], ast.Name)):
                    continue
                name = node.targets[0].id
                if name in self.type_aliases:
                    continue
                try:
                    alias_t = annotation_to_type(node.value, known)
                    self.type_aliases[name] = alias_t
                except TranspileError:
                    pass

    def is_main_guard(self, test: ast.expr) -> bool:
        if isinstance(test, ast.Compare):
            if isinstance(test.left, ast.Name) and test.left.id == "__name__":
                if len(test.ops) == 1 and isinstance(test.ops[0], ast.Eq):
                    r = test.comparators[0] if test.comparators else None
                    return isinstance(r, ast.Constant) and r.value == "__main__"
        return False

    def find_main_guard(self):
        # Only search in the user's entry module (first module)
        if not self.modules:
            return
        for node in self.modules[0].body:
            if isinstance(node, ast.If) and self.is_main_guard(node.test):
                self.main_guard_body = node.body
                return

    def transpile_function(self, f: ast.FunctionDef):
        if self._is_stub_function(f):
            return
        if any((isinstance(d, ast.Name) and d.id == "overload") or
               (isinstance(d, ast.Attribute) and d.attr == "overload")
               for d in f.decorator_list):
            return
        name = f.name
        if name not in self.functions:
            return  # not registered (skipped due to missing types)
        ret, params = self.functions[name]
        scope = Scope(parent=self.global_scope)

        n_extra = (1 if f.args.kwarg else 0)
        has_vararg = bool(params) and len(params) > n_extra and params[-(1 + n_extra)][0].startswith("vararg[")
        regular_params = params[:len(params) - (1 if has_vararg else 0) - n_extra]
        regular_args = list(f.args.args) + list(f.args.kwonlyargs)

        param_strs = []
        for arg, (t, default_node) in zip(regular_args, regular_params):
            scope.define(arg.arg, t)
            cpp_t = self.cpp_type(t)
            # Use const& for polymorphic class types to prevent slicing
            if t in self.classes and self._class_is_polymorphic(t):
                cpp_t = f"const {cpp_t}&"
            if default_node is not None:
                dc, _ = self.infer_expr(default_node, scope)
                param_strs.append(f"{cpp_t} {arg.arg} = {dc}")
            else:
                param_strs.append(f"{cpp_t} {arg.arg}")

        if has_vararg and f.args.vararg:
            vararg_node = f.args.vararg
            vararg_idx = -(1 + n_extra)
            elem_t = params[vararg_idx][0][7:-1]      # "vararg[T]" → T
            list_t = f"list[{elem_t}]"
            scope.define(vararg_node.arg, list_t)
            param_strs.append(f"{self.cpp_type(list_t)} {vararg_node.arg}")

        # **kwargs
        if f.args.kwarg:
            kwarg_name = f.args.kwarg.arg
            # kwargs type is the last param in params
            kwarg_type = params[-1][0] if params else "dict[string,string]"
            scope.define(kwarg_name, kwarg_type)
            param_strs.append(f"{self.cpp_type(kwarg_type)} {kwarg_name} = {{}}")

        # Emit template prefix if any param or return type is a TypeVar
        all_types = [ret] + [t for t, _ in params]
        tvars_used = sorted({t for t in all_types if t in self.type_vars})
        if tvars_used:
            self.emit(f"template<{', '.join('typename ' + t for t in tvars_used)}>")

        is_gen = self._is_generator(f)
        self.emit(f"{self.cpp_type(ret)} {name}({', '.join(param_strs)})" + " {")
        self.indent()

        if is_gen:
            if not ret.startswith("list["):
                raise TranspileError(
                    f"Generator '{name}' return annotation must be Generator[T]/Iterator[T]"
                )
            self._generator_yield_type = element_type(ret)
            self.emit(f"{self.cpp_type(ret)} _result;")

        for stmt in f.body:
            self.transpile_stmt(stmt, scope, func_return=ret)

        if is_gen:
            self.emit("return _result;")
            self._generator_yield_type = None

        self.dedent()
        self.emit("}")
        self.emit("")

    # ---- entry point ----

    def transpile(self) -> str:
        # --- Analysis passes first (before emitting anything) ---
        self.validate_imports()
        self.register_type_vars()              # T = TypeVar('T')
        self._register_global_scope()          # makes globals visible to class/function bodies
        self.register_class_signatures()
        self.register_type_aliases()           # MyList = list[int] etc.
        self.register_function_signatures()   # populates extra_includes, preamble_lines
        self.register_import_aliases()
        self.find_main_guard()

        # --- Standard headers ---
        for inc in [
            "#include <iostream>", "#include <string>", "#include <vector>",
            "#include <deque>", "#include <tuple>", "#include <optional>",
            "#include <variant>", "#include <functional>",
            "#include <unordered_map>", "#include <unordered_set>",
            "#include <map>",
            "#include <stdexcept>", "#include <cmath>",
            "#include <algorithm>", "#include <cctype>",
            "#include <sstream>", "#include <iomanip>",
            "#include <cstdint>",
        ]:
            self.emit(inc)
        for inc in self.extra_includes:
            self.emit(f"#include {inc}")
        self.emit("")
        if self._needs_stop_iteration:
            self.emit("struct _StopIteration_ {};")
            self.emit("")

        # --- Module-level global variables (before classes so methods can reference them) ---
        self.transpile_global_vars()

        # --- Classes (before preambles so preamble code can reference them) ---
        for mod in self.modules:
            _, _, _, is_stub = self._load_stub_meta(mod)
            if is_stub:
                continue
            for node in mod.body:
                if isinstance(node, ast.ClassDef):
                    saved_len = len(self.lines)
                    saved_indent = self.indent_level
                    saved_class = self.current_class
                    try:
                        self.transpile_class(node)
                    except TranspileError as e:
                        del self.lines[saved_len:]
                        self.indent_level = saved_indent
                        self.current_class = saved_class
                        self._skipped_classes[node.name] = f"line {node.lineno}: {e}"

        # --- Stub preambles (helper namespaces / global state, can reference emitted classes) ---
        for preamble in self.preamble_lines:
            for line in preamble.strip().splitlines():
                self.emit(line)
            self.emit("")

        # --- Build forward declaration list (emitted after function transpilation) ---
        fwd_lines: List[str] = []
        for mod in self.modules:
            _, _, _, is_stub = self._load_stub_meta(mod)
            if is_stub:
                continue
            for node in mod.body:
                if not isinstance(node, ast.FunctionDef):
                    continue
                if self._is_stub_function(node):
                    continue
                if any((isinstance(d, ast.Name) and d.id == "overload") or
                       (isinstance(d, ast.Attribute) and d.attr == "overload")
                       for d in node.decorator_list):
                    continue
                name = node.name
                if name not in self.functions:
                    continue
                ret, params = self.functions[name]
                n_extra = (1 if node.args.kwarg else 0)
                has_vararg = bool(params) and len(params) > n_extra and params[-(1 + n_extra)][0].startswith("vararg[")
                # regular_params excludes both vararg and kwargs trailing params
                regular_params = params[:len(params) - (1 if has_vararg else 0) - n_extra]
                regular_args = list(node.args.args) + list(node.args.kwonlyargs)
                param_strs = []
                for arg, (t, _) in zip(regular_args, regular_params):
                    cpp_t = self.cpp_type(t)
                    if t in self.classes and self._class_is_polymorphic(t):
                        cpp_t = f"const {cpp_t}&"
                    param_strs.append(f"{cpp_t} {arg.arg}")
                if has_vararg and node.args.vararg:
                    vararg_idx = -(1 + n_extra)
                    elem_t = params[vararg_idx][0][7:-1]
                    param_strs.append(f"{self.cpp_type(f'list[{elem_t}]')} {node.args.vararg.arg}")
                if node.args.kwarg:
                    kwarg_type = params[-1][0] if params else "dict[string,string]"
                    param_strs.append(f"{self.cpp_type(kwarg_type)} {node.args.kwarg.arg}")
                all_types = [ret] + [t for t, _ in params]
                tvars_used = sorted({t for t in all_types if t in self.type_vars})
                if tvars_used:
                    fwd_lines.append(f"template<{', '.join('typename ' + t for t in tvars_used)}>")
                fwd_lines.append(f"{self.cpp_type(ret)} {name}({', '.join(param_strs)});")

        # --- Functions (stubs are skipped inside transpile_function) ---
        for mod in self.modules:
            for node in mod.body:
                if isinstance(node, ast.FunctionDef):
                    saved_len = len(self.lines)
                    saved_indent = self.indent_level
                    try:
                        self.transpile_function(node)
                    except TranspileError as e:
                        del self.lines[saved_len:]
                        self.indent_level = saved_indent
                        self._skipped_functions[node.name] = f"line {node.lineno}: {e}"

        # --- Emit forward declarations (skip functions that failed to transpile) ---
        if fwd_lines:
            i = 0
            while i < len(fwd_lines):
                line = fwd_lines[i]
                # Skip template line + declaration line if either contains a skipped function name
                any_skip = any(name in line for name in self._skipped_functions)
                if any_skip:
                    # Remove preceding template<...> line if present
                    i += 1
                    continue
                # Check if next line is a declaration after a template and should be skipped
                if line.startswith("template"):
                    next_i = i + 1
                    if next_i < len(fwd_lines) and any(
                        name in fwd_lines[next_i] for name in self._skipped_functions
                    ):
                        i += 2
                        continue
                self.emit(line)
                i += 1
            self.emit("")

        # --- Warnings for skipped items ---
        for name, reason in self._skipped_classes.items():
            self.lines.append(f"// [Viper skip] Class '{name}' skipped: {reason}")
        for name, reason in self._skipped_functions.items():
            self.lines.append(f"// [Viper skip] Function '{name}' skipped: {reason}")
        if self._skipped_classes or self._skipped_functions:
            self.lines.append("")

        # --- main() ---
        if self.main_guard_body is not None:
            self.emit("int main() {")
            self.indent()
            scope = Scope(parent=self.global_scope)
            for stmt in self.main_guard_body:
                self.transpile_stmt(stmt, scope)
            self.emit("return 0;")
            self.dedent()
            self.emit("}")
        elif "main" in self.functions:
            self.emit("int main() {")
            self.indent()
            self.emit("main();")
            self.emit("return 0;")
            self.dedent()
            self.emit("}")
        else:
            self.emit("int main() { return 0; }")

        return "\n".join(self.lines)