1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::fmt;

use itertools::Itertools;

use crate::decl::{
	legacy::{ExtensionDecl, ModuleDecl},
	Decl, FieldDecl, FunctionDecl, ImportPathDecl, ParamDecl, StructBody, StructDecl,
	TypeAliasDecl, VarDecl,
};

pub trait Tooltip {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result;
}

impl Tooltip for Decl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		use Decl::*;

		match self {
			Var(inner) | Const(inner) => Tooltip::fmt(inner, f),
			TypeAlias(inner) => Tooltip::fmt(inner, f),
			Struct(inner) => Tooltip::fmt(inner, f),
			Field(inner) => Tooltip::fmt(inner, f),
			Function(inner) => Tooltip::fmt(inner, f),
			Param(inner) => Tooltip::fmt(inner, f),
			Extension(inner) => Tooltip::fmt(inner, f),
			ImportPath(inner) => Tooltip::fmt(inner, f),
			Import(_) => {
				eprintln!(
					"WARNING: Tooltip-formatting `#import` declarations is not currently supported"
				);
				Ok(())
			}
			Module(inner) => Tooltip::fmt(inner, f),
		}
	}
}

impl Tooltip for VarDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		if let Some(ref attributes) = self.attributes {
			writeln!(f, "{}", attributes)?;
		}

		write!(f, "{}", self.storage)?;
		if let Some(ref qual) = self.storage_qualifiers {
			write!(f, "<{}>", qual.iter().join(", "))?;
		}

		write!(f, " {}", self.name)?;
		if let Some(ref ty) = self.ty {
			write!(f, ": {}", ty)?;
		}

		Ok(())
	}
}

impl Tooltip for TypeAliasDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "TODO")
	}
}

impl Tooltip for StructDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		if let Some(ref attributes) = self.attributes {
			writeln!(f, "{}", attributes)?;
		}

		write!(f, "{}", self.storage)?;
		if let Some(ref modifier) = self.storage_modifier {
			write!(f, "<{}>", modifier)?;
		}

		write!(f, " {} ", self.name)?;

		Tooltip::fmt(&self.body, f)
	}
}

impl Tooltip for StructBody {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		writeln!(f, "{{")?;

		for field in self.fields.iter() {
			if let Decl::Field(ref field) = field {
				writeln!(f, "\t{}", field)?;
			}
		}

		write!(f, "}};")
	}
}

impl Tooltip for FieldDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "{}", self)
	}
}

impl Tooltip for FunctionDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		if let Some(ref attributes) = self.attributes {
			writeln!(f, "{} ", attributes)?;
		}

		write!(f, "{}", self.storage)?;
		if let Some(ref modifier) = self.storage_modifier {
			write!(f, "<{}>", modifier)?;
		}

		write!(f, " {}(", self.name)?;
		for (idx, param) in self.params.iter().enumerate() {
			Tooltip::fmt(param, f)?;
			if idx < self.params.len() - 1 {
				write!(f, ", ")?;
			}
		}
		write!(f, ")")?;

		if let Some(ref ty) = self.return_ty {
			write!(f, " -> {}", ty)?;
		}

		Ok(())
	}
}

impl Tooltip for ParamDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		if let Some(ref attributes) = self.attributes {
			writeln!(f, "{} ", attributes)?;
		}

		write!(f, "{}: {}", self.name, self.ty)
	}
}

impl Tooltip for ExtensionDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "TODO")
	}
}

impl Tooltip for ImportPathDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "{} {}", self.keyword, self.qualified_name())
	}
}

impl Tooltip for ModuleDecl {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "import {} from {};", self.name, self.path)
	}
}