types.c

Go to the documentation of this file.

 
#include "common/infix_internals.h"
#include "common/utility.h"
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Static Descriptors for Primitive and Built-in Types
 
#define INFIX_MAX_ALIGNMENT (1024 * 1024)  // 1MB Safety Limit
 
#define INFIX_TYPE_INIT(id, T)         \
    {.name = nullptr,                  \
     .category = INFIX_TYPE_PRIMITIVE, \
     .size = sizeof(T),                \
     .alignment = _Alignof(T),         \
     .is_arena_allocated = false,      \
     .arena = nullptr,                 \
     .source_offset = 0,               \
     .meta.primitive_id = id}
static infix_type _infix_type_void = {.name = nullptr,
                                      .category = INFIX_TYPE_VOID,
                                      .size = 0,
                                      .alignment = 0,
                                      .is_arena_allocated = false,
                                      .arena = nullptr,
                                      .source_offset = 0,
                                      .meta = {0}};
static infix_type _infix_type_pointer = {.name = nullptr,
                                         .category = INFIX_TYPE_POINTER,
                                         .size = sizeof(void *),
                                         .alignment = _Alignof(void *),
                                         .is_arena_allocated = false,
                                         .arena = nullptr,
                                         .source_offset = 0,
                                         .meta.pointer_info = {.pointee_type = &_infix_type_void}};
static infix_type _infix_type_bool = INFIX_TYPE_INIT(INFIX_PRIMITIVE_BOOL, bool);
static infix_type _infix_type_uint8 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_UINT8, uint8_t);
static infix_type _infix_type_sint8 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_SINT8, int8_t);
static infix_type _infix_type_uint16 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_UINT16, uint16_t);
static infix_type _infix_type_sint16 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_SINT16, int16_t);
static infix_type _infix_type_uint32 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_UINT32, uint32_t);
static infix_type _infix_type_sint32 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_SINT32, int32_t);
static infix_type _infix_type_uint64 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_UINT64, uint64_t);
static infix_type _infix_type_sint64 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_SINT64, int64_t);
#if !defined(INFIX_COMPILER_MSVC)
static infix_type _infix_type_uint128 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_UINT128, __uint128_t);
static infix_type _infix_type_sint128 = INFIX_TYPE_INIT(INFIX_PRIMITIVE_SINT128, __int128_t);
#endif
static infix_type _infix_type_float = INFIX_TYPE_INIT(INFIX_PRIMITIVE_FLOAT, float);
static infix_type _infix_type_double = INFIX_TYPE_INIT(INFIX_PRIMITIVE_DOUBLE, double);
#if defined(INFIX_COMPILER_MSVC) || (defined(INFIX_OS_WINDOWS) && defined(INFIX_COMPILER_CLANG))
// On these platforms, long double is just an alias for double, so no separate singleton is needed.
#else
static infix_type _infix_type_long_double = INFIX_TYPE_INIT(INFIX_PRIMITIVE_LONG_DOUBLE, long double);
#endif
// Public API: Type Creation Functions
INFIX_API c23_nodiscard infix_type * infix_type_create_primitive(infix_primitive_type_id id) {
    switch (id) {
    case INFIX_PRIMITIVE_BOOL:
        return &_infix_type_bool;
    case INFIX_PRIMITIVE_UINT8:
        return &_infix_type_uint8;
    case INFIX_PRIMITIVE_SINT8:
        return &_infix_type_sint8;
    case INFIX_PRIMITIVE_UINT16:
        return &_infix_type_uint16;
    case INFIX_PRIMITIVE_SINT16:
        return &_infix_type_sint16;
    case INFIX_PRIMITIVE_UINT32:
        return &_infix_type_uint32;
    case INFIX_PRIMITIVE_SINT32:
        return &_infix_type_sint32;
    case INFIX_PRIMITIVE_UINT64:
        return &_infix_type_uint64;
    case INFIX_PRIMITIVE_SINT64:
        return &_infix_type_sint64;
#if !defined(INFIX_COMPILER_MSVC)
    case INFIX_PRIMITIVE_UINT128:
        return &_infix_type_uint128;
    case INFIX_PRIMITIVE_SINT128:
        return &_infix_type_sint128;
#endif
    case INFIX_PRIMITIVE_FLOAT:
        return &_infix_type_float;
    case INFIX_PRIMITIVE_DOUBLE:
        return &_infix_type_double;
    case INFIX_PRIMITIVE_LONG_DOUBLE:
#if defined(INFIX_COMPILER_MSVC) || (defined(INFIX_OS_WINDOWS) && defined(INFIX_COMPILER_CLANG))
        // On MSVC and macOS/Clang (sometimes), long double is an alias for double.
        // We map to the double singleton to maintain type identity.
        return &_infix_type_double;
#else
        // On MinGW and Linux, long double is distinct (16 bytes).
        // We MUST use the distinct type to handle layout and passing correctly.
        return &_infix_type_long_double;
#endif
    default:
        // Return null for any invalid primitive ID.
        return nullptr;
    }
}
INFIX_API c23_nodiscard infix_type * infix_type_create_pointer(void) { return &_infix_type_pointer; }
INFIX_API c23_nodiscard infix_type * infix_type_create_void(void) { return &_infix_type_void; }
INFIX_API infix_struct_member infix_type_create_member(const char * name, infix_type * type, size_t offset) {
    return (infix_struct_member){name, type, offset, 0, 0, false};
}
INFIX_API infix_struct_member infix_type_create_bitfield_member(const char * name,
                                                                infix_type * type,
                                                                size_t offset,
                                                                uint8_t bit_width) {
    return (infix_struct_member){name, type, offset, bit_width, 0, true};
}
 
