Module: l0_c_emitter

Source: compiler/stage1_py/l0_c_emitter.py Language: Python

Symbols

• l0_c_emitter
• l0_c_emitter::CCodeBuilder
• l0_c_emitter::CEmitter

Namespace l0_c_emitter

Class l0_c_emitter::CCodeBuilder

Helper for building C code with indentation tracking.

Member Data l0_c_emitter.CCodeBuilder.lines

List lines

Member Data l0_c_emitter.CCodeBuilder.indent_level

int indent_level

Member Data l0_c_emitter.CCodeBuilder.indent_str

str indent_str

Member Data l0_c_emitter.CCodeBuilder.lines

l0_c_emitter.CCodeBuilder::lines

Function l0_c_emitter.CCodeBuilder.indent

None l0_c_emitter.CCodeBuilder.indent(self)

Increase the indentation level.

Function l0_c_emitter.CCodeBuilder.dedent

None l0_c_emitter.CCodeBuilder.dedent(self)

Decrease the indentation level.

Function l0_c_emitter.CCodeBuilder.emit

None l0_c_emitter.CCodeBuilder.emit(self, str line="")

Emit a line with current indentation.

Parameters:

• line: The C code line to emit. If empty, emits a blank line.

  Function l0_c_emitter.CCodeBuilder.emit_raw

None l0_c_emitter.CCodeBuilder.emit_raw(self, str line)

Emit a line without indentation.

Parameters:

• line: The C code line to emit directly.

  Function l0_c_emitter.CCodeBuilder.to_string

str l0_c_emitter.CCodeBuilder.to_string(self)

Combine all lines into a single string.

Returns: The complete C source code string with a trailing newline.

Class l0_c_emitter::CEmitter

C-specific code emitter.

Responsibilities:

• Emit C syntax (knows C keywords, syntax, conventions).

• Name mangling for C.

• Type emission (L0 types -> C types).

• Statement/expression emission to C.

• Cleanup code emission (HOW to clean, not when/why).

Does NOT:

• Make decisions about what to emit.

• Perform semantic analysis.

• Manage scopes or lifetimes (queries backend for this).

Member Data l0_c_emitter.CEmitter.C_KEYWORDS

Set C_KEYWORDS

Member Data l0_c_emitter.CEmitter.analysis

Optional analysis

Member Data l0_c_emitter.CEmitter.current_module

Optional current_module

Member Data l0_c_emitter.CEmitter.out

CCodeBuilder out

Member Data l0_c_emitter.CEmitter._tmp_counter

int _tmp_counter

Member Data l0_c_emitter.CEmitter._active_line_directive

Optional _active_line_directive

Member Data l0_c_emitter.CEmitter._opt_wrappers

Dict _opt_wrappers

Member Data l0_c_emitter.CEmitter._opt_emitted

Set _opt_emitted

Member Data l0_c_emitter.CEmitter.analysis

l0_c_emitter.CEmitter::analysis

Member Data l0_c_emitter.CEmitter._active_line_directive

l0_c_emitter.CEmitter::_active_line_directive

Function l0_c_emitter.CEmitter.set_analysis

None l0_c_emitter.CEmitter.set_analysis(self, AnalysisResult analysis)

Initialize emitter with analysis data.

Parameters:

• analysis: The AnalysisResult containing the compilation products.

  Function l0_c_emitter.CEmitter.get_output

str l0_c_emitter.CEmitter.get_output(self)

Get the generated C code.

Returns: The complete generated C code string.

Function l0_c_emitter.CEmitter.find_variant_decl

Optional[EnumVariant] l0_c_emitter.CEmitter.find_variant_decl(self, str module_name, str enum_name, str variant_name)

Look up an enum variant’s AST declaration.

Parameters:

• module_name: Name of the module containing the enum.
• enum_name: Name of the enum.
• variant_name: Name of the variant to find.

Returns: The EnumVariant node if found, otherwise None.

Function l0_c_emitter.CEmitter.ice

NoReturn l0_c_emitter.CEmitter.ice(self, str message, Optional[object] node=None)

Raise an internal compiler error with context.

Parameters:

• message: Descriptive error message.
• node: Optional AST node to provide source location information.

  Function l0_c_emitter.CEmitter.mangle_struct_name

str l0_c_emitter.CEmitter.mangle_struct_name(self, str module_name, str struct_name)

Mangle a struct name to avoid C namespace collisions.

Parameters:

• module_name: Module name.
• struct_name: L0 struct name.

Returns: Mangled C struct name (e.g., “l0_module_Point”).

Function l0_c_emitter.CEmitter.mangle_enum_name

str l0_c_emitter.CEmitter.mangle_enum_name(self, str module_name, str enum_name)

Mangle an enum name.

Parameters:

• module_name: Module name.
• enum_name: L0 enum name.

Returns: Mangled C enum name.

Function l0_c_emitter.CEmitter.mangle_function_name

str l0_c_emitter.CEmitter.mangle_function_name(self, str module_name, str func_name)

Mangle a function name.

Parameters:

• module_name: Module name.
• func_name: L0 function name.

Returns: Mangled C function name.

Function l0_c_emitter.CEmitter.mangle_let_name

str l0_c_emitter.CEmitter.mangle_let_name(self, str module_name, str let_name)

Mangle a top-level let name to C identifier.

Parameters:

• module_name: Module name.
• let_name: L0 constant name.

Returns: Mangled C identifier.

Function l0_c_emitter.CEmitter.mangle_identifier

str l0_c_emitter.CEmitter.mangle_identifier(self, str name)

Mangle an identifier if it conflicts with C keywords or L0 names.

