Function cpp_ty_fmt_impl

crates/codegen/src/unrealcpp.rs:6707–6783

(
    module_prefix: &'a str,
    module: &'a ModuleDef,
    ty: &'a AlgebraicTypeUse,
    module_name: &'a str,
)

}

fn cpp_ty_fmt_impl<'a>(
    module_prefix: &'a str,
    module: &'a ModuleDef,
    ty: &'a AlgebraicTypeUse,
    module_name: &'a str,
) -> impl fmt::Display + 'a {
    fmt_fn(move |f| match ty {
        // --------- primitives etc ---------
        AlgebraicTypeUse::Primitive(p) => f.write_str(match p {
            PrimitiveType::Bool => "bool",
            PrimitiveType::I8 => "int8",
            PrimitiveType::U8 => "uint8",
            PrimitiveType::I16 => "int16",
            PrimitiveType::U16 => "uint16",
            PrimitiveType::I32 => "int32",
            PrimitiveType::U32 => "uint32",
            PrimitiveType::I64 => "int64",
            PrimitiveType::U64 => "uint64",
            PrimitiveType::F32 => "float",
            PrimitiveType::F64 => "double",
            PrimitiveType::I128 => "FSpacetimeDBInt128",
            PrimitiveType::U128 => "FSpacetimeDBUInt128",
            PrimitiveType::I256 => "FSpacetimeDBInt256",
            PrimitiveType::U256 => "FSpacetimeDBUInt256",
        }),

        AlgebraicTypeUse::Array(elem) if matches!(elem.as_ref(), AlgebraicTypeUse::Primitive(PrimitiveType::U8)) => {
            f.write_str("TArray<uint8>")
        }

        AlgebraicTypeUse::Array(elem) => {
            let elem_type = cpp_ty_fmt_impl(module_prefix, module, elem, module_name).to_string();
            write!(f, "TArray<{elem_type}>")
        }

        AlgebraicTypeUse::String => f.write_str("FString"),
        AlgebraicTypeUse::Identity => f.write_str("FSpacetimeDBIdentity"),
        AlgebraicTypeUse::ConnectionId => f.write_str("FSpacetimeDBConnectionId"),
        AlgebraicTypeUse::Timestamp => f.write_str("FSpacetimeDBTimestamp"),
        AlgebraicTypeUse::TimeDuration => f.write_str("FSpacetimeDBTimeDuration"),
        AlgebraicTypeUse::Uuid => f.write_str("FSpacetimeDBUuid"),
        AlgebraicTypeUse::ScheduleAt => f.write_str("FSpacetimeDBScheduleAt"),
        AlgebraicTypeUse::Unit => f.write_str("FSpacetimeDBUnit"),

        // --------- references to user-defined types ---------
        AlgebraicTypeUse::Ref(r) => {
            let scoped = type_ref_name(module_prefix, module, *r); // PascalCase
            match &module.typespace_for_generate()[*r] {
                AlgebraicTypeDef::PlainEnum(_) => write!(f, "E{scoped}Type"), // enum → EFooType
                AlgebraicTypeDef::Product(_) => write!(f, "F{scoped}Type"),   // struct/record → FFooType
                AlgebraicTypeDef::Sum(_) => write!(f, "F{scoped}Type"),       // sum type → FFooType (UStruct)
            }
        }

        // Options use the generated optional types
        AlgebraicTypeUse::Option(inner) => {
            let optional_name = get_optional_type_name(module_prefix, module, inner);
            if module_name.is_empty() {