1 use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
2 use std::fmt;
3 
4 use crate::{
5     api::{Language, SyntaxNode, SyntaxToken},
6     NodeOrToken,
7 };
8 
9 struct SerDisplay<T>(T);
10 impl<T: fmt::Display> Serialize for SerDisplay<T> {
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,11     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
12     where
13         S: Serializer,
14     {
15         serializer.collect_str(&self.0)
16     }
17 }
18 
19 struct DisplayDebug<T>(T);
20 impl<T: fmt::Debug> fmt::Display for DisplayDebug<T> {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result21     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
22         fmt::Debug::fmt(&self.0, f)
23     }
24 }
25 
26 impl<L: Language> Serialize for SyntaxNode<L> {
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,27     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
28     where
29         S: Serializer,
30     {
31         let mut state = serializer.serialize_map(Some(3))?;
32         state.serialize_entry("kind", &SerDisplay(DisplayDebug(self.kind())))?;
33         state.serialize_entry("text_range", &self.text_range())?;
34         state.serialize_entry("children", &Children(self))?;
35         state.end()
36     }
37 }
38 
39 impl<L: Language> Serialize for SyntaxToken<L> {
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,40     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
41     where
42         S: Serializer,
43     {
44         let mut state = serializer.serialize_map(Some(3))?;
45         state.serialize_entry("kind", &SerDisplay(DisplayDebug(self.kind())))?;
46         state.serialize_entry("text_range", &self.text_range())?;
47         state.serialize_entry("text", &self.text())?;
48         state.end()
49     }
50 }
51 
52 struct Children<T>(T);
53 
54 impl<L: Language> Serialize for Children<&'_ SyntaxNode<L>> {
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,55     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
56     where
57         S: Serializer,
58     {
59         let mut state = serializer.serialize_seq(None)?;
60         self.0.children_with_tokens().try_for_each(|element| match element {
61             NodeOrToken::Node(it) => state.serialize_element(&it),
62             NodeOrToken::Token(it) => state.serialize_element(&it),
63         })?;
64         state.end()
65     }
66 }
67