constime 0.4.1

Zig's comptime for Rust with zero dependencies. Mostly something to play around with until more stuff is const fn.
Documentation 
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

#![doc = include_str!("../README.md")]

extern crate proc_macro;
use proc_macro::TokenStream;

use std::hash::{BuildHasher, RandomState};
use std::io::Write;

/// Properly passes an error message to the compiler without crashing macro engines.
macro_rules! build_error {
	($($arg:tt)*) => {
		format!("compile_error!(r#\"{}\"#);", format!($($arg)*))
			.parse::<TokenStream>()
			.unwrap()
	};
}

#[proc_macro]
#[doc = include_str!("../README.md")]
pub fn comptime(mut code: TokenStream) -> TokenStream {
	let mut out_dir = None;
	let mut externs = vec![];

	let mut args = std::env::args();
	while let Some(arg) = args.next() {
		// Push deps to rustc so you don't need to explicitly link with 'extern crate'
		if arg == "--extern" {
			let ext = args.next().unwrap();
			if !externs.contains(&ext) {
				externs.push(ext)
			}
		} else if arg == "--out-dir" {
			out_dir = args.next().map(std::path::PathBuf::from);
		}
	}

	let Some(out_dir) = out_dir else {
		return build_error!("Could not find output directory.");
	};

	#[rustfmt::skip]
	let wrapped_code = format!(r#"
		fn main() {{
			println!("{{:?}}", {{ {code} }});
		}}
	"#);

	let code_hash = RandomState::new().hash_one(&wrapped_code);
	let crate_name = std::env::var("CARGO_PKG_NAME").unwrap_or_else(|_| "unknown".to_owned());

	// Join by crate_name in the rare case of identical blocks across crates
	let constime_base = std::env::temp_dir().join("constime").join(crate_name);
	if !constime_base.exists() {
		if let Err(why) = std::fs::create_dir_all(&constime_base) {
			return build_error!("Failed to create temp directory: {why}");
		}
	}

	let evaluator_base = constime_base.join(code_hash.to_string());

	if !evaluator_base.exists() {
		// This hasn't been compiled yet.
		let mut rustc = std::process::Command::new("rustc");
		rustc
			.stderr(std::process::Stdio::piped())
			.stdin(std::process::Stdio::piped())
			.current_dir(constime_base)
			.arg("-L")
			.arg(out_dir)
			.arg("-o")
			.arg(&evaluator_base)
			.arg("-");

		for ext in &externs {
			rustc.arg("--extern").arg(ext);
		}

		let Ok(mut rustc) = rustc.spawn() else {
			return build_error!("Failed to spawn rustc");
		};

		// Avoid deadlock by containing stdin handling in its own scope
		if let Some(mut stdin) = rustc.stdin.take() {
			if stdin.write_all(wrapped_code.as_bytes()).is_err() {
				return build_error!("Failed to write to rustc stdin");
			};
		} else {
			return build_error!("Failed to open stdin for rustc");
		}

		let Ok(output) = rustc.wait_with_output() else {
			return build_error!("Failed to wait for rustc");
		};

		if !output.status.success() {
			// Extend the code so that autocompletion works.
			code.extend(build_error!("{}", String::from_utf8_lossy(&output.stderr)));
			return code;
		}
	}

	let out = std::process::Command::new(&evaluator_base)
		.stdout(std::process::Stdio::piped())
		.output();

	match out {
		Err(why) => return build_error!("Failed to execute code: {why}"),
		Ok(out) => {
			let out = String::from_utf8_lossy(&out.stdout);

			let Ok(out) = out.parse() else {
				return build_error!("Failed to parse output into a TokenStream");
			};

			return out;
		}
	}
}