Used for local variables, parameters, and pattern variables. Appends ‘_v’ suffix to avoid C keyword conflicts. Also mangles names starting with ‘’ or ‘l0’/’L0’ to avoid clashes with runtime names.

Parameters:

• name: The L0 identifier to mangle.

Returns: The safe C identifier.

Function l0_c_emitter.CEmitter.fresh_tmp

str l0_c_emitter.CEmitter.fresh_tmp(self, str kind="tmp")

Generate a unique temporary variable name.

Parameters:

• kind: Category of temporary (e.g., “tmp”, “ptr”, “try”).

Returns: Unique C identifier like “l0_tmp_1”, “l0_ptr_2”, etc.

Function l0_c_emitter.CEmitter.emit_sizeof_type

str l0_c_emitter.CEmitter.emit_sizeof_type(self, Type typ)

Emit C code for sizeof a given L0 type.

Parameters:

• typ: The type to measure.

Returns: A C expression like “((l0_int)sizeof(l0_int))”.

Function l0_c_emitter.CEmitter.emit_ord

str l0_c_emitter.CEmitter.emit_ord(self, str c_enum_expr)

Emit C code for ord(enum_value) intrinsic.

Parameters:

• c_enum_expr: C expression evaluating to an enum value.

Returns: A C expression that extracts the tag field and casts to l0_int.

Function l0_c_emitter.CEmitter.emit_type

str l0_c_emitter.CEmitter.emit_type(self, Type typ)

Convert an L0 Type to its C representation.

Parameters:

• typ: The L0 Type to convert.

Returns: A C type string (e.g., “l0_int”, “struct l0_main_Point*”).

Function l0_c_emitter.CEmitter.is_niche_nullable

bool l0_c_emitter.CEmitter.is_niche_nullable(self, NullableType t)

Public check for niche-optimized (pointer-shaped) nullable types.

Parameters:

• t: The NullableType to check.

Returns: True if the type is represented as a nullable pointer in C.

Function l0_c_emitter.CEmitter.emit_none_value_for_nullable

str l0_c_emitter.CEmitter.emit_none_value_for_nullable(self, NullableType t)

Emit C code for the L0 ‘null’ value of a nullable type.

Parameters:

• t: The NullableType.

Returns: C code string representing the ‘none’ state.

Function l0_c_emitter.CEmitter.emit_some_value_for_nullable

str l0_c_emitter.CEmitter.emit_some_value_for_nullable(self, NullableType t, str c_inner_expr)

Emit C code for wrapping a value in ‘some’ for a nullable type.

Parameters:

• t: The NullableType.
• c_inner_expr: C expression for the inner value.

Returns: C code string representing the ‘some’ state.

Function l0_c_emitter.CEmitter.emit_null_literal

str l0_c_emitter.CEmitter.emit_null_literal(self, Optional[Type] expected_type, *bool for_initializer=False)

Emit a null literal appropriate for the expected type.

Parameters:

• expected_type: The type expected in this context.
• for_initializer: If True, uses C initializer syntax ({0}).

Returns: C code for the null value.

Function l0_c_emitter.CEmitter.emit_widen_int

str l0_c_emitter.CEmitter.emit_widen_int(self, str c_expr, BuiltinType src_type, BuiltinType dst_type)

Emit C code for implicit integer widening.

Parameters:

• c_expr: C expression evaluating to the source value.
• src_type: The smaller source type.
• dst_type: The larger destination type.

Returns: C code string for the widening cast.

Function l0_c_emitter.CEmitter.emit_pointer_type

str l0_c_emitter.CEmitter.emit_pointer_type(self, Type base_type)

Emit C pointer type for a base type.

Parameters:

• base_type: The L0 type to point to.

Returns: C type string (e.g., “l0_int*”).

Function l0_c_emitter.CEmitter.emit_enum_tag

str l0_c_emitter.CEmitter.emit_enum_tag(self, EnumType enum_type, str variant_name)

Emit C tag enum value for an enum variant.

Parameters:

• enum_type: The L0 enum type.
• variant_name: The name of the variant.

Returns: The mangled C enum tag identifier.

Function l0_c_emitter.CEmitter.emit_section_comment

None l0_c_emitter.CEmitter.emit_section_comment(self, str text)

Emit a decorative section comment.

Parameters:

• text: The comment text.

  Function l0_c_emitter.CEmitter.emit_module_comment

None l0_c_emitter.CEmitter.emit_module_comment(self, str module_name)

Emit a module metadata comment.

Parameters:

• module_name: The name of the module.

  Function l0_c_emitter.CEmitter.emit_module_separator

None l0_c_emitter.CEmitter.emit_module_separator(self, str module_name)

Emit a decorative module separator.

Parameters:

• module_name: The name of the module.

  Function l0_c_emitter.CEmitter.emit_unreachable_comment

None l0_c_emitter.CEmitter.emit_unreachable_comment(self)

Emit an unreachable code comment for debugging.

Function l0_c_emitter.CEmitter.emit_unreachable_marker

None l0_c_emitter.CEmitter.emit_unreachable_marker(self, str reason="unreachable")

Emit a runtime panic call for unreachable code paths.

Parameters:

• reason: Description of why the path is unreachable.

  Function l0_c_emitter.CEmitter.emit_header

None l0_c_emitter.CEmitter.emit_header(self)

Emit C header boilerplate, SipHash implementation, and L0 runtime.

Function l0_c_emitter.CEmitter.emit_line_directive

None l0_c_emitter.CEmitter.emit_line_directive(self, Node node, str current_module)

Emit #line directive for debugging generated C.

Parameters:

• node: AST node with span information.
• current_module: Name of the current module.

  Function l0_c_emitter.CEmitter.restore_active_line_directive

