├── .gitignore ├── screenshot.png ├── Cargo.toml ├── README.md ├── LICENSE-MIT.txt ├── src ├── template.html └── lib.rs └── LICENSE-APACHE.txt /.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | Cargo.lock 3 | -------------------------------------------------------------------------------- /screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Diggsey/spanr/HEAD/screenshot.png -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "spanr" 3 | version = "0.1.0" 4 | authors = ["Diggory Blake "] 5 | edition = "2018" 6 | license = "MIT OR Apache-2.0" 7 | keywords = ["macros", "span", "debug"] 8 | categories = ["development-tools::procedural-macro-helpers"] 9 | description = "A tool for proc-macro authors to visualize the spans on generated code." 10 | 11 | [package.metadata.docs.rs] 12 | rustc-args = ["--cfg", "procmacro2_semver_exempt"] 13 | rustdoc-args = ["--cfg", "procmacro2_semver_exempt"] 14 | targets = ["x86_64-unknown-linux-gnu"] 15 | 16 | [dependencies] 17 | proc-macro2 = { version = "1.0.19", features = ["span-locations"] } 18 | html-escape = "0.2.6" 19 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # spanr 2 | 3 | A tool for procedural macro authors to be able to interactively view and debug 4 | the `Span`s on generated code. 5 | 6 | ## Screenshot 7 | 8 | ![screenshot](screenshot.png) 9 | 10 | ## Example usage 11 | 12 | ```rust 13 | #[proc_macro_attribute] 14 | pub fn act_zero(_attr: TokenStream, item: TokenStream) -> TokenStream { 15 | let res = match act_zero_impl(item) { 16 | Ok(tokens) => tokens, 17 | Err(e) => e.to_compile_error(), 18 | }; 19 | // Save the visualization to a file 20 | spanr::save_html(res.clone(), "tokens.html").unwrap(); 21 | res.into() 22 | } 23 | ``` 24 | 25 | ## Building 26 | 27 | This crate relies on unstable features from the `proc-macro2` crate, so it must 28 | be built using a nightly compiler, and the `RUSTFLAGS` environment variable 29 | must be configured: 30 | 31 | ```bash 32 | RUSTFLAGS='--cfg procmacro2_semver_exempt' 33 | ``` 34 | -------------------------------------------------------------------------------- /LICENSE-MIT.txt: -------------------------------------------------------------------------------- 1 | Permission is hereby granted, free of charge, to any 2 | person obtaining a copy of this software and associated 3 | documentation files (the "Software"), to deal in the 4 | Software without restriction, including without 5 | limitation the rights to use, copy, modify, merge, 6 | publish, distribute, sublicense, and/or sell copies of 7 | the Software, and to permit persons to whom the Software 8 | is furnished to do so, subject to the following 9 | conditions: 10 | 11 | The above copyright notice and this permission notice 12 | shall be included in all copies or substantial portions 13 | of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF 16 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 17 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 18 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 19 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 21 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 22 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 | DEALINGS IN THE SOFTWARE. 24 | -------------------------------------------------------------------------------- /src/template.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 38 | 39 | 40 |
{LEFT}
41 | 42 |
{BOTTOM}
43 | 92 | 93 | 94 | -------------------------------------------------------------------------------- /LICENSE-APACHE.txt: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | use std::collections::{HashMap, HashSet}; 2 | use std::fs; 3 | use std::path::{Path, PathBuf}; 4 | 5 | use html_escape::encode_text; 6 | use proc_macro2::{Delimiter, LineColumn, Spacing, Span, TokenStream, TokenTree}; 7 | 8 | const TEMPLATE_HTML: &str = include_str!("template.html"); 9 | 10 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] 11 | struct Position { 12 | line: usize, 13 | column: usize, 14 | } 15 | 16 | impl From for Position { 17 | fn from(other: LineColumn) -> Self { 18 | Self { 19 | line: other.line, 20 | column: other.column, 21 | } 22 | } 23 | } 24 | 25 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] 26 | enum SeparatorType { 27 | Start, 28 | End, 29 | } 30 | 31 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] 32 | struct RangeSeparator { 33 | pos: Position, 34 | sep: SeparatorType, 35 | idx: usize, 36 | } 37 | 38 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] 39 | struct Range { 40 | source: usize, 41 | start: Position, 42 | end: Position, 43 | } 44 | 45 | #[derive(Default, Debug, Clone)] 46 | struct Ranges { 47 | sources: HashMap, 48 | ranges: HashMap, 49 | generated: Vec<(String, Option)>, 50 | } 51 | 52 | #[derive(Copy, Clone, Debug, PartialEq, Eq)] 53 | enum NeedsSpace { 54 | Never, 55 | Always, 56 | IfNotPunct, 57 | } 58 | 59 | #[derive(Debug, Clone)] 60 | struct TokenVisitor { 61 | ranges: Ranges, 62 | indent: usize, 63 | newline: bool, 64 | needs_space: NeedsSpace, 65 | } 66 | 67 | impl TokenVisitor { 68 | fn add_span(&mut self, span: Span) -> Option { 69 | let source_file = span.source_file(); 70 | if source_file.is_real() { 71 | let num_sources = self.ranges.sources.len(); 72 | let source = *self 73 | .ranges 74 | .sources 75 | .entry(source_file.path()) 76 | .or_insert(num_sources); 77 | let range = Range { 78 | source, 79 | start: span.start().into(), 80 | end: span.end().into(), 81 | }; 82 | let num_ranges = self.ranges.ranges.len(); 83 | let range_idx = *self.ranges.ranges.entry(range).or_insert(num_ranges); 84 | Some(range_idx) 85 | } else { 86 | None 87 | } 88 | } 89 | fn add_str(&mut self, s: &str, range_idx: Option) { 90 | self.ranges.generated.push((s.into(), range_idx)); 91 | } 92 | fn visit_str(&mut self, s: &str, span: Span) { 93 | if s.is_empty() { 94 | return; 95 | } 96 | let range_idx = self.add_span(span); 97 | match s { 98 | "}" => { 99 | self.indent -= 1; 100 | if !self.newline { 101 | self.newline = true; 102 | self.add_str("\n", None); 103 | } 104 | } 105 | _ => {} 106 | } 107 | if self.newline { 108 | self.newline = false; 109 | for _ in 0..self.indent { 110 | self.add_str(" ", None); 111 | } 112 | } 113 | self.add_str(s, range_idx); 114 | match s { 115 | "{" => { 116 | self.indent += 1; 117 | self.newline = true; 118 | self.add_str("\n", None); 119 | } 120 | ";" | "}" => { 121 | self.newline = true; 122 | self.add_str("\n", None); 123 | } 124 | _ => {} 125 | } 126 | if self.newline { 127 | self.needs_space = NeedsSpace::Never; 128 | } 129 | } 130 | fn visit_token_stream(&mut self, token_stream: TokenStream) { 131 | for token_tree in token_stream { 132 | self.visit_token_tree(token_tree); 133 | } 134 | } 135 | fn visit_token_tree(&mut self, token_tree: TokenTree) { 136 | match token_tree { 137 | TokenTree::Group(group) => { 138 | self.visit_str( 139 | match group.delimiter() { 140 | Delimiter::Parenthesis => "(", 141 | Delimiter::Brace => "{", 142 | Delimiter::Bracket => "[", 143 | Delimiter::None => "", 144 | }, 145 | group.span_open(), 146 | ); 147 | self.visit_token_stream(group.stream()); 148 | self.visit_str( 149 | match group.delimiter() { 150 | Delimiter::Parenthesis => ")", 151 | Delimiter::Brace => "}", 152 | Delimiter::Bracket => "]", 153 | Delimiter::None => "", 154 | }, 155 | group.span_close(), 156 | ); 157 | } 158 | TokenTree::Ident(ident) => { 159 | if self.needs_space != NeedsSpace::Never { 160 | self.add_str(" ", None); 161 | } 162 | self.visit_str(&ident.to_string(), ident.span()); 163 | self.needs_space = NeedsSpace::IfNotPunct; 164 | } 165 | TokenTree::Punct(punct) => { 166 | if self.needs_space == NeedsSpace::Always { 167 | self.add_str(" ", None); 168 | } 169 | self.visit_str(&punct.to_string(), punct.span()); 170 | if punct.spacing() == Spacing::Alone { 171 | self.needs_space = NeedsSpace::Always; 172 | } 173 | } 174 | TokenTree::Literal(literal) => { 175 | if self.needs_space != NeedsSpace::Never { 176 | self.add_str(" ", None); 177 | } 178 | self.visit_str(&literal.to_string(), literal.span()); 179 | self.needs_space = NeedsSpace::IfNotPunct; 180 | } 181 | } 182 | } 183 | } 184 | 185 | fn generate_ranges(token_stream: TokenStream) -> Ranges { 186 | let mut res = TokenVisitor { 187 | ranges: Default::default(), 188 | indent: 0, 189 | newline: true, 190 | needs_space: NeedsSpace::Never, 191 | }; 192 | res.visit_token_stream(token_stream); 193 | res.ranges 194 | } 195 | 196 | struct LoadedSource { 197 | path: PathBuf, 198 | text: Vec, 199 | range_seps: Vec, 200 | } 201 | 202 | struct SourceParts { 203 | parts: Vec<(String, Vec)>, 204 | } 205 | 206 | impl SourceParts { 207 | fn add_unspanned(&mut self, s: &str) { 208 | self.parts.push((s.into(), Vec::new())); 209 | } 210 | fn add(&mut self, s: String, indexes: &HashSet) { 211 | self.parts.push((s, indexes.iter().copied().collect())); 212 | } 213 | } 214 | 215 | fn load_original_source(ranges: &Ranges) -> SourceParts { 216 | let mut loaded_sources: HashMap<_, _> = ranges 217 | .sources 218 | .iter() 219 | .filter_map(|(path, &source)| { 220 | let text = fs::read_to_string(path).ok()?; 221 | Some(( 222 | source, 223 | LoadedSource { 224 | path: path.clone(), 225 | text: text.lines().map(Into::into).collect(), 226 | range_seps: Vec::new(), 227 | }, 228 | )) 229 | }) 230 | .collect(); 231 | 232 | for (&range, &idx) in &ranges.ranges { 233 | if let Some(loaded_source) = loaded_sources.get_mut(&range.source) { 234 | loaded_source.range_seps.push(RangeSeparator { 235 | pos: range.start, 236 | sep: SeparatorType::Start, 237 | idx, 238 | }); 239 | loaded_source.range_seps.push(RangeSeparator { 240 | pos: range.end, 241 | sep: SeparatorType::End, 242 | idx, 243 | }); 244 | } 245 | } 246 | 247 | let mut source_parts = SourceParts { parts: Vec::new() }; 248 | for loaded_source in loaded_sources.values_mut() { 249 | loaded_source.range_seps.sort(); 250 | 251 | source_parts.add_unspanned("\n"); 252 | source_parts.add_unspanned("//======================================"); 253 | source_parts.add_unspanned("\n"); 254 | source_parts.add_unspanned("// "); 255 | source_parts.add_unspanned(&loaded_source.path.display().to_string()); 256 | source_parts.add_unspanned("\n"); 257 | source_parts.add_unspanned("//======================================"); 258 | source_parts.add_unspanned("\n"); 259 | 260 | let mut indexes = HashSet::new(); 261 | let mut pos = loaded_source.range_seps.first().unwrap().pos; 262 | pos.column = 0; 263 | 264 | for range_sep in &loaded_source.range_seps { 265 | while pos.line < range_sep.pos.line { 266 | if let Some(line_text) = loaded_source.text.get(pos.line.wrapping_sub(1)) { 267 | let s: String = line_text.chars().skip(pos.column).collect(); 268 | source_parts.add(s, &indexes); 269 | } 270 | source_parts.add_unspanned("\n"); 271 | pos.line += 1; 272 | pos.column = 0; 273 | } 274 | if pos.column < range_sep.pos.column { 275 | if let Some(line_text) = loaded_source.text.get(pos.line.wrapping_sub(1)) { 276 | let s: String = line_text 277 | .chars() 278 | .skip(pos.column) 279 | .take(range_sep.pos.column - pos.column) 280 | .collect(); 281 | source_parts.add(s, &indexes); 282 | } 283 | pos.column = range_sep.pos.column; 284 | } 285 | match range_sep.sep { 286 | SeparatorType::Start => { 287 | indexes.insert(range_sep.idx); 288 | } 289 | SeparatorType::End => { 290 | indexes.remove(&range_sep.idx); 291 | } 292 | } 293 | } 294 | if let Some(line_text) = loaded_source.text.get(pos.line.wrapping_sub(1)) { 295 | let s: String = line_text.chars().skip(pos.column).collect(); 296 | source_parts.add(s, &indexes); 297 | } 298 | source_parts.add_unspanned("\n"); 299 | } 300 | source_parts 301 | } 302 | 303 | fn generate_html_parts>(parts: Vec<(String, T)>) -> String { 304 | let mut res = String::new(); 305 | res += "
"; 306 | for (text, indexes) in parts { 307 | if text == "\n" { 308 | res += "
"; 309 | } else { 310 | res += ""; 315 | res += &encode_text(&text); 316 | res += "" 317 | } 318 | } 319 | res += "
"; 320 | res 321 | } 322 | 323 | pub fn generate_html(token_stream: TokenStream) -> String { 324 | let ranges = generate_ranges(token_stream); 325 | let source_parts = load_original_source(&ranges); 326 | let lhs = generate_html_parts(ranges.generated); 327 | let rhs = generate_html_parts(source_parts.parts); 328 | TEMPLATE_HTML 329 | .replace("{LEFT}", &lhs) 330 | .replace("{RIGHT}", &rhs) 331 | } 332 | 333 | pub fn save_html(token_stream: TokenStream, path: impl AsRef) -> Result<(), std::io::Error> { 334 | let html = generate_html(token_stream); 335 | fs::write(path, html) 336 | } 337 | 338 | #[cfg(test)] 339 | mod tests { 340 | use proc_macro2::TokenStream; 341 | 342 | #[test] 343 | fn it_works() { 344 | let x: TokenStream = "fn foo() -> i32 {\n42\n}\n".parse().unwrap(); 345 | dbg!(x); 346 | } 347 | } 348 | --------------------------------------------------------------------------------