Function cpp_ty_init_fmt_impl

crates/codegen/src/unrealcpp.rs:6790–6843

For UPROPERTY() Unreal expects initialization values for certain types. UE5 strict mode requires all UPROPERTY fields to be explicitly initialized, otherwise the engine logs "property not initialized properly" errors. This includes primitives (bool defaults to true if not initialized to false), and enum types (must be initialized to a valid enum value).

(module_prefix: &str, module: &ModuleDef, ty: &AlgebraicTypeUse)

// This includes primitives (bool defaults to true if not initialized to false),
// and enum types (must be initialized to a valid enum value).
fn cpp_ty_init_fmt_impl(module_prefix: &str, module: &ModuleDef, ty: &AlgebraicTypeUse) -> String {
    match ty {
        AlgebraicTypeUse::Primitive(p) => match p {
            PrimitiveType::Bool => " = false".to_string(),
            PrimitiveType::I8 => " = 0".to_string(),
            PrimitiveType::U8 => " = 0".to_string(),
            PrimitiveType::I16 => " = 0".to_string(),
            PrimitiveType::U16 => " = 0".to_string(),
            PrimitiveType::I32 => " = 0".to_string(),
            PrimitiveType::U32 => " = 0".to_string(),
            PrimitiveType::I64 => " = 0".to_string(),
            PrimitiveType::U64 => " = 0".to_string(),
            PrimitiveType::F32 => " = 0.0f".to_string(),
            PrimitiveType::F64 => " = 0.0".to_string(),
            PrimitiveType::I128 => String::new(),
            PrimitiveType::U128 => String::new(),
            PrimitiveType::I256 => String::new(),
            PrimitiveType::U256 => String::new(),
        },
        AlgebraicTypeUse::Array(_elem) => String::new(),
        AlgebraicTypeUse::String => String::new(),
        AlgebraicTypeUse::Identity => String::new(),
        AlgebraicTypeUse::ConnectionId => String::new(),
        AlgebraicTypeUse::Timestamp => String::new(),
        AlgebraicTypeUse::TimeDuration => String::new(),
        AlgebraicTypeUse::ScheduleAt => String::new(),
        AlgebraicTypeUse::Uuid => String::new(),
        AlgebraicTypeUse::Unit => String::new(),
        // --------- references to user-defined types ---------
        AlgebraicTypeUse::Ref(r) => {
            // Enum types must be initialized to a valid enum value in UE5.
            // Use the first variant as the default value.
            match &module.typespace_for_generate()[*r] {
                AlgebraicTypeDef::PlainEnum(plain_enum) => {
                    let type_name = type_ref_name(module_prefix, module, *r);
                    if let Some(first_variant) = plain_enum.variants.first() {
                        let variant_name = first_variant.deref().to_case(Case::Pascal);
                        format!(" = E{type_name}Type::{variant_name}")
                    } else {
                        String::new()
                    }
                }
                // Product and Sum types have proper default constructors
                AlgebraicTypeDef::Product(_) => String::new(),
                AlgebraicTypeDef::Sum(_) => String::new(),
            }
        }
        // Options use the generated optional types
        AlgebraicTypeUse::Option(_inner) => String::new(),
        // Result use the generated result types
        AlgebraicTypeUse::Result { ok_ty: _, err_ty: _ } => String::new(),
        AlgebraicTypeUse::Never => unreachable!("never type"),
    }
}

// Given an `AlgebraicTypeUse`, add every referenced type’s generated
// header name (`"<FTypeName>.g.h"`) into `out` (a `HashSet` avoids dups).