None l0_c_emitter.CEmitter.restore_active_line_directive(self)

Re-emit the current source line directive after generated helper lines.

Function l0_c_emitter.CEmitter.emit_forward_decls

None l0_c_emitter.CEmitter.emit_forward_decls(self)

Emit forward declarations for all structs and enums in compilation unit.

Function l0_c_emitter.CEmitter.emit_struct

None l0_c_emitter.CEmitter.emit_struct(self, str module_name, StructDecl decl, StructInfo struct_info)

Emit a complete C struct definition.

Parameters:

• module_name: Name of the module.
• decl: StructDecl AST node.
• struct_info: Resolved type information for the struct.

  Function l0_c_emitter.CEmitter.emit_enum

None l0_c_emitter.CEmitter.emit_enum(self, str module_name, EnumDecl decl, EnumInfo enum_info)

Emit an L0 enum as a C tagged union.

Parameters:

• module_name: Name of the module.
• decl: EnumDecl AST node.
• enum_info: Resolved type information for the enum.

  Function l0_c_emitter.CEmitter.emit_let_declaration

None l0_c_emitter.CEmitter.emit_let_declaration(self, str module_name, LetDecl decl, Type let_type, Callable[[Expr, Type], str] let_initializer_callback)

Emit a single top-level let declaration as a static variable.

Parameters:

• module_name: Module containing the let.
• decl: Let declaration AST node.
• let_type: Resolved type of the let.
• let_initializer_callback: Callback to emit initializer expression string.

  Function l0_c_emitter.CEmitter.emit_top_level_let_cleanup

None l0_c_emitter.CEmitter.emit_top_level_let_cleanup(self)

Emit final cleanup for ARC-managed top-level lets before process exit.

Function l0_c_emitter.CEmitter.emit_function_declaration

None l0_c_emitter.CEmitter.emit_function_declaration(self, str module_name, FuncDecl decl, FuncType func_type)

Emit a single function declaration signature.

Parameters:

• module_name: Name of the module.
• decl: FuncDecl AST node.
• func_type: Resolved signature of the function.

  Function l0_c_emitter.CEmitter.emit_function_definition_header

None l0_c_emitter.CEmitter.emit_function_definition_header(self, str module_name, FuncDecl decl, FuncType func_type)

Emit function definition header (signature and opening brace).

Parameters:

• module_name: Name of the module.
• decl: FuncDecl AST node.
• func_type: Resolved signature of the function.

  Function l0_c_emitter.CEmitter.emit_function_definition_footer

None l0_c_emitter.CEmitter.emit_function_definition_footer(self)

Emit function definition footer (closing brace).

Function l0_c_emitter.CEmitter.emit_main_wrapper

None l0_c_emitter.CEmitter.emit_main_wrapper(self, str entry_module, FuncType func_type)

Emit C main() wrapper that calls the L0 entry function.

Parameters:

• entry_module: Name of the entry module.
• func_type: Resolved signature of the L0 main function.

  Function l0_c_emitter.CEmitter.emit_optional_wrapper_for_defined_type

None l0_c_emitter.CEmitter.emit_optional_wrapper_for_defined_type(self, Type inner)

Emit the collected optional wrapper for a just-defined user type.

Parameters:

• inner: Just-defined struct or enum type.

  Function l0_c_emitter.CEmitter.prepare_optional_wrappers

None l0_c_emitter.CEmitter.prepare_optional_wrappers(self)

Scan all compilation unit types and collect required optional wrappers.

Function l0_c_emitter.CEmitter.emit_optional_wrappers

None l0_c_emitter.CEmitter.emit_optional_wrappers(self, *bool early)

Emit C typedef declarations for collected optional wrapper types.

Parameters:

• early: If True, emit wrappers for builtins only. If False, emit wrappers for user-defined structs/enums.

  Function l0_c_emitter.CEmitter.emit_value_cleanup

None l0_c_emitter.CEmitter.emit_value_cleanup(self, str c_expr, Type ty)

Emit C code to clean up an owned by-value variable.

Parameters:

• c_expr: C expression evaluating to the value.
• ty: The L0 Type of the value.

  Function l0_c_emitter.CEmitter.emit_struct_cleanup

None l0_c_emitter.CEmitter.emit_struct_cleanup(self, str c_ptr_expr, StructType struct_type)

Emit cleanup code for all owned fields in a struct.

Parameters:

• c_ptr_expr: C expression evaluating to a pointer to the struct.
• struct_type: The L0 struct type.

  Function l0_c_emitter.CEmitter.emit_enum_cleanup

None l0_c_emitter.CEmitter.emit_enum_cleanup(self, str c_ptr_expr, EnumType enum_type)

Emit cleanup code for owned fields in an enum’s active variant.

Parameters:

• c_ptr_expr: C expression evaluating to a pointer to the enum.
• enum_type: The L0 enum type.

  Function l0_c_emitter.CEmitter.emit_int_literal

str l0_c_emitter.CEmitter.emit_int_literal(self, int value)

Emit C code for an integer literal.

Parameters:

• value: The integer value.

Returns: C literal string (handles INT32_MIN edge case).

Function l0_c_emitter.CEmitter.emit_byte_literal

str l0_c_emitter.CEmitter.emit_byte_literal(self, str value)

Emit C code for a byte literal.

Parameters:

• value: The byte literal character.

Returns: C casted character literal.

Function l0_c_emitter.CEmitter.emit_string_literal

str l0_c_emitter.CEmitter.emit_string_literal(self, str value)

Emit C code for an ARC string literal.

Parameters:

• value: The L0 string token payload.

Returns: C L0_STRING_CONST expression.

Function l0_c_emitter.CEmitter.emit_const_string_literal

