Function is_blueprintable

crates/codegen/src/unrealcpp.rs:6249–6296

Helper function to check if a type is blueprintable as a field (UPROPERTY)

(module: &ModuleDef, ty: &AlgebraicTypeUse)

// Helper function to check if a type is blueprintable as a field (UPROPERTY)
fn is_blueprintable(module: &ModuleDef, ty: &AlgebraicTypeUse) -> bool {
    match ty {
        AlgebraicTypeUse::Primitive(p) => match p {
            // These types are not blueprintable in Unreal Engine
            PrimitiveType::I8 | PrimitiveType::I16 | PrimitiveType::U16 | PrimitiveType::U32 | PrimitiveType::U64 => {
                false
            }
            // All other primitive types are blueprintable
            _ => true,
        },
        // Arrays are blueprintable if their element type is a struct/enum/primitive that can be used in Blueprint
        // TArray<USTRUCT> is always blueprintable, even if the USTRUCT has non-blueprintable fields
        AlgebraicTypeUse::Array(inner) => match inner.as_ref() {
            AlgebraicTypeUse::Ref(r) => {
                // TArray<CustomType> is blueprintable if CustomType is a UStruct/UEnum
                match &module.typespace_for_generate()[*r] {
                    AlgebraicTypeDef::Product(_) => true,   // TArray<USTRUCT> is always blueprintable
                    AlgebraicTypeDef::Sum(_) => true,       // TArray<UENUM> is always blueprintable
                    AlgebraicTypeDef::PlainEnum(_) => true, // TArray<PlainEnum> is always blueprintable
                }
            }
            // For primitive arrays, check if the primitive is blueprintable
            _ => is_blueprintable(module, inner),
        },
        AlgebraicTypeUse::String => true,
        AlgebraicTypeUse::Identity => true,
        AlgebraicTypeUse::ConnectionId => true,
        AlgebraicTypeUse::Timestamp => true,
        AlgebraicTypeUse::TimeDuration => true,
        AlgebraicTypeUse::Uuid => true,
        AlgebraicTypeUse::ScheduleAt => true, // ScheduleAt is blueprintable as a property (TObjectPtr)
        AlgebraicTypeUse::Unit => true,
        AlgebraicTypeUse::Ref(r) => {
            // For struct/class fields, USTRUCTs and UENUMs are always blueprintable as field types
            // The individual fields within the struct may not be accessible, but the struct itself can be used
            match &module.typespace_for_generate()[*r] {
                AlgebraicTypeDef::Product(_) => true, // USTRUCTs are always blueprintable as field types
                AlgebraicTypeDef::Sum(_) => true,     // Sum types are blueprintable
                AlgebraicTypeDef::PlainEnum(_) => true, // Enums are blueprintable
            }
        }
        AlgebraicTypeUse::Option(inner) => is_blueprintable(module, inner),
        AlgebraicTypeUse::Result { ok_ty, err_ty } => {
            is_blueprintable(module, ok_ty) && is_blueprintable(module, err_ty)
        }
        AlgebraicTypeUse::Never => false,
    }
}

// Helper function to check if a type can be used as a delegate parameter
// For delegates, structs are blueprintable even if they contain non-blueprintable fields