Coverage Report

Created: 2026-01-22 08:11

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/wasm-tools/crates/wit-parser/src/serde_.rs
Line
Count
Source
1
use crate::{IndexMap, Type};
2
use alloc::string::{String, ToString};
3
use id_arena::{Arena, Id};
4
use semver::Version;
5
use serde::ser::{SerializeMap, SerializeSeq, Serializer};
6
use serde::{Deserialize, Serialize, de::Error};
7
8
0
pub fn serialize_none<S>(serializer: S) -> Result<S::Ok, S::Error>
9
0
where
10
0
    S: Serializer,
11
{
12
0
    serializer.serialize_none()
13
0
}
14
15
0
pub fn serialize_arena<T, S>(arena: &Arena<T>, serializer: S) -> Result<S::Ok, S::Error>
16
0
where
17
0
    T: Serialize,
18
0
    S: Serializer,
19
{
20
0
    let mut seq = serializer.serialize_seq(Some(arena.len()))?;
21
0
    for (_, item) in arena.iter() {
22
0
        seq.serialize_element(&item)?;
23
    }
24
0
    seq.end()
25
0
}
26
27
0
pub fn serialize_id<T, S>(id: &Id<T>, serializer: S) -> Result<S::Ok, S::Error>
28
0
where
29
0
    S: Serializer,