str l0_c_emitter.CEmitter.emit_const_string_literal(self, str value)

Emit C code for a static string literal initializer.

Parameters:

• value: The L0 string token payload.

Returns: C L0_STRING_CONST macro expression.

Function l0_c_emitter.CEmitter.emit_bool_literal

str l0_c_emitter.CEmitter.emit_bool_literal(self, bool value)

Emit C code for a boolean literal expression.

Parameters:

• value: The boolean value.

Returns: “1” for true, “0” for false.

Function l0_c_emitter.CEmitter.emit_const_bool_literal

str l0_c_emitter.CEmitter.emit_const_bool_literal(self, bool value)

Emit C code for a boolean literal in a static initializer.

Parameters:

• value: The boolean value.

Returns: “true” or “false”.

Function l0_c_emitter.CEmitter.emit_var_ref

str l0_c_emitter.CEmitter.emit_var_ref(self, str c_name)

Emit C code for a variable reference identifier.

Parameters:

• c_name: Mangled C identifier.

Returns: The identifier string.

Function l0_c_emitter.CEmitter.emit_unary_op

str l0_c_emitter.CEmitter.emit_unary_op(self, str op, str c_operand)

Emit C code for a unary operation.

Parameters:

• op: C unary operator string.
• c_operand: C expression for the operand.

Returns: C unary expression string.

Function l0_c_emitter.CEmitter.emit_negated_condition

str l0_c_emitter.CEmitter.emit_negated_condition(self, str c_cond)

Emit a negated condition expression for control-flow lowering.

Function l0_c_emitter.CEmitter.emit_binary_op

str l0_c_emitter.CEmitter.emit_binary_op(self, str op, str c_left, str c_right)

Emit C code for a simple binary operation.

Parameters:

• op: C binary operator string.
• c_left: C expression for left operand.
• c_right: C expression for right operand.

Returns: C binary expression string.

Function l0_c_emitter.CEmitter.emit_condition_binary_op

str l0_c_emitter.CEmitter.emit_condition_binary_op(self, str op, str c_left, str c_right)

Emit a top-level binary condition for direct statement headers.

Function l0_c_emitter.CEmitter.emit_checked_int_div

str l0_c_emitter.CEmitter.emit_checked_int_div(self, str c_left, str c_right)

Emit C code for checked integer division runtime call.

Function l0_c_emitter.CEmitter.emit_checked_int_mod

str l0_c_emitter.CEmitter.emit_checked_int_mod(self, str c_left, str c_right)

Emit C code for checked integer modulo runtime call.

Function l0_c_emitter.CEmitter.emit_checked_int_mul

str l0_c_emitter.CEmitter.emit_checked_int_mul(self, str c_left, str c_right)

Emit C code for checked integer multiplication runtime call.

Function l0_c_emitter.CEmitter.emit_checked_int_add

str l0_c_emitter.CEmitter.emit_checked_int_add(self, str c_left, str c_right)

Emit C code for checked integer addition runtime call.

Function l0_c_emitter.CEmitter.emit_checked_int_sub

str l0_c_emitter.CEmitter.emit_checked_int_sub(self, str c_left, str c_right)

Emit C code for checked integer subtraction runtime call.

Function l0_c_emitter.CEmitter.emit_function_call

str l0_c_emitter.CEmitter.emit_function_call(self, str c_func_name, str c_args)

Emit C code for a function call.

Parameters:

• c_func_name: C identifier or expression for the function.
• c_args: Comma-separated C expression string for arguments.

Returns: C function call expression string.

Function l0_c_emitter.CEmitter.emit_field_access

str l0_c_emitter.CEmitter.emit_field_access(self, str c_obj, str field_name, bool is_pointer)

Emit C code for field access using ‘.

’ or ‘->’.

Parameters:

• c_obj: C expression for the object.
• field_name: The field identifier.
• is_pointer: True if the object is a pointer.

Returns: C field access expression string.

Function l0_c_emitter.CEmitter.emit_paren_expr

str l0_c_emitter.CEmitter.emit_paren_expr(self, str c_inner)

Emit C code for a parenthesized expression.

Parameters:

• c_inner: The inner C expression string.

Returns: Parenthesized expression string.

Function l0_c_emitter.CEmitter.emit_cast

str l0_c_emitter.CEmitter.emit_cast(self, str c_type, str c_inner)

Emit C code for a type cast.

Parameters:

• c_type: Target C type string.
• c_inner: Expression to cast.

Returns: C cast expression string.

Function l0_c_emitter.CEmitter.emit_checked_ptr_access

str l0_c_emitter.CEmitter.emit_checked_ptr_access(self, str c_ptr_expr, str c_ptr_type, str c_required_size, str c_required_align, str access_mode="_RT_ACCESS_READ")

Emit a runtime-checked pointer access expression.

Declares one static per-call-site cache slot so the runtime validates repeated accesses from the same site with a single range check.

Function l0_c_emitter.CEmitter.emit_checked_ptr_index_access

str l0_c_emitter.CEmitter.emit_checked_ptr_index_access(self, str c_base_expr, str c_index_expr, str c_ptr_type, str c_element_size, str c_required_align, str access_mode="_RT_ACCESS_READ")

Emit a runtime-checked indexed pointer access expression.

Function l0_c_emitter.CEmitter.emit_checked_ptr_access_for_base

str l0_c_emitter.CEmitter.emit_checked_ptr_access_for_base(self, str c_ptr_expr, str c_base_type, str access_mode="_RT_ACCESS_READ")

Emit a runtime-checked pointer to a complete object of c_base_type .

Function l0_c_emitter.CEmitter.emit_drop_begin_expr