static bool _layout_struct(infix_type * type) {
    size_t current_byte_offset = 0;
    uint8_t current_bit_offset = 0;  // 0-7 bits used in the current byte
    size_t max_alignment = 1;
 
    for (size_t i = 0; i < type->meta.aggregate_info.num_members; ++i) {
        infix_struct_member * member = &type->meta.aggregate_info.members[i];
 
        // 1. Handle Flexible Array Members (FAM)
        if (member->type->category == INFIX_TYPE_ARRAY && member->type->meta.array_info.is_flexible) {
            // Flush any pending bits to the next byte
            if (current_bit_offset > 0) {
                if (current_byte_offset == SIZE_MAX) {
                    _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                    return false;
                }
                current_byte_offset++;
                current_bit_offset = 0;
            }
 
            // FAM aligns according to its element type.
            size_t member_align = member->type->alignment;
            if (member_align == 0)
                member_align = 1;
 
            size_t aligned = _infix_align_up(current_byte_offset, member_align);
            if (aligned < current_byte_offset) {
                _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                return false;
            }
            current_byte_offset = aligned;
            member->offset = current_byte_offset;
 
            if (member_align > max_alignment)
                max_alignment = member_align;
            continue;  // FAM logic done
        }
 
        // 2. Handle Bitfields
        if (member->is_bitfield) {
            // Zero-width bitfield: force alignment to the next boundary of the declared type.
            if (member->bit_width == 0) {
                if (current_bit_offset > 0) {
                    if (current_byte_offset == SIZE_MAX) {
                        _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                        return false;
                    }
                    current_byte_offset++;
                    current_bit_offset = 0;
                }
                size_t align = member->type->alignment;
                if (align == 0)
                    align = 1;
 
                size_t aligned = _infix_align_up(current_byte_offset, align);
                if (aligned < current_byte_offset) {
                    _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                    return false;
                }
                current_byte_offset = aligned;
                member->offset = current_byte_offset;
                member->bit_offset = 0;
 
                if (align > max_alignment)
                    max_alignment = align;
                continue;
            }
 
            // Standard Bitfield
            // Simplified System V packing: pack into current byte if it fits.
            if (current_bit_offset + member->bit_width > 8) {
                // Overflow: move to start of next byte
                if (current_byte_offset == SIZE_MAX) {
                    _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                    return false;
                }
                current_byte_offset++;
                current_bit_offset = 0;
            }
 
            member->offset = current_byte_offset;
            member->bit_offset = current_bit_offset;
            current_bit_offset += member->bit_width;
 
            // If we filled the byte exactly, advance to next byte
            if (current_bit_offset == 8) {
                if (current_byte_offset == SIZE_MAX) {
                    _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                    return false;
                }
                current_byte_offset++;
                current_bit_offset = 0;
            }
 
            // Update struct alignment. Bitfields typically impose the alignment of their base type.
            size_t align = member->type->alignment;
            if (align == 0)
                align = 1;
            if (align > max_alignment)
                max_alignment = align;
        }
        else {
            // 3. Standard Member
 
            // Flush bits first
            if (current_bit_offset > 0) {
                if (current_byte_offset == SIZE_MAX) {
                    _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                    return false;
                }
                current_byte_offset++;
                current_bit_offset = 0;
            }
 
            size_t member_align = member->type->alignment;
            if (member_align == 0)
                member_align = 1;
 
            if (member_align > max_alignment)
                max_alignment = member_align;
 
            size_t aligned = _infix_align_up(current_byte_offset, member_align);
            if (aligned < current_byte_offset) {
                _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                return false;
            }
            current_byte_offset = aligned;
            member->offset = current_byte_offset;
 
            if (current_byte_offset > SIZE_MAX - member->type->size) {
                _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
                return false;
            }
            current_byte_offset += member->type->size;
        }
    }
 
    // Final flush
    if (current_bit_offset > 0)
        current_byte_offset++;
 
    // If it is packed, the alignment is explicitly determined by the user (defaulting to 1
    // if not specified in the syntax). We must respect this value absolutely, ignoring
    // the natural alignment of members.
    if (type->meta.aggregate_info.is_packed)
        max_alignment = type->alignment;
 
    type->alignment = max_alignment;
    type->size = _infix_align_up(current_byte_offset, max_alignment);
    return true;
}
static infix_status _create_aggregate_setup(infix_arena_t * arena,
                                            infix_type ** out_type,
                                            infix_struct_member ** out_arena_members,
                                            infix_struct_member * members,
                                            size_t num_members) {
    if (out_type == nullptr)
        return INFIX_ERROR_INVALID_ARGUMENT;
    // Pre-flight check: ensure all provided member types are valid.
    for (size_t i = 0; i < num_members; ++i) {
        if (members[i].type == nullptr) {
            *out_type = nullptr;
            _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INVALID_MEMBER_TYPE, 0);
            return INFIX_ERROR_INVALID_ARGUMENT;
        }
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    infix_struct_member * arena_members = nullptr;
    if (num_members > 0) {
        arena_members =
            infix_arena_alloc(arena, sizeof(infix_struct_member) * num_members, _Alignof(infix_struct_member));
        if (arena_members == nullptr) {
            *out_type = nullptr;
            _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
            return INFIX_ERROR_ALLOCATION_FAILED;
        }
        infix_memcpy(arena_members, members, sizeof(infix_struct_member) * num_members);
    }
    *out_type = type;
    *out_arena_members = arena_members;
    return INFIX_SUCCESS;
}
c23_nodiscard infix_status infix_type_create_pointer_to(infix_arena_t * arena,
                                                        infix_type ** out_type,
                                                        infix_type * pointee_type) {
    if (!out_type || !pointee_type) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    // Start by copying the layout of a generic pointer.
    *type = *infix_type_create_pointer();
    // Mark it as arena-allocated so it can be deep-copied and freed correctly.
    type->is_arena_allocated = true;
    // Set the specific pointee type.
    type->meta.pointer_info.pointee_type = pointee_type;
    *out_type = type;
    return INFIX_SUCCESS;
}
INFIX_API c23_nodiscard infix_status infix_type_create_array(infix_arena_t * arena,
                                                             infix_type ** out_type,
                                                             infix_type * element_type,
                                                             size_t num_elements) {
    if (out_type == nullptr || element_type == nullptr) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    if (element_type->size > 0 && num_elements > SIZE_MAX / element_type->size) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_ARRAY;
    type->meta.array_info.element_type = element_type;
    type->meta.array_info.num_elements = num_elements;
    type->meta.array_info.is_flexible = false;
    // An array's alignment is the same as its element's alignment.
    type->alignment = element_type->alignment;
    type->size = element_type->size * num_elements;
    *out_type = type;
    return INFIX_SUCCESS;
}
 