30
{
31
0
    serializer.serialize_u64(id.index() as u64)
32
0
}
33
34
0
pub fn serialize_optional_id<T, S>(id: &Option<Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
35
0
where
36
0
    S: Serializer,
37
{
38
0
    match id {
39
0
        Some(id) => serialize_id(&id, serializer),
40
0
        None => serializer.serialize_none(),
41
    }
42
0
}
43
44
0
pub fn serialize_id_map<K, T, S>(map: &IndexMap<K, Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
45
0
where
46
0
    K: Serialize,
47
0
    S: Serializer,
48
{
49
0
    let mut s = serializer.serialize_map(Some(map.len()))?;
50
0
    for (key, id) in map.iter() {
51
0
        s.serialize_entry(key, &(id.index() as u64))?;
52
    }
53
0
    s.end()
54
0
}
55
56
impl Serialize for Type {
57
0
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
58
0
    where
59
0
        S: Serializer,
60
    {
61
0
        match self {
62
0
            Type::Bool => serializer.serialize_str("bool"),
63
0
            Type::U8 => serializer.serialize_str("u8"),
64
0
            Type::U16 => serializer.serialize_str("u16"),
65
0
            Type::U32 => serializer.serialize_str("u32"),
66
0
            Type::U64 => serializer.serialize_str("u64"),
67
0
            Type::S8 => serializer.serialize_str("s8"),
68
0
            Type::S16 => serializer.serialize_str("s16"),
69
0
            Type::S32 => serializer.serialize_str("s32"),
70
0
            Type::S64 => serializer.serialize_str("s64"),
71
0
            Type::F32 => serializer.serialize_str("f32"),
72
0
            Type::F64 => serializer.serialize_str("f64"),
73
0
            Type::Char => serializer.serialize_str("char"),
74
0
            Type::String => serializer.serialize_str("string"),
75
0
            Type::ErrorContext => serializer.serialize_str("error-context"),
76
0
            Type::Id(type_id) => serializer.serialize_u64(type_id.index() as u64),
77
        }
78
0
    }
79
}
80
81
0
pub fn serialize_params<S>(params: &[(String, Type)], serializer: S) -> Result<S::Ok, S::Error>
82
0
where
83
0
    S: Serializer,
84
{
85
0
    let mut seq = serializer.serialize_seq(Some(params.len()))?;
86
0
    for (name, typ) in params.iter() {
87
0
        let param = Param {
88
0
            name: name.to_string(),
89
0
            typ: *typ,
90
0
        };
91
0
        seq.serialize_element(&param)?;
92
    }
93
0
    seq.end()
94
0
}
95
96
#[derive(Debug, Clone, PartialEq, serde_derive::Serialize)]
97
struct Param {
98
    #[serde(skip_serializing_if = "String::is_empty")]
99
    pub name: String,
100
    #[serde(rename = "type")]
101
    pub typ: Type,
102
}
103
104
3.61k
pub fn serialize_version<S>(version: &Version, serializer: S) -> Result<S::Ok, S::Error>
105
3.61k
where
106
3.61k
    S: Serializer,
107
{
108
3.61k
    version.to_string().serialize(serializer)
109
3.61k
}
110
111
1.84k
pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
112
1.84k
where
113
1.84k
    D: serde::de::Deserializer<'de>,
114
{
115
1.84k
    let version: String = String::deserialize(deserializer)?;
116
1.84k
    version.parse().map_err(|e| D::Error::custom(e))
Unexecuted instantiation: wit_parser::serde_::deserialize_version::<serde::__private::de::content::ContentRefDeserializer<serde_json::error::Error>>::{closure#0}
Unexecuted instantiation: wit_parser::serde_::deserialize_version::<&mut serde_json::de::Deserializer<serde_json::read::SliceRead>>::{closure#0}
117
1.84k
}
wit_parser::serde_::deserialize_version::<serde::__private::de::content::ContentRefDeserializer<serde_json::error::Error>>
Line
Count
Source
111
739
pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
112
739
where
113
739
    D: serde::de::Deserializer<'de>,
114
{
115
739
    let version: String = String::deserialize(deserializer)?;
116
739
    version.parse().map_err(|e| D::Error::custom(e))
117
739
}
wit_parser::serde_::deserialize_version::<&mut serde_json::de::Deserializer<serde_json::read::SliceRead>>
Line
Count
Source
111
1.11k
pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
112
1.11k
where
113
1.11k
    D: serde::de::Deserializer<'de>,
114
{
115
1.11k
    let version: String = String::deserialize(deserializer)?;
116
1.11k
    version.parse().map_err(|e| D::Error::custom(e))
117
1.11k
}
118
119
1.13k
pub fn serialize_optional_version<S>(
120
1.13k
    version: &Option<Version>,
121
1.13k
    serializer: S,
122
1.13k
) -> Result<S::Ok, S::Error>
123
1.13k
where
124
1.13k
    S: Serializer,
125
{
126
1.13k
    version
127
1.13k
        .as_ref()
128
1.13k
        .map(|s| s.to_string())
129
1.13k
        .serialize(serializer)
130
1.13k
}
131
132
571
pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
133
571
where
134
571
    D: serde::de::Deserializer<'de>,
135
{
136
571
    match <Option<String>>::deserialize(deserializer)? {
137
571
        Some(version) => Ok(Some(version.parse().map_err(|e| D::Error::custom(e))?)),
Unexecuted instantiation: wit_parser::serde_::deserialize_optional_version::<serde::__private::de::content::ContentRefDeserializer<serde_json::error::Error>>::{closure#0}
Unexecuted instantiation: wit_parser::serde_::deserialize_optional_version::<&mut serde_json::de::Deserializer<serde_json::read::SliceRead>>::{closure#0}
138
0
        None => Ok(None),
139
    }
140
571
}
wit_parser::serde_::deserialize_optional_version::<serde::__private::de::content::ContentRefDeserializer<serde_json::error::Error>>
Line
Count
Source
132
177
pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
133
177
where
134
177
    D: serde::de::Deserializer<'de>,
135
{
136
177
    match <Option<String>>::deserialize(deserializer)? {
137
177
        Some(version) => Ok(Some(version.parse().map_err(|e| D::Error::custom(e))?)),
138
0
        None => Ok(None),
139
    }
140
177
}
wit_parser::serde_::deserialize_optional_version::<&mut serde_json::de::Deserializer<serde_json::read::SliceRead>>
Line
Count
Source
132
394
pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
133
394
where
134
394
    D: serde::de::Deserializer<'de>,
135
{
136
394
    match <Option<String>>::deserialize(deserializer)? {
137
394
        Some(version) => Ok(Some(version.parse().map_err(|e| D::Error::custom(e))?)),
138
0
        None => Ok(None),
139
    }
140
394
}