str l0_c_emitter.CEmitter.emit_drop_begin_expr(self, str c_ptr_expr, str c_ptr_type, str c_required_size, str c_required_align)

Emit the expression that validates and begins a generated drop.

Function l0_c_emitter.CEmitter.emit_drop_finish_call

None l0_c_emitter.CEmitter.emit_drop_finish_call(self, str c_ptr_expr)

Emit the runtime call that completes a generated drop.

Function l0_c_emitter.CEmitter.emit_checked_narrow_cast

str l0_c_emitter.CEmitter.emit_checked_narrow_cast(self, str c_dst_type, str c_inner)

Emit C code for a checked narrowing cast runtime call.

Function l0_c_emitter.CEmitter.emit_unwrap_ptr

str l0_c_emitter.CEmitter.emit_unwrap_ptr(self, str c_dst_type, str c_inner, str type_str)

Emit C code for unwrapping a pointer-shaped optional runtime check.

Function l0_c_emitter.CEmitter.emit_unwrap_opt

str l0_c_emitter.CEmitter.emit_unwrap_opt(self, str c_src_type, str c_inner, str type_str)

Emit C code for unwrapping a value-optional runtime check.

Function l0_c_emitter.CEmitter.emit_null_check_eq

str l0_c_emitter.CEmitter.emit_null_check_eq(self, str c_expr)

Emit C code for null equality check (opt == null).

Function l0_c_emitter.CEmitter.emit_null_check_ne

str l0_c_emitter.CEmitter.emit_null_check_ne(self, str c_expr)

Emit C code for null inequality check (opt != null).

Function l0_c_emitter.CEmitter.emit_pointer_null_check

str l0_c_emitter.CEmitter.emit_pointer_null_check(self, str c_expr, str op)

Emit C code for pointer null comparison.

Parameters:

• c_expr: C expression for the pointer.
• op: Comparison operator (e.g., “==”, “!=”).

Returns: C comparison expression string.

Function l0_c_emitter.CEmitter.emit_condition_pointer_null_check

str l0_c_emitter.CEmitter.emit_condition_pointer_null_check(self, str c_expr, str op)

Emit a top-level pointer null comparison for direct statement headers.

Function l0_c_emitter.CEmitter.emit_optional_has_value

str l0_c_emitter.CEmitter.emit_optional_has_value(self, str c_expr)

Emit C code for reading an optional wrapper’s has-value flag.

Function l0_c_emitter.CEmitter.emit_optional_value

str l0_c_emitter.CEmitter.emit_optional_value(self, str c_expr)

Emit C code for reading an optional wrapper’s payload value.

Function l0_c_emitter.CEmitter.emit_enum_tag_access

str l0_c_emitter.CEmitter.emit_enum_tag_access(self, str c_expr)

Emit C code for reading an enum tag.

Function l0_c_emitter.CEmitter.emit_enum_payload_field_access

str l0_c_emitter.CEmitter.emit_enum_payload_field_access(self, str c_expr, str variant, str field)

Emit C code for reading a field from an enum payload.

Function l0_c_emitter.CEmitter.emit_string_equals_call

str l0_c_emitter.CEmitter.emit_string_equals_call(self, str lhs, str rhs)

Emit the runtime string-equality helper call.

Function l0_c_emitter.CEmitter.emit_string_concat_call

str l0_c_emitter.CEmitter.emit_string_concat_call(self, str lhs, str rhs)

Emit the runtime string-concatenation helper call.

Function l0_c_emitter.CEmitter.emit_string_compare_call

str l0_c_emitter.CEmitter.emit_string_compare_call(self, str op, str lhs, str rhs)

Emit the runtime string-compare helper call wrapped in a relational check.

Function l0_c_emitter.CEmitter.emit_condition_string_compare_call

str l0_c_emitter.CEmitter.emit_condition_string_compare_call(self, str op, str lhs, str rhs)

Emit a top-level string relational check for direct statement headers.

Function l0_c_emitter.CEmitter.emit_discard_expr

str l0_c_emitter.CEmitter.emit_discard_expr(self, str c_expr)

Emit a statement-context discard wrapper for an expression.

Function l0_c_emitter.CEmitter.emit_deref_lvalue

str l0_c_emitter.CEmitter.emit_deref_lvalue(self, str ptr_expr)

Emit C code for a dereference lvalue: (*ptr).

Function l0_c_emitter.CEmitter.emit_field_lvalue

str l0_c_emitter.CEmitter.emit_field_lvalue(self, str obj, str field, bool is_pointer)

Emit C code for a field access lvalue.

Function l0_c_emitter.CEmitter.emit_index_lvalue

str l0_c_emitter.CEmitter.emit_index_lvalue(self, str base, str index)

Emit C code for an index lvalue: base[idx].

Function l0_c_emitter.CEmitter.emit_struct_constructor

str l0_c_emitter.CEmitter.emit_struct_constructor(self, str c_struct_name, List[Tuple[str, str]] field_inits)

Emit C code for a struct compound literal constructor.

Parameters:

• c_struct_name: Mangled C struct name.
• field_inits: List of (field_name, c_value) tuples.

Returns: C compound literal: (struct name){ .f1 = v1, .f2 = v2 }.

Function l0_c_emitter.CEmitter.emit_struct_static_initializer

str l0_c_emitter.CEmitter.emit_struct_static_initializer(self, List[Tuple[str, str]] field_inits)

Emit a brace-only struct initializer for static storage duration.

Function l0_c_emitter.CEmitter.emit_struct_constructor_for_type

str l0_c_emitter.CEmitter.emit_struct_constructor_for_type(self, StructType struct_type, List[Tuple[str, str]] field_inits)

