Refactor + Implicit crates

Refactors the codebase to be significantly cleaner, and implements passing --extern which allows you to use crates without . This also avoids using a temporary file to compile to rustc and instead pipes the source to rustc. One less file to worry about clogging up your target dir.

Author: codebycruz

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "constime"
-authors = ["David Cruz <[email protected]>"]
-repository = "https://github.com/DvvCz/Constime"
 description = "Zig's comptime for Rust with zero dependencies. Mostly something to play around with until more stuff is const fn."
-version = "0.2.2"
+version = "0.3.0"
+
+authors = ["David Cruz <[email protected]>"]
+repository = "https://github.com/DvvCz/Constime"
 edition = "2021"
 license = "MIT"
 
@@ -12,4 +13,4 @@ proc-macro = true
 doctest = false
 
 [dev-dependencies]
-ureq = "2.6.1"
+ureq = "2.12.1"

README.md

@@ -22,9 +22,9 @@
 cargo add constime
 ```
 
-Dependencies in `comptime!` can be stored in either `[dependencies]` or `[build-dependencies]`, and must be explicitly imported using `extern crate`.
+Dependencies in `comptime!` can be stored in either `[dependencies]` or `[build-dependencies]`.
 
-You will also need a build.rs file in order to force `[build-dependencies]` to compile.
+If you use build dependencies, you will need to explicitly link with `extern crate` and a `build.rs` file to force them to compile.
 
 ## Example
 
@@ -35,7 +35,12 @@ fn main() {
 	// Let's use a pure-build time dependency
 	println!("Here's a fact about the number 5: {}", comptime! {
 		extern crate ureq;
-		ureq::get("http://numbersapi.com/5/math").call().unwrap().into_string().unwrap()
+
+		ureq::get("http://numbersapi.com/5/math")
+			.call()
+			.unwrap()
+			.into_string()
+			.unwrap()
 	});
 
 	// Standard library works fine too.

src/lib.rs

@@ -2,78 +2,114 @@
 
 extern crate proc_macro;
 use proc_macro::TokenStream;
-use std::hash::{Hash, Hasher};
+
+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(code: TokenStream) -> TokenStream {
-	let (mut externs, mut out_dir, mut args) = (vec![], None, std::env::args());
+	let mut out_dir = None;
+	let mut externs = vec![];
+
+	let mut args = std::env::args();
 	while let Some(arg) = args.next() {
-		if arg == "--out-dir" {
-			out_dir = args.next();
-		} else if arg == "--extern" {
-			externs.push("--extern".to_owned());
+		// Push deps to rustc so you don't need to explicitly link with 'extern crate'
+		if arg == "--extern" {
 			externs.push(args.next().unwrap());
+		} else if arg == "--out-dir" {
+			out_dir = args.next().map(std::path::PathBuf::from);
+		}
+	}
+
+	if out_dir.is_none() {
+		let out = std::env::current_dir().unwrap().join("target").join("debug").join("deps");
+		if out.exists() {
+			out_dir = Some(out);
 		}
 	}
 
 	let Some(out_dir) = out_dir else {
-		return "compile_error!(\"Could not find output directory.\")".parse().unwrap()
+		return build_error!("Could not find output directory.");
 	};
 
-	let code = format!("fn main(){{ println!(\"{{:?}}\", {{ {code} }}) }}");
-
-	let mut hash = std::collections::hash_map::DefaultHasher::new();
-	code.hash(&mut hash);
-	let hash = hash.finish();
-
-	let output_file = format!("{out_dir}{}constime-{hash}.exe", std::path::MAIN_SEPARATOR);
-	let out_path = std::path::Path::new(&output_file);
-	if out_path.exists() {
-		let ext = out_path.with_extension("err");
-		if ext.exists() {
-			return format!(
-				"compile_error!(r#\"{}\"#)",
-				std::fs::read_to_string(ext).expect("Error when compiling")
-			)
-			.parse()
-			.unwrap();
-		}
-	} else {
-		let input_file = format!("{out_dir}{}constime-{hash}.rs", std::path::MAIN_SEPARATOR);
-		std::fs::write(&input_file, code).expect("Failed to write temporary file to output");
+	let wrapped_code = format!(r#"
+		fn main() {{
+			println!("{{:?}}", {{ {code} }});
+		}}
+	"#);
+
+	let hash = RandomState::new().hash_one(&wrapped_code);
+
+	let constime_base = out_dir.join("constime");
+	if !constime_base.exists() {
+		std::fs::create_dir(&constime_base).unwrap();
+	}
 
-		let rustc = std::process::Command::new("rustc")
+	let evaluator_base = constime_base
+		.join(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())
-			.args([&input_file, "-o", &output_file])
-			.args(["-L", &out_dir])
-			.output();
-
-		match rustc {
-			Err(why) => return format!("compile_error!(r#\"{}\"#)", why).parse().unwrap(),
-			Ok(output) if !output.status.success() => {
-				return format!(
-					"compile_error!(r#\"{}\"#)",
-					std::str::from_utf8(&output.stderr).unwrap()
-				)
-				.parse()
-				.unwrap()
-			}
-			_ => (),
+			.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() {
+			return build_error!("{}", String::from_utf8_lossy(&output.stderr));
 		}
 	}
 
-	let out = std::process::Command::new(&output_file)
+	let out = std::process::Command::new(&evaluator_base)
 		.stdout(std::process::Stdio::piped())
 		.output();
 
 	match out {
-		Err(why) => {
-			std::fs::write(out_path.with_extension("err"), why.to_string()).unwrap();
-			format!("compile_error!(r#\"Failed to execute code: {why}\"#)")
-				.parse()
-				.unwrap()
+		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;
 		}
-		Ok(out) => std::str::from_utf8(&out.stdout).unwrap().parse().unwrap(),
 	}
-}
+}

tests/main.rs

@@ -12,9 +12,8 @@ fn test_base() {
 }
 
 #[test]
-fn test_ureq() {
+fn test_dev_ureq() {
 	let retrieved = comptime! {
-		extern crate ureq;
 		ureq::get("https://gist.githubusercontent.com/DvvCz/9972f1627f8418badb1736d6899d5f44/raw/b31a3627458a698dc029750dfc2572a6f8a131cf/test.txt").call().unwrap().into_string().unwrap()
 	};