1use crate::r#type::module::*;
4use super::{TreeDisplay, TreeFormatter};
5
6impl TreeDisplay for Module {
7 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
8 f.root(&format!("Module [{}]", f.format_raw(self.span, source)))?;
9 f.field_vec(true, "directives", &self.directives, source)
10 }
11}
12
13impl TreeDisplay for ModuleDirective {
14 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
15 match self {
16 ModuleDirective::ModuleVariable { linkage, directive, span } => {
17 f.root(&format!("ModuleDirective::ModuleVariable [{}]", f.format_raw(*span, source)))?;
18 f.field_option(false, "linkage", linkage, source)?;
19 f.field_with_child(true, "directive", directive, source)
20 }
21 ModuleDirective::EntryFunction { linkage, directive, span } => {
22 f.root(&format!("ModuleDirective::EntryFunction [{}]", f.format_raw(*span, source)))?;
23 f.field_option(false, "linkage", linkage, source)?;
24 f.field_with_child(true, "directive", directive, source)
25 }
26 ModuleDirective::FuncFunction { linkage, directive, span } => {
27 f.root(&format!("ModuleDirective::FuncFunction [{}]", f.format_raw(*span, source)))?;
28 f.field_option(false, "linkage", linkage, source)?;
29 f.field_with_child(true, "directive", directive, source)
30 }
31 ModuleDirective::AliasFunction { directive, span } => {
32 f.root(&format!("ModuleDirective::AliasFunction [{}]", f.format_raw(*span, source)))?;
33 f.field_with_child(true, "directive", directive, source)
34 }
35 ModuleDirective::ModuleInfo { directive, span } => {
36 f.root(&format!("ModuleDirective::ModuleInfo [{}]", f.format_raw(*span, source)))?;
37 f.field_with_child(true, "directive", directive, source)
38 }
39 ModuleDirective::Debug { directive, span } => {
40 f.root(&format!("ModuleDirective::Debug [{}]", f.format_raw(*span, source)))?;
41 f.field_with_child(true, "directive", directive, source)
42 }
43 }
44 }
45}
46
47impl TreeDisplay for ModuleInfoDirectiveKind {
48 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
49 match self {
50 ModuleInfoDirectiveKind::Version { directive, span } => {
51 f.root(&format!("ModuleInfoDirectiveKind::Version [{}]", f.format_raw(*span, source)))?;
52 f.field_with_child(true, "directive", directive, source)
53 }
54 ModuleInfoDirectiveKind::Target { directive, span } => {
55 f.root(&format!("ModuleInfoDirectiveKind::Target [{}]", f.format_raw(*span, source)))?;
56 f.field_with_child(true, "directive", directive, source)
57 }
58 ModuleInfoDirectiveKind::AddressSize { directive, span } => {
59 f.root(&format!("ModuleInfoDirectiveKind::AddressSize [{}]", f.format_raw(*span, source)))?;
60 f.field_with_child(true, "directive", directive, source)
61 }
62 }
63 }
64}
65
66impl TreeDisplay for VersionDirective {
67 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
68 f.root(&format!("VersionDirective [{}]", f.format_raw(self.span, source)))?;
69 f.field(false, "major", &self.major.to_string())?;
70 f.field(true, "minor", &self.minor.to_string())
71 }
72}
73
74impl TreeDisplay for TargetDirective {
75 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
76 f.root(&format!("TargetDirective [{}]", f.format_raw(self.span, source)))?;
77 f.field_vec(true, "entries", &self.entries, source)
78 }
79}
80
81impl TreeDisplay for AddressSizeDirective {
82 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
83 f.root(&format!("AddressSizeDirective [{}]", f.format_raw(self.span, source)))?;
84 f.field_with_child(true, "size", &self.size, source)
85 }
86}
87
88impl TreeDisplay for ModuleDebugDirective {
89 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
90 match self {
91 ModuleDebugDirective::File { directive, span } => {
92 f.root(&format!("ModuleDebugDirective::File [{}]", f.format_raw(*span, source)))?;
93 f.field_with_child(true, "directive", directive, source)
94 }
95 ModuleDebugDirective::Section { directive, span } => {
96 f.root(&format!("ModuleDebugDirective::Section [{}]", f.format_raw(*span, source)))?;
97 f.field_with_child(true, "directive", directive, source)
98 }
99 ModuleDebugDirective::Dwarf { directive, span } => {
100 f.root(&format!("ModuleDebugDirective::Dwarf [{}]", f.format_raw(*span, source)))?;
101 f.field_with_child(true, "directive", directive, source)
102 }
103 }
104 }
105}
106
107impl TreeDisplay for FileDirective {
108 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
109 f.root(&format!("FileDirective [{}]", f.format_raw(self.span, source)))?;
110 f.field(false, "index", &self.index.to_string())?;
111 f.field(false, "path", &format!("\"{}\"", self.path))?;
112 match self.timestamp {
113 Some(t) => f.field(false, "timestamp", &format!("Some({})", t))?,
114 None => f.field(false, "timestamp", "None")?,
115 }
116 match self.file_size {
117 Some(s) => f.field(true, "file_size", &format!("Some({})", s)),
118 None => f.field(true, "file_size", "None"),
119 }
120 }
121}
122
123impl TreeDisplay for TargetString {
124 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
125 let (variant, span) = match self {
126 TargetString::Sm120a { span } => ("Sm120a", span),
127 TargetString::Sm120f { span } => ("Sm120f", span),
128 TargetString::Sm120 { span } => ("Sm120", span),
129 TargetString::Sm121a { span } => ("Sm121a", span),
130 TargetString::Sm121f { span } => ("Sm121f", span),
131 TargetString::Sm121 { span } => ("Sm121", span),
132 TargetString::Sm110a { span } => ("Sm110a", span),
133 TargetString::Sm110f { span } => ("Sm110f", span),
134 TargetString::Sm110 { span } => ("Sm110", span),
135 TargetString::Sm100a { span } => ("Sm100a", span),
136 TargetString::Sm100f { span } => ("Sm100f", span),
137 TargetString::Sm100 { span } => ("Sm100", span),
138 TargetString::Sm101a { span } => ("Sm101a", span),
139 TargetString::Sm101f { span } => ("Sm101f", span),
140 TargetString::Sm101 { span } => ("Sm101", span),
141 TargetString::Sm103a { span } => ("Sm103a", span),
142 TargetString::Sm103f { span } => ("Sm103f", span),
143 TargetString::Sm103 { span } => ("Sm103", span),
144 TargetString::Sm90a { span } => ("Sm90a", span),
145 TargetString::Sm90 { span } => ("Sm90", span),
146 TargetString::Sm80 { span } => ("Sm80", span),
147 TargetString::Sm86 { span } => ("Sm86", span),
148 TargetString::Sm87 { span } => ("Sm87", span),
149 TargetString::Sm88 { span } => ("Sm88", span),
150 TargetString::Sm89 { span } => ("Sm89", span),
151 TargetString::Sm70 { span } => ("Sm70", span),
152 TargetString::Sm72 { span } => ("Sm72", span),
153 TargetString::Sm75 { span } => ("Sm75", span),
154 TargetString::Sm60 { span } => ("Sm60", span),
155 TargetString::Sm61 { span } => ("Sm61", span),
156 TargetString::Sm62 { span } => ("Sm62", span),
157 TargetString::Sm50 { span } => ("Sm50", span),
158 TargetString::Sm52 { span } => ("Sm52", span),
159 TargetString::Sm53 { span } => ("Sm53", span),
160 TargetString::Sm30 { span } => ("Sm30", span),
161 TargetString::Sm32 { span } => ("Sm32", span),
162 TargetString::Sm35 { span } => ("Sm35", span),
163 TargetString::Sm37 { span } => ("Sm37", span),
164 TargetString::Sm20 { span } => ("Sm20", span),
165 TargetString::Sm10 { span } => ("Sm10", span),
166 TargetString::Sm11 { span } => ("Sm11", span),
167 TargetString::Sm12 { span } => ("Sm12", span),
168 TargetString::Sm13 { span } => ("Sm13", span),
169 TargetString::TexmodeUnified { span } => ("TexmodeUnified", span),
170 TargetString::TexmodeIndependent { span } => ("TexmodeIndependent", span),
171 TargetString::Debug { span } => ("Debug", span),
172 TargetString::MapF64ToF32 { span } => ("MapF64ToF32", span),
173 };
174 f.root(&format!("TargetString::{} [{}]", variant, f.format_raw(*span, source)))
175 }
176}
177
178impl TreeDisplay for AddressSize {
179 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
180 let (variant, span) = match self {
181 AddressSize::Size32 { span } => ("Size32", span),
182 AddressSize::Size64 { span } => ("Size64", span),
183 };
184 f.root(&format!("AddressSize::{} [{}]", variant, f.format_raw(*span, source)))
185 }
186}