Emit a C struct constructor for an L0 struct type.

Function l0_c_emitter.CEmitter.emit_struct_static_initializer_for_type

str l0_c_emitter.CEmitter.emit_struct_static_initializer_for_type(self, StructType struct_type, List[Tuple[str, str]] field_inits)

Emit a static-storage struct initializer for an L0 struct type.

Function l0_c_emitter.CEmitter.emit_variant_constructor

str l0_c_emitter.CEmitter.emit_variant_constructor(self, str c_enum_name, str variant_name, str tag_value, List[Tuple[str, str]] payload_inits)

Emit C code for an enum variant tagged union literal.

Parameters:

• c_enum_name: Mangled C enum name.
• variant_name: Name of the variant.
• tag_value: C tag value.
• payload_inits: List of (field_name, c_value) tuples for payload.

Returns: C tagged union literal string.

Function l0_c_emitter.CEmitter.emit_variant_static_initializer

str l0_c_emitter.CEmitter.emit_variant_static_initializer(self, str variant_name, str tag_value, List[Tuple[str, str]] payload_inits)

Emit a brace-only enum tagged-union initializer for static storage duration.

Function l0_c_emitter.CEmitter.emit_variant_constructor_for_type

str l0_c_emitter.CEmitter.emit_variant_constructor_for_type(self, EnumType enum_type, str variant_name, List[Tuple[str, str]] payload_inits)

Emit a tagged union constructor for a given L0 enum type.

Function l0_c_emitter.CEmitter.emit_variant_static_initializer_for_type

str l0_c_emitter.CEmitter.emit_variant_static_initializer_for_type(self, EnumType enum_type, str variant_name, List[Tuple[str, str]] payload_inits)

Emit a static-storage tagged union initializer for a given L0 enum type.

Function l0_c_emitter.CEmitter.emit_pattern_binding_init

str l0_c_emitter.CEmitter.emit_pattern_binding_init(self, str scrutinee, str variant, str field)

Emit C code for accessing a variant field during pattern matching.

Parameters:

• scrutinee: Name of the scrutinee variable.
• variant: Name of the variant being matched.
• field: Name of the payload field being extracted.

Returns: C field access expression string.

Function l0_c_emitter.CEmitter.emit_expr_stmt

None l0_c_emitter.CEmitter.emit_expr_stmt(self, str c_expr)

Emit an expression as a statement.

Parameters:

• c_expr: C expression string.

  Function l0_c_emitter.CEmitter.emit_return_stmt

None l0_c_emitter.CEmitter.emit_return_stmt(self, Optional[str] c_value)

Emit a C return statement.

Parameters:

• c_value: Optional C expression string to return.

  Function l0_c_emitter.CEmitter.emit_exit_switch

None l0_c_emitter.CEmitter.emit_exit_switch(self)

Emit a C break statement to exit a switch block.

Function l0_c_emitter.CEmitter.emit_label

None l0_c_emitter.CEmitter.emit_label(self, str label)

Emit a C label followed by a null statement.

Parameters:

• label: C label identifier.

  Function l0_c_emitter.CEmitter.emit_goto

None l0_c_emitter.CEmitter.emit_goto(self, str label)

Emit a C goto statement.

Parameters:

• label: Target C label identifier.

  Function l0_c_emitter.CEmitter.emit_block_start

None l0_c_emitter.CEmitter.emit_block_start(self)

Emit an opening brace and increase indentation.

Function l0_c_emitter.CEmitter.emit_block_end

None l0_c_emitter.CEmitter.emit_block_end(self)

Emit a closing brace and decrease indentation.

Function l0_c_emitter.CEmitter.emit_while_header

None l0_c_emitter.CEmitter.emit_while_header(self, str c_cond)

Emit a C while loop header.

Parameters:

• c_cond: C expression for the loop condition.

  Function l0_c_emitter.CEmitter.emit_if_header

None l0_c_emitter.CEmitter.emit_if_header(self, str c_cond)

Emit a C if statement header.

Parameters:

• c_cond: C expression for the condition.

  Function l0_c_emitter.CEmitter.emit_else

None l0_c_emitter.CEmitter.emit_else(self)

Emit a C else keyword.

Function l0_c_emitter.CEmitter.emit_for_loop_start

None l0_c_emitter.CEmitter.emit_for_loop_start(self)

Emit a decorative comment and opening brace for a for loop block.

Function l0_c_emitter.CEmitter.emit_for_loop_end

None l0_c_emitter.CEmitter.emit_for_loop_end(self)

Emit closing brace for a for loop block.

Function l0_c_emitter.CEmitter.emit_let_decl

None l0_c_emitter.CEmitter.emit_let_decl(self, str c_type, str c_var_name, str c_init)

Emit a C local variable declaration with initializer.

Parameters:

• c_type: C type string.
• c_var_name: C identifier.
• c_init: C initializer expression string.

  Function l0_c_emitter.CEmitter.emit_assignment

None l0_c_emitter.CEmitter.emit_assignment(self, str c_target, str c_value)

Emit a simple C assignment statement.

Parameters:

• c_target: C lvalue expression.
• c_value: C expression for the value.

  Function l0_c_emitter.CEmitter.emit_pointer_assignment

None l0_c_emitter.CEmitter.emit_pointer_assignment(self, str c_ptr_name, str c_value)

Emit a C assignment through a pointer.

Parameters:

• c_ptr_name: C expression evaluating to a pointer.
• c_value: C expression for the value.

  Function l0_c_emitter.CEmitter.emit_checked_pointer_assignment

None l0_c_emitter.CEmitter.emit_checked_pointer_assignment(self, str c_ptr_name, str c_base_type, str c_value)

