fn typekind_to_ty()

in api_generator/src/generator/code_gen/mod.rs [167:230]

• 57 lines of code
• 11 McCabe index (conditional complexity)

fn typekind_to_ty(name: &str, kind: &TypeKind, required: bool, fn_arg: bool) -> syn::Ty {
    let mut v = String::new();
    if !required {
        v.push_str("Option<");
    }

    let str_type = "&'b str";
    match kind {
        TypeKind::Unknown(_) => v.push_str(str_type),
        TypeKind::List => {
            v.push_str("&'b [");
            v.push_str(str_type);
            v.push(']');
        }
        TypeKind::Enum => match name {
            // opened https://github.com/elastic/elasticsearch/issues/53212
            // to discuss whether this really should be a collection
            "expand_wildcards" => {
                // Expand wildcards should
                v.push_str("&'b [");
                v.push_str(name.to_pascal_case().as_str());
                v.push(']');
            }
            _ => v.push_str(name.to_pascal_case().as_str()),
        },
        TypeKind::String => v.push_str(str_type),
        TypeKind::Text => v.push_str(str_type),
        TypeKind::Boolean => match name {
            // keep until https://github.com/elastic/elasticsearch/pull/57329 is merged
            "track_total_hits" => {
                if fn_arg {
                    v.push_str(format!("Into<{}>", name.to_pascal_case()).as_str())
                } else {
                    v.push_str(name.to_pascal_case().as_str())
                }
            }
            _ => v.push_str("bool"),
        },
        TypeKind::Number => v.push_str("i64"),
        TypeKind::Float => v.push_str("f32"),
        TypeKind::Double => v.push_str("f64"),
        TypeKind::Integer => v.push_str("i32"),
        TypeKind::Long => v.push_str("i64"),
        TypeKind::Date => v.push_str(str_type),
        TypeKind::Time => v.push_str(str_type),
        TypeKind::Union(u) => match name {
            "slices" => v.push_str("Slices"),
            "track_total_hits" => {
                if fn_arg {
                    v.push_str(format!("Into<{}>", name.to_pascal_case()).as_str())
                } else {
                    v.push_str(name.to_pascal_case().as_str())
                }
            }
            _ => panic!("unsupported union type: {:?} for {}", u, name),
        },
    };

    if !required {
        v.push('>');
    }

    syn::parse_type(v.as_str()).unwrap()
}