rustdoc/html/render/search_index/
serde.rs

1use std::fmt::{self, Formatter};
2
3use rustc_span::Symbol;
4use serde::de::{self, SeqAccess};
5use serde::ser::SerializeSeq as _;
6use serde::{Deserialize, Deserializer, Serialize, Serializer};
7
8use crate::html::render::IndexItemFunctionType;
9
10impl Serialize for IndexItemFunctionType {
11    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
12    where
13        S: Serializer,
14    {
15        struct ParamNames<'a>(&'a [Option<Symbol>]);
16
17        impl<'a> Serialize for ParamNames<'a> {
18            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
19            where
20                S: Serializer,
21            {
22                serializer.collect_seq(
23                    self.0
24                        .iter()
25                        .map(|symbol| symbol.as_ref().map(Symbol::as_str).unwrap_or_default()),
26                )
27            }
28        }
29
30        let mut seq = serializer.serialize_seq(Some(2))?;
31
32        let mut fn_type = String::new();
33        self.write_to_string_without_param_names(&mut fn_type);
34        seq.serialize_element(&fn_type)?;
35
36        seq.serialize_element(&ParamNames(&self.param_names))?;
37
38        seq.end()
39    }
40}
41
42impl<'de> Deserialize<'de> for IndexItemFunctionType {
43    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
44    where
45        D: Deserializer<'de>,
46    {
47        #[derive(Deserialize)]
48        struct Deserialized {
49            #[serde(deserialize_with = "function_signature")]
50            function_signature: IndexItemFunctionType,
51            #[serde(deserialize_with = "param_names")]
52            param_names: Vec<Option<Symbol>>,
53        }
54
55        fn function_signature<'de, D: Deserializer<'de>>(
56            deserializer: D,
57        ) -> Result<IndexItemFunctionType, D::Error> {
58            String::deserialize(deserializer).map(|sig| {
59                IndexItemFunctionType::read_from_string_without_param_names(sig.as_bytes()).0
60            })
61        }
62
63        fn param_names<'de, D: Deserializer<'de>>(
64            deserializer: D,
65        ) -> Result<Vec<Option<Symbol>>, D::Error> {
66            struct Visitor;
67
68            impl<'de> de::Visitor<'de> for Visitor {
69                type Value = Vec<Option<Symbol>>;
70
71                fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
72                    f.write_str("seq of param names")
73                }
74
75                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
76                where
77                    A: SeqAccess<'de>,
78                {
79                    let mut param_names = Vec::with_capacity(seq.size_hint().unwrap_or_default());
80
81                    while let Some(symbol) = seq.next_element::<String>()? {
82                        param_names.push(if symbol.is_empty() {
83                            None
84                        } else {
85                            Some(Symbol::intern(&symbol))
86                        });
87                    }
88
89                    Ok(param_names)
90                }
91            }
92
93            deserializer.deserialize_seq(Visitor)
94        }
95
96        let Deserialized { mut function_signature, param_names } =
97            Deserialized::deserialize(deserializer)?;
98        function_signature.param_names = param_names;
99
100        Ok(function_signature)
101    }
102}
rustdoc/html/render/search_index/serde.rs

rustdoc/html/render/search_index/
serde.rs