Emit an assignment through a runtime-checked object pointer.

Function l0_c_emitter.CEmitter.emit_temp_decl

None l0_c_emitter.CEmitter.emit_temp_decl(self, str c_type, str c_temp_name, str c_value)

Emit a C temporary variable declaration with initializer.

Parameters:

• c_type: C type string.
• c_temp_name: C identifier for temporary.
• c_value: C initializer expression string.

  Function l0_c_emitter.CEmitter.emit_string_retain

None l0_c_emitter.CEmitter.emit_string_retain(self, str c_expr)

Emit an ARC string retain runtime call.

Parameters:

• c_expr: C expression evaluating to an l0_string.

  Function l0_c_emitter.CEmitter.emit_string_release

None l0_c_emitter.CEmitter.emit_string_release(self, str c_expr)

Emit an ARC string release runtime call.

Parameters:

• c_expr: C expression evaluating to an l0_string.

  Function l0_c_emitter.CEmitter.emit_comment

None l0_c_emitter.CEmitter.emit_comment(self, str comment)

Emit a C block comment.

Parameters:

• comment: The comment text.

  Function l0_c_emitter.CEmitter.emit_match_scrutinee_decl

None l0_c_emitter.CEmitter.emit_match_scrutinee_decl(self, str c_type, str c_expr)

Emit the scrutinee declaration for a match/case statement.

Parameters:

• c_type: C type string of scrutinee.
• c_expr: C expression for scrutinee value.

  Function l0_c_emitter.CEmitter.emit_switch_start

None l0_c_emitter.CEmitter.emit_switch_start(self, str c_expr)

Emit a C switch statement header and opening brace.

Parameters:

• c_expr: C expression to switch on.

  Function l0_c_emitter.CEmitter.emit_match_switch_start

None l0_c_emitter.CEmitter.emit_match_switch_start(self, str scrutinee_name)

Emit a match switch over an enum tag.

Parameters:

• scrutinee_name: Identifier of the scrutinee variable.

  Function l0_c_emitter.CEmitter.emit_switch_end

None l0_c_emitter.CEmitter.emit_switch_end(self)

Emit a C switch statement closing brace.

Function l0_c_emitter.CEmitter.emit_case_label

None l0_c_emitter.CEmitter.emit_case_label(self, str c_tag_value)

Emit a C case label.

Parameters:

• c_tag_value: The constant C tag identifier or literal.

  Function l0_c_emitter.CEmitter.emit_default_label

None l0_c_emitter.CEmitter.emit_default_label(self)

Emit a C default case label.

Function l0_c_emitter.CEmitter.emit_null_assignment

None l0_c_emitter.CEmitter.emit_null_assignment(self, str c_var)

Emit a NULL assignment to a variable.

Parameters:

• c_var: C lvalue expression.

  Function l0_c_emitter.CEmitter.emit_alloc_obj

None l0_c_emitter.CEmitter.emit_alloc_obj(self, str c_ptr_type, str c_base_type, str c_temp_name)

Emit a heap allocation runtime call.

Parameters:

• c_ptr_type: C pointer type string.
• c_base_type: C base object type string.
• c_temp_name: Name of temporary to hold the pointer.

  Function l0_c_emitter.CEmitter.emit_struct_init

None l0_c_emitter.CEmitter.emit_struct_init(self, str c_temp_name, str c_base_type, str c_init_str)

Emit an object initialization through a pointer.

Parameters:

• c_temp_name: Name of the pointer variable.
• c_base_type: C base object type string.
• c_init_str: C compound initializer body.

  Function l0_c_emitter.CEmitter.emit_struct_init_from_fields

None l0_c_emitter.CEmitter.emit_struct_init_from_fields(self, str c_temp_name, Type base_type, List[Tuple[str, str]] field_inits)

Emit struct initialization using positional field values.

Parameters:

• c_temp_name: Name of the pointer variable.
• base_type: L0 base object type.
• field_inits: List of (field_name, c_value) tuples.

  Function l0_c_emitter.CEmitter.emit_enum_variant_init

None l0_c_emitter.CEmitter.emit_enum_variant_init(self, str c_temp_name, EnumType enum_type, str variant_name, List[Tuple[str, str]] payload_inits)

Emit enum variant initialization for a heap-allocated enum.

Parameters:

• c_temp_name: Name of the pointer variable.
• enum_type: L0 enum type.
• variant_name: Name of the active variant.
• payload_inits: List of (field_name, c_value) tuples for payload.

  Function l0_c_emitter.CEmitter.emit_zero_init

None l0_c_emitter.CEmitter.emit_zero_init(self, str c_temp_name, str c_base_type)

Emit zero-initialization through a pointer.

Parameters:

• c_temp_name: Name of the pointer variable.
• c_base_type: C base object type string.

  Function l0_c_emitter.CEmitter.emit_try_check_niche

None l0_c_emitter.CEmitter.emit_try_check_niche(self, str c_tmp, str ret_none)

Emit a NULL check for a niche-optimized optional.

Parameters:

• c_tmp: C identifier of the temporary holding the optional.
• ret_none: C expression for the ‘none’ return value.

  Function l0_c_emitter.CEmitter.emit_try_check_value

None l0_c_emitter.CEmitter.emit_try_check_value(self, str c_tmp, str ret_none)

Emit a has_value check for a value-optional.

Parameters:

• c_tmp: C identifier of the temporary holding the optional.
• ret_none: C expression for the ‘none’ return value.

  Function l0_c_emitter.CEmitter.emit_try_extract_value

str l0_c_emitter.CEmitter.emit_try_extract_value(self, str c_tmp)

Emit C code to extract the inner value from an optional.

Parameters:

• c_tmp: C identifier of the temporary holding the optional.

Returns: C expression string for the extracted value.

Function l0_c_emitter.CEmitter._is_niche_nullable

bool l0_c_emitter.CEmitter._is_niche_nullable(self, NullableType t)

Check if a nullable type uses niche optimization (pointer-shaped).

Function l0_c_emitter.CEmitter._opt_key_for_type

str l0_c_emitter.CEmitter._opt_key_for_type(self, Type t)

Generate a unique key for an optional wrapper type name.

Function l0_c_emitter.CEmitter._opt_wrapper_name_for_inner

str l0_c_emitter.CEmitter._opt_wrapper_name_for_inner(self, Type inner)

Generate C typedef name for optional wrapper of given inner type.

Function l0_c_emitter.CEmitter._collect_opt_wrappers_from_type

None l0_c_emitter.CEmitter._collect_opt_wrappers_from_type(self, Type t)

Recursively collect optional wrapper types needed.

Function l0_c_emitter.CEmitter._is_early_inner

bool l0_c_emitter.CEmitter._is_early_inner(self, Type inner)

Check if an inner type wrapper can be emitted before user definitions.

Function l0_c_emitter.CEmitter._emit_optional_wrapper

None l0_c_emitter.CEmitter._emit_optional_wrapper(self, str name, Type inner)

Emit one collected optional wrapper typedef.

Parameters:

• name: Wrapper typedef name.
• inner: Inner wrapped type.

  Function l0_c_emitter.CEmitter._emit_cleanup_by_type

None l0_c_emitter.CEmitter._emit_cleanup_by_type(self, str c_expr, Type ty)

Emit recursive cleanup code for any ARC-managed data inside a type.

Parameters:

• c_expr: C expression evaluating to the by-value object to clean up.
• ty: The L0 type describing c_expr.

See also:

• emit_value_cleanup: Public entry point for by-value cleanup emission. _emit_enum_value_cleanup: Handles enum-specific cleanup lowering.

  Function l0_c_emitter.CEmitter._emit_enum_value_cleanup

None l0_c_emitter.CEmitter._emit_enum_value_cleanup(self, str c_expr, EnumType enum_type)

Emit C cleanup code for an enum by-value variable.

Function l0_c_emitter.CEmitter._emit_enum_cleanup_switch

None l0_c_emitter.CEmitter._emit_enum_cleanup_switch(self, EnumType enum_type, str c_tag_expr, Callable[[str, str], str] field_expr_for_variant_field, *bool missing_info_is_ice)

Emit a cleanup switch over the active variant of an enum value.

Parameters:

• enum_type: Enum type whose payload cleanup is being emitted.
• c_tag_expr: C expression yielding the enum tag to switch on.
• field_expr_for_variant_field: Callback that maps variant and field names to the corresponding C lvalue expression.
• missing_info_is_ice: Whether missing enum metadata should raise an internal compiler error.

See also:

• _emit_enum_value_cleanup: Uses this helper for by-value enum cleanup. _iter_variant_cleanup_fields: Supplies the field names paired with types.

  Function l0_c_emitter.CEmitter._iter_variant_cleanup_fields

List[Tuple[str, Type]] l0_c_emitter.CEmitter._iter_variant_cleanup_fields(self, EnumType enum_type, str variant_name, List[Type] variant_field_types)

Pair variant field names with their resolved field types.

Parameters:

• enum_type: Enum type owning the variant.
• variant_name: Variant whose fields are being cleaned up.
• variant_field_types: Resolved payload field types for the variant.

Returns: A list of “(field_name, field_type)” pairs, or an empty list when the AST declaration cannot be matched to the resolved payload types.

See also:

• find_variant_decl: Retrieves the source declaration used for field names. _emit_enum_cleanup_switch: Consumes these pairs to emit cleanup code.

  Function l0_c_emitter.CEmitter._enum_has_arc_data

bool l0_c_emitter.CEmitter._enum_has_arc_data(self, EnumInfo enum_info)

Report whether any enum payload field requires ARC-aware cleanup.

Parameters:

• enum_info: Resolved enum metadata to inspect.

Returns: True if any variant payload contains ARC-managed data.

See also:

• _emit_enum_cleanup_switch: Skips switch emission when this is false.

  Function l0_c_emitter.CEmitter._get_struct_info

Optional[StructInfo] l0_c_emitter.CEmitter._get_struct_info(self, StructType struct_type, *bool strict)

Look up resolved metadata for a struct type.

Parameters:

• struct_type: Struct type whose metadata is needed.
• strict: Whether a missing entry should raise an internal compiler error.

Returns: The matching StructInfo when available, otherwise None.

See also:

• emit_struct_cleanup: Requires strict struct metadata during emission.

  Function l0_c_emitter.CEmitter._get_enum_info

Optional[EnumInfo] l0_c_emitter.CEmitter._get_enum_info(self, EnumType enum_type, *bool strict)

Look up resolved metadata for an enum type.

Parameters:

• enum_type: Enum type whose metadata is needed.
• strict: Whether a missing entry should raise an internal compiler error.

Returns: The matching EnumInfo when available, otherwise None.

See also:

• _emit_enum_cleanup_switch: Uses enum metadata to enumerate payload fields.

  Function l0_c_emitter.CEmitter._emit_field_cleanup

None l0_c_emitter.CEmitter._emit_field_cleanup(self, str field_expr, Type field_type)

Emit recursive cleanup for a field.

Function l0_c_emitter.CEmitter._string_token_to_c_bytes_and_len

tuple[str, int] l0_c_emitter.CEmitter._string_token_to_c_bytes_and_len(self, str value)

Decode an L0 string token payload and encode as C string-literal bytes.