Coverage Report

Created: 2026-09-28 08:25

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, Span, 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
/// Variant-level serialize_with for struct variants that have an id and a
35
/// skipped span, preserving the old newtype serialization format.
36
0
pub fn serialize_id_ignore_span<T, S>(
37
0
    id: &Id<T>,
38
0
    _span: &Span,
39
0
    serializer: S,
40
0
) -> Result<S::Ok, S::Error>
41
0
where
42
0
    S: Serializer,
43
{
44
0
    serialize_id(id, serializer)
45
0
}
46
47
0
pub fn serialize_optional_id<T, S>(id: &Option<Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
48
0
where
49
0
    S: Serializer,
50
{
51
0
    match id {
52
0
        Some(id) => serialize_id(&id, serializer),
53
0
        None => serializer.serialize_none(),
54
    }
55
0
}
56
57
0
pub fn serialize_id_map<K, T, S>(map: &IndexMap<K, Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
58
0
where
59
0
    K: Serialize,
60
0
    S: Serializer,
61
{
62
0
    let mut s = serializer.serialize_map(Some(map.len()))?;
63
0
    for (key, id) in map.iter() {
64
0
        s.serialize_entry(key, &(id.index() as u64))?;
65
    }
66
0
    s.end()
67
0
}
68
69
impl Serialize for Type {
70
0
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
71
0
    where
72
0
        S: Serializer,
73
    {
74
0
        match self {
75
0
            Type::Bool => serializer.serialize_str("bool"),
76
0
            Type::U8 => serializer.serialize_str("u8"),
77
0
            Type::U16 => serializer.serialize_str("u16"),
78
0
            Type::U32 => serializer.serialize_str("u32"),
79
0
            Type::U64 => serializer.serialize_str("u64"),
80
0
            Type::S8 => serializer.serialize_str("s8"),
81
0
            Type::S16 => serializer.serialize_str("s16"),
82
0
            Type::S32 => serializer.serialize_str("s32"),
83
0
            Type::S64 => serializer.serialize_str("s64"),
84
0
            Type::F32 => serializer.serialize_str("f32"),
85
0
            Type::F64 => serializer.serialize_str("f64"),
86
0
            Type::Char => serializer.serialize_str("char"),
87
0
            Type::String => serializer.serialize_str("string"),
88
0
            Type::ErrorContext => serializer.serialize_str("error-context"),
89
0
            Type::Id(type_id) => serializer.serialize_u64(type_id.index() as u64),
90
        }
91
0
    }
92
}
93
94
3.16k
pub fn serialize_version<S>(version: &Version, serializer: S) -> Result<S::Ok, S::Error>
95
3.16k
where
96
3.16k
    S: Serializer,
97
{
98
3.16k
    version.to_string().serialize(serializer)
99
3.16k
}
100
101
1.45k
pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
102
1.45k
where
103
1.45k
    D: serde::de::Deserializer<'de>,
104
{
105
1.45k
    let version: String = String::deserialize(deserializer)?;
106
1.45k
    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}
107
1.45k
}
wit_parser::serde_::deserialize_version::<serde::private::de::content::ContentRefDeserializer<serde_json::error::Error>>
Line
Count
Source
101
488
pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
102
488
where
103
488
    D: serde::de::Deserializer<'de>,
104
{
105
488
    let version: String = String::deserialize(deserializer)?;
106
488
    version.parse().map_err(|e| D::Error::custom(e))
107
488
}
wit_parser::serde_::deserialize_version::<&mut serde_json::de::Deserializer<serde_json::read::SliceRead>>
Line
Count
Source
101
971
pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
102
971
where
103
971
    D: serde::de::Deserializer<'de>,
104
{
105
971
    let version: String = String::deserialize(deserializer)?;
106
971
    version.parse().map_err(|e| D::Error::custom(e))
107
971
}
108
109
989
pub fn serialize_optional_version<S>(
110
989
    version: &Option<Version>,
111
989
    serializer: S,
112
989
) -> Result<S::Ok, S::Error>
113
989
where
114
989
    S: Serializer,
115
{
116
989
    version
117
989
        .as_ref()
118
989
        .map(|s| s.to_string())
119
989
        .serialize(serializer)
120
989
}
121
122
439
pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
123
439
where
124
439
    D: serde::de::Deserializer<'de>,
125
{
126
439
    match <Option<String>>::deserialize(deserializer)? {
127
439
        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}
128
0
        None => Ok(None),
129
    }
130
439
}
wit_parser::serde_::deserialize_optional_version::<serde::private::de::content::ContentRefDeserializer<serde_json::error::Error>>
Line
Count
Source
122
70
pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
123
70
where
124
70
    D: serde::de::Deserializer<'de>,
125
{
126
70
    match <Option<String>>::deserialize(deserializer)? {
127
70
        Some(version) => Ok(Some(version.parse().map_err(|e| D::Error::custom(e))?)),
128
0
        None => Ok(None),
129
    }
130
70
}
wit_parser::serde_::deserialize_optional_version::<&mut serde_json::de::Deserializer<serde_json::read::SliceRead>>
Line
Count
Source
122
369
pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
123
369
where
124
369
    D: serde::de::Deserializer<'de>,
125
{
126
369
    match <Option<String>>::deserialize(deserializer)? {
127
369
        Some(version) => Ok(Some(version.parse().map_err(|e| D::Error::custom(e))?)),
128
0
        None => Ok(None),
129
    }
130
369
}