INFIX_API c23_nodiscard infix_status infix_type_create_flexible_array(infix_arena_t * arena,
                                                                      infix_type ** out_type,
                                                                      infix_type * element_type) {
    if (out_type == nullptr || element_type == nullptr) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    // Flexible arrays of incomplete types (size 0) are generally not allowed.
    if (element_type->category == INFIX_TYPE_VOID || element_type->size == 0) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INVALID_MEMBER_TYPE, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
 
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_ARRAY;
    type->meta.array_info.element_type = element_type;
    type->meta.array_info.num_elements = 0;
    type->meta.array_info.is_flexible = true;  // Mark as flexible
 
    // A flexible array member itself has size 0 within the struct (it hangs off the end).
    // However, its alignment requirement affects the struct.
    type->alignment = element_type->alignment;
    type->size = 0;
 
    *out_type = type;
    return INFIX_SUCCESS;
}
 
INFIX_API c23_nodiscard infix_status infix_type_create_enum(infix_arena_t * arena,
                                                            infix_type ** out_type,
                                                            infix_type * underlying_type) {
    if (out_type == nullptr || underlying_type == nullptr) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    if (underlying_type->category != INFIX_TYPE_PRIMITIVE ||
        underlying_type->meta.primitive_id > INFIX_PRIMITIVE_SINT128) {
        _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INVALID_MEMBER_TYPE, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_ENUM;
    // An enum has the same memory layout as its underlying integer type.
    type->size = underlying_type->size;
    type->alignment = underlying_type->alignment;
    type->meta.enum_info.underlying_type = underlying_type;
    *out_type = type;
    return INFIX_SUCCESS;
}
INFIX_API c23_nodiscard infix_status infix_type_create_complex(infix_arena_t * arena,
                                                               infix_type ** out_type,
                                                               infix_type * base_type) {
    if (out_type == nullptr || base_type == nullptr || (!is_float(base_type) && !is_double(base_type))) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_COMPLEX;
    // A complex number is simply two floating-point numbers back-to-back.
    type->size = base_type->size * 2;
    type->alignment = base_type->alignment;
    type->meta.complex_info.base_type = base_type;
    *out_type = type;
    return INFIX_SUCCESS;
}
INFIX_API c23_nodiscard infix_status infix_type_create_vector(infix_arena_t * arena,
                                                              infix_type ** out_type,
                                                              infix_type * element_type,
                                                              size_t num_elements) {
    if (out_type == nullptr || element_type == nullptr || element_type->category != INFIX_TYPE_PRIMITIVE) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    if (element_type->size > 0 && num_elements > SIZE_MAX / element_type->size) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_VECTOR;
    type->meta.vector_info.element_type = element_type;
    type->meta.vector_info.num_elements = num_elements;
    type->size = element_type->size * num_elements;
    // Vector alignment is typically its total size, up to a platform-specific maximum (e.g., 16 on x64).
    // This is a simplification; the ABI-specific classifiers will handle the true alignment rules.
    type->alignment = type->size > 8 ? 16 : type->size;
    *out_type = type;
    return INFIX_SUCCESS;
}
INFIX_API c23_nodiscard infix_status infix_type_create_union(infix_arena_t * arena,
                                                             infix_type ** out_type,
                                                             infix_struct_member * members,
                                                             size_t num_members) {
    infix_type * type = nullptr;
    infix_struct_member * arena_members = nullptr;
    infix_status status = _create_aggregate_setup(arena, &type, &arena_members, members, num_members);
    if (status != INFIX_SUCCESS) {
        *out_type = nullptr;
        return status;
    }
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_UNION;
    type->meta.aggregate_info.members = arena_members;
    type->meta.aggregate_info.num_members = num_members;
    type->meta.aggregate_info.is_packed = false;  // Unions don't use this flag currently
    // A union's size is the size of its largest member, and its alignment is the
    // alignment of its most-aligned member.
    size_t max_size = 0;
    size_t max_alignment = 1;
    for (size_t i = 0; i < num_members; ++i) {
        arena_members[i].offset = 0;  // All union members have an offset of 0.
        if (arena_members[i].type->size > max_size)
            max_size = arena_members[i].type->size;
        if (arena_members[i].type->alignment > max_alignment)
            max_alignment = arena_members[i].type->alignment;
    }
    type->alignment = max_alignment;
    // The total size is the size of the largest member, padded up to the required alignment.
    type->size = _infix_align_up(max_size, max_alignment);
    // Overflow check
    if (type->size < max_size) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INTEGER_OVERFLOW, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    *out_type = type;
    return INFIX_SUCCESS;
}
INFIX_API c23_nodiscard infix_status infix_type_create_struct(infix_arena_t * arena,
                                                              infix_type ** out_type,
                                                              infix_struct_member * members,
                                                              size_t num_members) {
    _infix_clear_error();
    infix_type * type = nullptr;
    infix_struct_member * arena_members = nullptr;
    infix_status status = _create_aggregate_setup(arena, &type, &arena_members, members, num_members);
    if (status != INFIX_SUCCESS) {
        *out_type = nullptr;
        return status;
    }
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_STRUCT;
    type->meta.aggregate_info.members = arena_members;
    type->meta.aggregate_info.num_members = num_members;
    type->meta.aggregate_info.is_packed = false;
 
    // This performs a preliminary layout calculation.
    // Note: This layout may be incomplete if it contains unresolved named references or flexible arrays.
    // The final, correct layout will be computed by `_infix_type_recalculate_layout`.
    // However, we must set a preliminary size/alignment here.
 
    // We use the recalculate logic to do the heavy lifting, assuming a temporary arena can be made.
    // But we can't create an arena here easily if we are in a strict context.
    // So we do a simplified pass just like the old logic, ignoring complex bitfield rules for now.
    // The proper bitfield layout happens in `_infix_type_recalculate_layout`.
 
    for (size_t i = 0; i < num_members; ++i) {
        infix_struct_member * member = &arena_members[i];
        if (member->type->alignment == 0 && member->type->category != INFIX_TYPE_NAMED_REFERENCE &&
            !(member->type->category == INFIX_TYPE_ARRAY && member->type->meta.array_info.is_flexible)) {
            if (member->type->category != INFIX_TYPE_ARRAY) {
                *out_type = nullptr;
                _infix_set_error(INFIX_CATEGORY_PARSER, INFIX_CODE_INVALID_MEMBER_TYPE, 0);
                return INFIX_ERROR_INVALID_ARGUMENT;
            }
        }
    }
 
    // Calculate Layout (including bitfields and FAMs)
    if (!_layout_struct(type)) {
        *out_type = nullptr;
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
 
    *out_type = type;
    return INFIX_SUCCESS;
}
INFIX_API c23_nodiscard infix_status infix_type_create_packed_struct(infix_arena_t * arena,
                                                                     infix_type ** out_type,
                                                                     size_t total_size,
                                                                     size_t alignment,
                                                                     infix_struct_member * members,
                                                                     size_t num_members) {
    if (out_type == nullptr || (num_members > 0 && members == nullptr)) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    // Validate alignment is power-of-two AND within sane limits.
    if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_INVALID_ALIGNMENT, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    if (alignment > INFIX_MAX_ALIGNMENT) {
        _infix_set_error(INFIX_CATEGORY_ABI, INFIX_CODE_TYPE_TOO_LARGE, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    infix_struct_member * arena_members = nullptr;
    if (num_members > 0) {
        arena_members =
            infix_arena_alloc(arena, sizeof(infix_struct_member) * num_members, _Alignof(infix_struct_member));
        if (arena_members == nullptr) {
            *out_type = nullptr;
            _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
            return INFIX_ERROR_ALLOCATION_FAILED;
        }
        infix_memcpy(arena_members, members, sizeof(infix_struct_member) * num_members);
    }
    type->is_arena_allocated = true;
    type->size = total_size;
    type->alignment = alignment;
    type->category = INFIX_TYPE_STRUCT;  // Packed structs are still fundamentally structs.
    type->meta.aggregate_info.members = arena_members;
    type->meta.aggregate_info.num_members = num_members;
    type->meta.aggregate_info.is_packed = true;  // Marked as packed
    *out_type = type;
    return INFIX_SUCCESS;
}
INFIX_API c23_nodiscard infix_status infix_type_create_named_reference(infix_arena_t * arena,
                                                                       infix_type ** out_type,
                                                                       const char * name,
                                                                       infix_aggregate_category_t agg_cat) {
    if (out_type == nullptr || name == nullptr) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_NULL_POINTER, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
    infix_type * type = infix_arena_calloc(arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (type == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    // The name must be copied into the arena to ensure its lifetime matches the type's.
    size_t name_len = strlen(name) + 1;
    char * arena_name = infix_arena_alloc(arena, name_len, 1);
    if (arena_name == nullptr) {
        *out_type = nullptr;
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return INFIX_ERROR_ALLOCATION_FAILED;
    }
    infix_memcpy(arena_name, name, name_len);
    type->is_arena_allocated = true;
    type->category = INFIX_TYPE_NAMED_REFERENCE;
    type->size = 0;       // Size and alignment are unknown until resolution.
    type->alignment = 1;  // Default to 1 to be safe in preliminary layout calculations.
    type->meta.named_reference.name = arena_name;
    type->meta.named_reference.aggregate_category = agg_cat;
    *out_type = type;
    return INFIX_SUCCESS;
}
// Internal Type Graph Management
typedef struct recalc_visited_node_t {
    infix_type * type; 
    struct recalc_visited_node_t * next; 
} recalc_visited_node_t;
static void _infix_type_recalculate_layout_recursive(infix_arena_t * temp_arena,
                                                     infix_type * type,
                                                     recalc_visited_node_t ** visited_head) {
    if (!type || !type->is_arena_allocated)
        return;  // Base case: Don't modify static singleton types.
    // Cycle detection: If we have already visited this node in the current recursion
    // path, we are in a cycle. Return immediately to break the loop. The layout of
    // this node will be calculated when the recursion unwinds to its first visit.
    for (recalc_visited_node_t * v = *visited_head; v != nullptr; v = v->next)
        if (v->type == type)
            return;
    // Allocate the memoization node from a stable temporary arena.
    recalc_visited_node_t * visited_node =
        infix_arena_alloc(temp_arena, sizeof(recalc_visited_node_t), _Alignof(recalc_visited_node_t));
    if (!visited_node)
        return;  // Cannot proceed without memory.
    visited_node->type = type;
    visited_node->next = *visited_head;
    *visited_head = visited_node;
    // Recurse into child types first (post-order traversal).
    switch (type->category) {
    case INFIX_TYPE_POINTER:
        _infix_type_recalculate_layout_recursive(temp_arena, type->meta.pointer_info.pointee_type, visited_head);
        break;
    case INFIX_TYPE_ARRAY:
        _infix_type_recalculate_layout_recursive(temp_arena, type->meta.array_info.element_type, visited_head);
        break;
    case INFIX_TYPE_STRUCT:
    case INFIX_TYPE_UNION:
        for (size_t i = 0; i < type->meta.aggregate_info.num_members; ++i) {
            _infix_type_recalculate_layout_recursive(
                temp_arena, type->meta.aggregate_info.members[i].type, visited_head);
        }
        break;
    default:
        break;  // Other types have no child types to recurse into.
    }
    // After children are updated, recalculate this type's layout.
    if (type->category == INFIX_TYPE_STRUCT)
        _layout_struct(type);
    else if (type->category == INFIX_TYPE_UNION) {
        size_t max_size = 0;
        size_t max_alignment = 1;
        for (size_t i = 0; i < type->meta.aggregate_info.num_members; ++i) {
            infix_type * member_type = type->meta.aggregate_info.members[i].type;
            if (member_type->size > max_size)
                max_size = member_type->size;
            if (member_type->alignment > max_alignment)
                max_alignment = member_type->alignment;
        }
        type->alignment = max_alignment;
        type->size = _infix_align_up(max_size, max_alignment);
    }
    else if (type->category == INFIX_TYPE_ARRAY) {
        // Flexible arrays have size 0 but inherit alignment.
        // Fixed arrays calculate size normally.
        if (type->meta.array_info.is_flexible) {
            type->alignment = type->meta.array_info.element_type->alignment;
            type->size = 0;
        }
        else {
            type->alignment = type->meta.array_info.element_type->alignment;
            type->size = type->meta.array_info.element_type->size * type->meta.array_info.num_elements;
        }
    }
}
void _infix_type_recalculate_layout(infix_type * type) {
    // Create a temporary arena solely for the visited list's lifetime.
    infix_arena_t * temp_arena = infix_arena_create(1024);
    if (!temp_arena)
        return;
    recalc_visited_node_t * visited_head = nullptr;
    _infix_type_recalculate_layout_recursive(temp_arena, type, &visited_head);
    infix_arena_destroy(temp_arena);
}
typedef struct memo_node_t {
    const infix_type * src;    
    infix_type * dest;         
    struct memo_node_t * next; 
} memo_node_t;
static infix_type * _copy_type_graph_to_arena_recursive(infix_arena_t * dest_arena,
                                                        const infix_type * src_type,
                                                        memo_node_t ** memo_head) {
    if (src_type == nullptr)
        return nullptr;
    // If the source type lives in the same arena as our destination, we can safely share the pointer instead of
    // performing a deep copy.
    if (src_type->arena == dest_arena)
        return (infix_type *)src_type;
    // Base case: Static types don't need to be copied; return the singleton pointer.
    if (!src_type->is_arena_allocated)
        return (infix_type *)src_type;
    // Check memoization table: if we've already copied this node, return the existing copy.
    // This correctly handles cycles and shared sub-graphs.
    for (memo_node_t * node = *memo_head; node != NULL; node = node->next)
        if (node->src == src_type)
            return node->dest;
    // Allocate the new type object in the destination arena.
    infix_type * dest_type = infix_arena_calloc(dest_arena, 1, sizeof(infix_type), _Alignof(infix_type));
    if (dest_type == nullptr)
        return nullptr;
    // Add this new pair to the memoization table BEFORE recursing. This is crucial
    // for handling cycles: the recursive call will find this entry and return `dest_type`.
    memo_node_t * new_memo_node = infix_arena_alloc(dest_arena, sizeof(memo_node_t), _Alignof(memo_node_t));
    if (!new_memo_node)
        return nullptr;
    new_memo_node->src = src_type;
    new_memo_node->dest = dest_type;
    new_memo_node->next = *memo_head;
    *memo_head = new_memo_node;
    // Perform a shallow copy of the main struct, then recurse to deep copy child pointers.
    *dest_type = *src_type;
    dest_type->is_arena_allocated = true;
    dest_type->is_incomplete = src_type->is_incomplete;
    dest_type->arena = dest_arena;  // The new type now belongs to the destination arena.
    // Deep copy the semantic name string, if it exists.
    if (src_type->name) {
        size_t name_len = strlen(src_type->name) + 1;
        char * dest_name = infix_arena_alloc(dest_arena, name_len, 1);
        if (!dest_name)
            return nullptr;  // Allocation failed
        infix_memcpy((void *)dest_name, src_type->name, name_len);
        dest_type->name = dest_name;
    }
    switch (src_type->category) {
    case INFIX_TYPE_POINTER:
        dest_type->meta.pointer_info.pointee_type =
            _copy_type_graph_to_arena_recursive(dest_arena, src_type->meta.pointer_info.pointee_type, memo_head);
        break;
    case INFIX_TYPE_ARRAY:
        dest_type->meta.array_info.element_type =
            _copy_type_graph_to_arena_recursive(dest_arena, src_type->meta.array_info.element_type, memo_head);
        // Explicitly copy the flexible flag to ensure it persists.
        dest_type->meta.array_info.is_flexible = src_type->meta.array_info.is_flexible;
        break;
    case INFIX_TYPE_STRUCT:
    case INFIX_TYPE_UNION:
        if (src_type->meta.aggregate_info.num_members > 0) {
            // Copy the members array itself.
            size_t members_size = sizeof(infix_struct_member) * src_type->meta.aggregate_info.num_members;
            dest_type->meta.aggregate_info.members =
                infix_arena_alloc(dest_arena, members_size, _Alignof(infix_struct_member));
            if (dest_type->meta.aggregate_info.members == nullptr)
                return nullptr;
            dest_type->meta.aggregate_info.is_packed = src_type->meta.aggregate_info.is_packed;  // Copy packed flag
            // Now, recurse for each member's type and copy its name.
            for (size_t i = 0; i < src_type->meta.aggregate_info.num_members; ++i) {
                dest_type->meta.aggregate_info.members[i] = src_type->meta.aggregate_info.members[i];
                dest_type->meta.aggregate_info.members[i].type = _copy_type_graph_to_arena_recursive(
                    dest_arena, src_type->meta.aggregate_info.members[i].type, memo_head);
                const char * src_name = src_type->meta.aggregate_info.members[i].name;
                if (src_name) {
                    size_t name_len = strlen(src_name) + 1;
                    char * dest_name = infix_arena_alloc(dest_arena, name_len, 1);
                    if (!dest_name)
                        return nullptr;
                    infix_memcpy((void *)dest_name, src_name, name_len);
                    dest_type->meta.aggregate_info.members[i].name = dest_name;
                }
                // Copy bitfield properties
                dest_type->meta.aggregate_info.members[i].bit_width =
                    src_type->meta.aggregate_info.members[i].bit_width;
                dest_type->meta.aggregate_info.members[i].bit_offset =
                    src_type->meta.aggregate_info.members[i].bit_offset;
                dest_type->meta.aggregate_info.members[i].is_bitfield =
                    src_type->meta.aggregate_info.members[i].is_bitfield;
            }
        }
        break;
    case INFIX_TYPE_NAMED_REFERENCE:
        {
            const char * src_name = src_type->meta.named_reference.name;
            if (src_name) {
                size_t name_len = strlen(src_name) + 1;
                char * dest_name = infix_arena_alloc(dest_arena, name_len, 1);
                if (!dest_name)
                    return nullptr;
                infix_memcpy((void *)dest_name, src_name, name_len);
                dest_type->meta.named_reference.name = dest_name;
            }
            break;
        }
    case INFIX_TYPE_REVERSE_TRAMPOLINE:
        dest_type->meta.func_ptr_info.return_type =
            _copy_type_graph_to_arena_recursive(dest_arena, src_type->meta.func_ptr_info.return_type, memo_head);
        if (src_type->meta.func_ptr_info.num_args > 0) {
            size_t args_size = sizeof(infix_function_argument) * src_type->meta.func_ptr_info.num_args;
            dest_type->meta.func_ptr_info.args =
                infix_arena_alloc(dest_arena, args_size, _Alignof(infix_function_argument));
            if (dest_type->meta.func_ptr_info.args == nullptr)
                return nullptr;
            for (size_t i = 0; i < src_type->meta.func_ptr_info.num_args; ++i) {
                dest_type->meta.func_ptr_info.args[i] = src_type->meta.func_ptr_info.args[i];
                dest_type->meta.func_ptr_info.args[i].type = _copy_type_graph_to_arena_recursive(
                    dest_arena, src_type->meta.func_ptr_info.args[i].type, memo_head);
                const char * src_name = src_type->meta.func_ptr_info.args[i].name;
                if (src_name) {
                    size_t name_len = strlen(src_name) + 1;
                    char * dest_name = infix_arena_alloc(dest_arena, name_len, 1);
                    if (!dest_name)
                        return nullptr;
                    infix_memcpy((void *)dest_name, src_name, name_len);
                    dest_type->meta.func_ptr_info.args[i].name = dest_name;
                }
            }
        }
        break;
    case INFIX_TYPE_ENUM:
        dest_type->meta.enum_info.underlying_type =
            _copy_type_graph_to_arena_recursive(dest_arena, src_type->meta.enum_info.underlying_type, memo_head);
        break;
    case INFIX_TYPE_COMPLEX:
        dest_type->meta.complex_info.base_type =
            _copy_type_graph_to_arena_recursive(dest_arena, src_type->meta.complex_info.base_type, memo_head);
        break;
    case INFIX_TYPE_VECTOR:
        dest_type->meta.vector_info.element_type =
            _copy_type_graph_to_arena_recursive(dest_arena, src_type->meta.vector_info.element_type, memo_head);
        break;
    default:
        // Other types like primitives have no child pointers to copy.
        break;
    }
    return dest_type;
}
infix_type * _copy_type_graph_to_arena(infix_arena_t * dest_arena, const infix_type * src_type) {
    memo_node_t * memo_head = nullptr;
    return _copy_type_graph_to_arena_recursive(dest_arena, src_type, &memo_head);
}
typedef struct estimate_visited_node_t {
    const infix_type * type;               
    struct estimate_visited_node_t * next; 
} estimate_visited_node_t;
static size_t _estimate_graph_size_recursive(infix_arena_t * temp_arena,
                                             const infix_type * type,
                                             estimate_visited_node_t ** visited_head) {
    if (!type || !type->is_arena_allocated)
        return 0;
    // Cycle detection: if we've seen this node, it's already accounted for.
    for (estimate_visited_node_t * v = *visited_head; v != NULL; v = v->next)
        if (v->type == type)
            return 0;
    // Add this node to the visited list before recursing.
    estimate_visited_node_t * visited_node =
        infix_arena_alloc(temp_arena, sizeof(estimate_visited_node_t), _Alignof(estimate_visited_node_t));
    if (!visited_node) {
        // On allocation failure, we can't proceed with estimation. Return a large
        // number to ensure the caller allocates a fallback-sized arena.
        return 65536;
    }
    visited_node->type = type;
    visited_node->next = *visited_head;
    *visited_head = visited_node;
    // The size includes the type object itself, a memoization node, and the name string if it exists.
    size_t total_size = sizeof(infix_type) + sizeof(memo_node_t);
    if (type->name)
        total_size += strlen(type->name) + 1;
    switch (type->category) {
    case INFIX_TYPE_POINTER:
        total_size += _estimate_graph_size_recursive(temp_arena, type->meta.pointer_info.pointee_type, visited_head);
        break;
    case INFIX_TYPE_ARRAY:
        total_size += _estimate_graph_size_recursive(temp_arena, type->meta.array_info.element_type, visited_head);
        break;
    case INFIX_TYPE_STRUCT:
    case INFIX_TYPE_UNION:
        if (type->meta.aggregate_info.num_members > 0) {
            total_size += sizeof(infix_struct_member) * type->meta.aggregate_info.num_members;
            for (size_t i = 0; i < type->meta.aggregate_info.num_members; ++i) {
                const infix_struct_member * member = &type->meta.aggregate_info.members[i];
                if (member->name)
                    total_size += strlen(member->name) + 1;
                total_size += _estimate_graph_size_recursive(temp_arena, member->type, visited_head);
            }
        }
        break;
    case INFIX_TYPE_NAMED_REFERENCE:
        if (type->meta.named_reference.name)
            total_size += strlen(type->meta.named_reference.name) + 1;
        break;
    case INFIX_TYPE_REVERSE_TRAMPOLINE:
        total_size += _estimate_graph_size_recursive(temp_arena, type->meta.func_ptr_info.return_type, visited_head);
        if (type->meta.func_ptr_info.num_args > 0) {
            total_size += sizeof(infix_function_argument) * type->meta.func_ptr_info.num_args;
            for (size_t i = 0; i < type->meta.func_ptr_info.num_args; ++i) {
                const infix_function_argument * arg = &type->meta.func_ptr_info.args[i];
                if (arg->name)
                    total_size += strlen(arg->name) + 1;
                total_size += _estimate_graph_size_recursive(temp_arena, arg->type, visited_head);
            }
        }
        break;
    case INFIX_TYPE_ENUM:
        total_size += _estimate_graph_size_recursive(temp_arena, type->meta.enum_info.underlying_type, visited_head);
        break;
    case INFIX_TYPE_COMPLEX:
        total_size += _estimate_graph_size_recursive(temp_arena, type->meta.complex_info.base_type, visited_head);
        break;
    case INFIX_TYPE_VECTOR:
        total_size += _estimate_graph_size_recursive(temp_arena, type->meta.vector_info.element_type, visited_head);
        break;
    default:
        break;
    }
    return total_size;
}
size_t _infix_estimate_graph_size(infix_arena_t * temp_arena, const infix_type * type) {
    if (!temp_arena || !type)
        return 0;
    estimate_visited_node_t * visited_head = nullptr;
    return _estimate_graph_size_recursive(temp_arena, type, &visited_head);
}
// Public API: Introspection Functions
INFIX_API c23_nodiscard const char * infix_type_get_name(const infix_type * type) {
    if (type == nullptr)
        return nullptr;
    return type->name;
}
INFIX_API c23_nodiscard infix_type_category infix_type_get_category(const infix_type * type) {
    return type ? type->category : (infix_type_category)-1;
}
INFIX_API c23_nodiscard size_t infix_type_get_size(const infix_type * type) { return type ? type->size : 0; }
INFIX_API c23_nodiscard size_t infix_type_get_alignment(const infix_type * type) { return type ? type->alignment : 0; }
INFIX_API c23_nodiscard size_t infix_type_get_member_count(const infix_type * type) {
    if (!type || (type->category != INFIX_TYPE_STRUCT && type->category != INFIX_TYPE_UNION))
        return 0;
    return type->meta.aggregate_info.num_members;
}
INFIX_API c23_nodiscard const infix_struct_member * infix_type_get_member(const infix_type * type, size_t index) {
    if (!type || (type->category != INFIX_TYPE_STRUCT && type->category != INFIX_TYPE_UNION) ||
        index >= type->meta.aggregate_info.num_members)
        return nullptr;
    return &type->meta.aggregate_info.members[index];
}
INFIX_API c23_nodiscard const char * infix_type_get_arg_name(const infix_type * func_type, size_t index) {
    if (!func_type || func_type->category != INFIX_TYPE_REVERSE_TRAMPOLINE ||
        index >= func_type->meta.func_ptr_info.num_args)
        return nullptr;
    return func_type->meta.func_ptr_info.args[index].name;
}
INFIX_API c23_nodiscard const infix_type * infix_type_get_arg_type(const infix_type * func_type, size_t index) {
    if (!func_type || func_type->category != INFIX_TYPE_REVERSE_TRAMPOLINE ||
        index >= func_type->meta.func_ptr_info.num_args)
        return nullptr;
    return func_type->meta.func_ptr_info.args[index].type;
}
INFIX_API c23_nodiscard size_t infix_forward_get_num_args(const infix_forward_t * trampoline) {
    return trampoline ? trampoline->num_args : 0;
}
INFIX_API c23_nodiscard size_t infix_forward_get_num_fixed_args(const infix_forward_t * trampoline) {
    return trampoline ? trampoline->num_fixed_args : 0;
}
INFIX_API c23_nodiscard const infix_type * infix_forward_get_return_type(const infix_forward_t * trampoline) {
    return trampoline ? trampoline->return_type : nullptr;
}
INFIX_API c23_nodiscard const infix_type * infix_forward_get_arg_type(const infix_forward_t * trampoline,
                                                                      size_t index) {
    if (!trampoline || index >= trampoline->num_args)
        return nullptr;
    return trampoline->arg_types[index];
}
INFIX_API c23_nodiscard size_t infix_reverse_get_num_args(const infix_reverse_t * trampoline) {
    return trampoline ? trampoline->num_args : 0;
}
INFIX_API c23_nodiscard size_t infix_reverse_get_num_fixed_args(const infix_reverse_t * trampoline) {
    return trampoline ? trampoline->num_fixed_args : 0;
}
INFIX_API c23_nodiscard const infix_type * infix_reverse_get_return_type(const infix_reverse_t * trampoline) {
    return trampoline ? trampoline->return_type : nullptr;
}
INFIX_API c23_nodiscard const infix_type * infix_reverse_get_arg_type(const infix_reverse_t * trampoline,
                                                                      size_t index) {
    if (!trampoline || index >= trampoline->num_args)
        return nullptr;
    return trampoline->arg_types[index];
}