beet_build 0.0.8

Codegen and compilation tooling for beet
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

use crate::prelude::*;
use beet_core::prelude::*;
use proc_macro2::TokenStream;
use proc_macro2::TokenTree;
use quote::ToTokens;
use std::hash::Hash;
use std::hash::Hasher;


/// Hash all the parts of a rust file that are not part of an rsx! macro.
pub(super) struct HashNonSnippetRust<'a, H> {
	pub macros: &'a TemplateMacros,
	pub hasher: &'a mut H,
}
impl<H: Hasher> HashNonSnippetRust<'_, H> {
	pub fn hash(&mut self, file: &SourceFile) -> Result<()> {
		match file.extension() {
			Some(ex) if ex == "rs" => {
				let file_content = fs_ext::read_to_string(file)?;
				let parsed_file =
					syn::parse_file(&file_content).map_err(|err| {
						bevyhow!(
							"Failed to parse file: {}\n{}",
							file.display(),
							err
						)
					})?;
				self.walk_tokens(parsed_file.to_token_stream())?;
				Ok(())
			}
			_ => {
				// currently all non-rust files (mdx,rsx) are themselves a parsed expression
				// so the hash is built from that expression
				Ok(())
			}
		}
	}
	/// # Errors
	/// If the file cannot be read or parsed as tokens
	fn walk_tokens(&mut self, tokens: TokenStream) -> Result<()> {
		let mut iter = tokens.into_iter().peekable();
		while let Some(tree) = iter.next() {
			// println!("visiting tree: {}", tree.to_string());
			match &tree {
				TokenTree::Ident(ident)
					if ident.to_string() == self.macros.rstml =>
				{
					// println!("visiting ident: {}", ident.to_string());
					if let Some(TokenTree::Punct(punct)) = iter.peek() {
						if punct.as_char() == '!' {
							iter.next(); // consume !
							if let Some(TokenTree::Group(_group)) = iter.next()
							{
								// inside the template, this will be hashed by
								// update_file_expr_hash
								continue;
							}
						}
					} else {
						ident.to_string().hash(self.hasher);
						// i dont think we need to replace spaces here, thats for
						// interop between tokenizers but we're always using syn::parse_file
						// ident.to_string().replace(" ", "").hash(self.hasher);
					}
				}
				TokenTree::Group(group) => {
					// recurse into groups
					self.walk_tokens(group.stream())?;
				}
				tree => {
					// Hash everything else
					tree.to_string().hash(self.hasher);
					// i dont think we need to replace spaces here, thats for
					// interop between tokenizers but we're always using syn::parse_file
					// tree.to_string().replace(" ", "").hash(self.hasher);
				}
			}
		}
		Ok(())
	}
}


#[cfg(test)]
mod test {
	use super::*;
	use proc_macro2::TokenStream;
	use quote::quote;
	use std::hash::Hasher;

	fn hash(tokens: TokenStream) -> u64 {
		let mut hasher = FixedHasher::default().build_hasher();
		HashNonSnippetRust {
			hasher: &mut hasher,
			macros: &TemplateMacros::default(),
		}
		.walk_tokens(tokens)
		.unwrap();
		hasher.finish()
	}


	#[test]
	#[rustfmt::skip]
	fn works() {
		// ignore macro inners
		hash(quote! {rsx!{1}}).xpect_eq(hash(quote! {rsx!{2}}));
		// ignore multiple macros
		hash(quote! {rsx!{1} rsx!{1}}).xpect_eq(hash(quote! {rsx!{2} rsx!{2}}));
		// hash non-template expressions
		hash(quote! {foo}).xpect_not_eq(hash(quote! {bar}));
		// hash other macros
		hash(quote! {println!(foo)}).xpect_not_eq(hash(quote! {println!(bar)}));
	}
}