Class CppEmitter

python/little_kernel/codegen/codegen_base.py:39–272

C++ code emitter with context-aware LLType resolution and scope tracking. - Avoids redundant type declarations for in-scope variables (parameters/previous assignments) - Enforces basic type safety for reassignments - Resolves namespace aliases via user-provided context (e.g., 'lk.ui

class CppEmitter(ExpressionCodegenMixin, StatementCodegenMixin, ControlFlowCodegenMixin, CallCodegenMixin,
                 ast.NodeVisitor):
    """
    C++ code emitter with context-aware LLType resolution and scope tracking.
    - Avoids redundant type declarations for in-scope variables (parameters/previous assignments)
    - Enforces basic type safety for reassignments
    - Resolves namespace aliases via user-provided context (e.g., 'lk.uint32')
    """

    def __init__(self, ctx: Dict[str, object], all_types=None):
        """
        Initialize the C++ emitter with a user-provided context.
        
        Args:
            ctx: A dictionary representing the namespace context (e.g., function.__globals__).
                 Must contain the alias used to import `little_kernel.language` (e.g., 'll' or 'lk').
        """
        # Code buffers (headers -> structs -> main code)
        self.header_buffer = StringIO()
        self.header_cache = set()
        self.struct_buffer = StringIO()
        self.main_buffer = StringIO()
        self.builtin_buffer = StringIO()
        self.builtin_cache = set()
        self.builtin_body_cache = set()  # Track emitted function names to prevent duplicates

        # State management
        self.indent_level = 0
        self.indent_unit = "    "  # 4-space indentation

        # LLType tracking: StructType -> C++ struct name
        self.struct_types: Dict["ll.StructType", str] = {}

        # Special struct tracking: Track which special structs are used
        self.used_special_structs: set = set()

        # Enum tracking: Track which Enum types are used
        self.used_enums: set = set()

        # Context & annotation cache
        self.ctx = ctx  # User's namespace (for alias resolution)
        self.annotation_cache: Dict[ast.AST, "ll.LLType"] = {}

        # Scope tracking: Maps variable names to their LLType (per function scope)
        # Reset when entering/exiting a FunctionDef
        self.scope_vars: Dict[str, "ll.LLType"] = {}
        self.all_types = all_types if all_types is not None else {}

        # Add required C++ headers
        self._add_basic_headers()

        # Validate context (ensure LLType-related objects are present)
        self._validate_context()

    def _add_basic_headers(self) -> None:
        """Add C++ headers for std types."""
        headers = [
            "<cstdint>",  # For stdint types (uint32_t, int64_t)