ptx_parser/pretty_print/
module.rs

1// TreeDisplay implementations for module types (src/type/module.rs)
2
3use super::{TreeDisplay, TreeFormatter};
4use crate::r#type::module::*;
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 {
17                linkage,
18                directive,
19                span,
20            } => {
21                f.root(&format!(
22                    "ModuleDirective::ModuleVariable [{}]",
23                    f.format_raw(*span, source)
24                ))?;
25                f.field_option(false, "linkage", linkage, source)?;
26                f.field_with_child(true, "directive", directive, source)
27            }
28            ModuleDirective::EntryFunction {
29                linkage,
30                directive,
31                span,
32            } => {
33                f.root(&format!(
34                    "ModuleDirective::EntryFunction [{}]",
35                    f.format_raw(*span, source)
36                ))?;
37                f.field_option(false, "linkage", linkage, source)?;
38                f.field_with_child(true, "directive", directive, source)
39            }
40            ModuleDirective::FuncFunction {
41                linkage,
42                directive,
43                span,
44            } => {
45                f.root(&format!(
46                    "ModuleDirective::FuncFunction [{}]",
47                    f.format_raw(*span, source)
48                ))?;
49                f.field_option(false, "linkage", linkage, source)?;
50                f.field_with_child(true, "directive", directive, source)
51            }
52            ModuleDirective::AliasFunction { directive, span } => {
53                f.root(&format!(
54                    "ModuleDirective::AliasFunction [{}]",
55                    f.format_raw(*span, source)
56                ))?;
57                f.field_with_child(true, "directive", directive, source)
58            }
59            ModuleDirective::ModuleInfo { directive, span } => {
60                f.root(&format!(
61                    "ModuleDirective::ModuleInfo [{}]",
62                    f.format_raw(*span, source)
63                ))?;
64                f.field_with_child(true, "directive", directive, source)
65            }
66            ModuleDirective::Debug { directive, span } => {
67                f.root(&format!(
68                    "ModuleDirective::Debug [{}]",
69                    f.format_raw(*span, source)
70                ))?;
71                f.field_with_child(true, "directive", directive, source)
72            }
73        }
74    }
75}
76
77impl TreeDisplay for ModuleInfoDirectiveKind {
78    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
79        match self {
80            ModuleInfoDirectiveKind::Version { directive, span } => {
81                f.root(&format!(
82                    "ModuleInfoDirectiveKind::Version [{}]",
83                    f.format_raw(*span, source)
84                ))?;
85                f.field_with_child(true, "directive", directive, source)
86            }
87            ModuleInfoDirectiveKind::Target { directive, span } => {
88                f.root(&format!(
89                    "ModuleInfoDirectiveKind::Target [{}]",
90                    f.format_raw(*span, source)
91                ))?;
92                f.field_with_child(true, "directive", directive, source)
93            }
94            ModuleInfoDirectiveKind::AddressSize { directive, span } => {
95                f.root(&format!(
96                    "ModuleInfoDirectiveKind::AddressSize [{}]",
97                    f.format_raw(*span, source)
98                ))?;
99                f.field_with_child(true, "directive", directive, source)
100            }
101        }
102    }
103}
104
105impl TreeDisplay for VersionDirective {
106    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
107        f.root(&format!(
108            "VersionDirective [{}]",
109            f.format_raw(self.span, source)
110        ))?;
111        f.field(false, "major", &self.major.to_string())?;
112        f.field(true, "minor", &self.minor.to_string())
113    }
114}
115
116impl TreeDisplay for TargetDirective {
117    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
118        f.root(&format!(
119            "TargetDirective [{}]",
120            f.format_raw(self.span, source)
121        ))?;
122        f.field_vec(true, "entries", &self.entries, source)
123    }
124}
125
126impl TreeDisplay for AddressSizeDirective {
127    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
128        f.root(&format!(
129            "AddressSizeDirective [{}]",
130            f.format_raw(self.span, source)
131        ))?;
132        f.field_with_child(true, "size", &self.size, source)
133    }
134}
135
136impl TreeDisplay for ModuleDebugDirective {
137    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
138        match self {
139            ModuleDebugDirective::File { directive, span } => {
140                f.root(&format!(
141                    "ModuleDebugDirective::File [{}]",
142                    f.format_raw(*span, source)
143                ))?;
144                f.field_with_child(true, "directive", directive, source)
145            }
146            ModuleDebugDirective::Section { directive, span } => {
147                f.root(&format!(
148                    "ModuleDebugDirective::Section [{}]",
149                    f.format_raw(*span, source)
150                ))?;
151                f.field_with_child(true, "directive", directive, source)
152            }
153            ModuleDebugDirective::Dwarf { directive, span } => {
154                f.root(&format!(
155                    "ModuleDebugDirective::Dwarf [{}]",
156                    f.format_raw(*span, source)
157                ))?;
158                f.field_with_child(true, "directive", directive, source)
159            }
160        }
161    }
162}
163
164impl TreeDisplay for FileDirective {
165    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
166        f.root(&format!(
167            "FileDirective [{}]",
168            f.format_raw(self.span, source)
169        ))?;
170        f.field(false, "index", &self.index.to_string())?;
171        f.field(false, "path", &format!("\"{}\"", self.path))?;
172        match self.timestamp {
173            Some(t) => f.field(false, "timestamp", &format!("Some({})", t))?,
174            None => f.field(false, "timestamp", "None")?,
175        }
176        match self.file_size {
177            Some(s) => f.field(true, "file_size", &format!("Some({})", s)),
178            None => f.field(true, "file_size", "None"),
179        }
180    }
181}
182
183impl TreeDisplay for TargetString {
184    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
185        let (variant, span) = match self {
186            TargetString::Sm120a { span } => ("Sm120a", span),
187            TargetString::Sm120f { span } => ("Sm120f", span),
188            TargetString::Sm120 { span } => ("Sm120", span),
189            TargetString::Sm121a { span } => ("Sm121a", span),
190            TargetString::Sm121f { span } => ("Sm121f", span),
191            TargetString::Sm121 { span } => ("Sm121", span),
192            TargetString::Sm110a { span } => ("Sm110a", span),
193            TargetString::Sm110f { span } => ("Sm110f", span),
194            TargetString::Sm110 { span } => ("Sm110", span),
195            TargetString::Sm100a { span } => ("Sm100a", span),
196            TargetString::Sm100f { span } => ("Sm100f", span),
197            TargetString::Sm100 { span } => ("Sm100", span),
198            TargetString::Sm101a { span } => ("Sm101a", span),
199            TargetString::Sm101f { span } => ("Sm101f", span),
200            TargetString::Sm101 { span } => ("Sm101", span),
201            TargetString::Sm103a { span } => ("Sm103a", span),
202            TargetString::Sm103f { span } => ("Sm103f", span),
203            TargetString::Sm103 { span } => ("Sm103", span),
204            TargetString::Sm90a { span } => ("Sm90a", span),
205            TargetString::Sm90 { span } => ("Sm90", span),
206            TargetString::Sm80 { span } => ("Sm80", span),
207            TargetString::Sm86 { span } => ("Sm86", span),
208            TargetString::Sm87 { span } => ("Sm87", span),
209            TargetString::Sm88 { span } => ("Sm88", span),
210            TargetString::Sm89 { span } => ("Sm89", span),
211            TargetString::Sm70 { span } => ("Sm70", span),
212            TargetString::Sm72 { span } => ("Sm72", span),
213            TargetString::Sm75 { span } => ("Sm75", span),
214            TargetString::Sm60 { span } => ("Sm60", span),
215            TargetString::Sm61 { span } => ("Sm61", span),
216            TargetString::Sm62 { span } => ("Sm62", span),
217            TargetString::Sm50 { span } => ("Sm50", span),
218            TargetString::Sm52 { span } => ("Sm52", span),
219            TargetString::Sm53 { span } => ("Sm53", span),
220            TargetString::Sm30 { span } => ("Sm30", span),
221            TargetString::Sm32 { span } => ("Sm32", span),
222            TargetString::Sm35 { span } => ("Sm35", span),
223            TargetString::Sm37 { span } => ("Sm37", span),
224            TargetString::Sm20 { span } => ("Sm20", span),
225            TargetString::Sm10 { span } => ("Sm10", span),
226            TargetString::Sm11 { span } => ("Sm11", span),
227            TargetString::Sm12 { span } => ("Sm12", span),
228            TargetString::Sm13 { span } => ("Sm13", span),
229            TargetString::TexmodeUnified { span } => ("TexmodeUnified", span),
230            TargetString::TexmodeIndependent { span } => ("TexmodeIndependent", span),
231            TargetString::Debug { span } => ("Debug", span),
232            TargetString::MapF64ToF32 { span } => ("MapF64ToF32", span),
233        };
234        f.root(&format!(
235            "TargetString::{} [{}]",
236            variant,
237            f.format_raw(*span, source)
238        ))
239    }
240}
241
242impl TreeDisplay for AddressSize {
243    fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
244        let (variant, span) = match self {
245            AddressSize::Size32 { span } => ("Size32", span),
246            AddressSize::Size64 { span } => ("Size64", span),
247        };
248        f.root(&format!(
249            "AddressSize::{} [{}]",
250            variant,
251            f.format_raw(*span, source)
252        ))
253    }
254}
ptx_parser/pretty_print/module.rs

ptx_parser/pretty_print/
module.rs
