Function write_primitive2

libs/llrt_json/src/stringify.rs:203–292

(
    context: &mut StringifyContext<'_, 'js>,
    add_comma: bool,
    new_value: Option<Value<'js>>,
)

}

fn write_primitive2<'js>(
    context: &mut StringifyContext<'_, 'js>,
    add_comma: bool,
    new_value: Option<Value<'js>>,
) -> Result<PrimitiveStatus<'js>> {
    let key = context.key;
    let index = context.index;
    let include_keys_replacer = context.include_keys_replacer;
    let indentation = context.indentation;
    let depth = context.depth;

    let value = new_value.as_ref().unwrap_or(context.value);

    let type_of = value.type_of();

    if context.index.is_none()
        && matches!(
            type_of,
            Type::Symbol | Type::Undefined | Type::Function | Type::Constructor
        )
    {
        return Ok(PrimitiveStatus::Ignored);
    }

    if matches!(type_of, Type::BigInt) {
        return Err(Exception::throw_type(
            context.ctx,
            "Do not know how to serialize a BigInt",
        ));
    }

    if let Some(include_keys_replacer) = include_keys_replacer {
        let key = get_key_or_index(context.itoa_buffer, key, index);
        if !include_keys_replacer.contains(key) {
            return Ok(PrimitiveStatus::Ignored);
        }
    };

    if let Some(indentation) = indentation {
        write_indented_separator(context.result, key, add_comma, indentation, depth);
    } else {
        write_sep(context.result, add_comma, false);
        if let Some(key) = key {
            write_key(context.result, key, false);
        }
    }

    match type_of {
        Type::Null | Type::Undefined => context.result.push_str("null"),
        Type::Bool => {
            let bool_str = if unsafe { value.as_bool().unwrap_unchecked() } {
                "true"
            } else {
                "false"
            };
            context.result.push_str(bool_str);
        },
        Type::Int => context.result.push_str(