amt! macro proof of concept

core/Cargo.toml

@@ -20,6 +20,7 @@ uint = "0.9"
 serde_json = "1"
 
 [features]
+default = []
 serde = ["dep:serde"]
 std = []
 parsing = ["serde", "std", "dep:quoth"]

macros/Cargo.toml

@@ -15,4 +15,5 @@ proc-macro = true
 quote = "1"
 proc-macro2 = "1"
 syn = "2"
-currencies-core = { version = "0.3.2", path = "../core" }
+currencies-core = { version = "0.3.2", path = "../core", features = ["parsing"] }
+derive-syn-parse = "0.2"

macros/src/lib.rs

@@ -1 +1,67 @@
+use currencies_core::{
+    currency::USD,
+    safety::{Checked, Unchecked},
+    Currency, ParsedAmount,
+};
+use derive_syn_parse::Parse;
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::{parse2, Error, Ident, LitStr, Result, Token};
 
+#[derive(Parse)]
+struct AmountInput {
+    currency: Ident,
+    _comma: Token![,],
+    amount: LitStr,
+}
+
+#[proc_macro]
+pub fn amt(input: TokenStream) -> TokenStream {
+    match amt_internal::<false>(input) {
+        Ok(tokens) => tokens.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
+#[proc_macro]
+pub fn amt_checked(input: TokenStream) -> TokenStream {
+    match amt_internal::<true>(input) {
+        Ok(tokens) => tokens.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
+fn filter_error(err: impl ToString) -> String {
+    format!("invalid amount: {}", err.to_string().trim_start_matches("error: "))
+}
+
+fn parse_amount<C: Currency, const SAFE: bool>(amount: &LitStr, currency_ident: &Ident) -> Result<TokenStream2> {
+    let krate = quote!(::currencies);
+    if SAFE {
+        let amount: ParsedAmount<C, Checked> = amount.value().parse().map_err(|err| Error::new(amount.span(), filter_error(err)))?;
+        let amount = amount.amount;
+        let amount: TokenStream2 = format!("{:?}", amount.raw_backing()).parse().unwrap();
+        Ok(quote! {
+            #krate::Amount::<#currency_ident, #krate::safety::Checked>::from_raw(#amount)
+        })
+    } else {
+        let amount: ParsedAmount<C, Unchecked> = amount.value().parse().map_err(|err| Error::new(amount.span(), filter_error(err)))?;
+        let amount = amount.amount;
+        let amount: TokenStream2 = format!("{:?}", amount.raw_backing()).parse().unwrap();
+        Ok(quote! {
+            #krate::Amount::<#currency_ident, #krate::safety::Unchecked>::from_raw(#amount)
+        })
+    }
+}
+
+fn amt_internal<const SAFE: bool>(tokens: impl Into<TokenStream2>) -> Result<TokenStream2> {
+    let input = parse2::<AmountInput>(tokens.into())?;
+    let currency = input.currency;
+    let amount = input.amount;
+    let output = match currency.to_string().to_uppercase().as_str() {
+        "USD" => parse_amount::<USD, SAFE>(&amount, &currency)?,
+        _ => todo!(),
+    };
+    Ok(output)
+}

src/lib.rs

@@ -17,3 +17,4 @@
 #![warn(missing_docs)]
 
 pub use currencies_core::*;
+pub use currencies_macros::*;

tests/macro_tests.rs

@@ -0,0 +1,17 @@
+use currencies::amt;
+use currencies::amt_checked;
+use currencies::currency::*;
+use currencies::safety::Checked;
+use currencies::Amount;
+
+#[test]
+fn test_amt_usd_unchecked() {
+    let amount = amt!(USD, "$3.24");
+    assert_eq!(format!("{}", amount), "$3.24");
+}
+
+#[test]
+fn test_amt_usd_checked() {
+    let amount: Amount<USD, Checked> = amt_checked!(USD, "$3.24");
+    assert_eq!(format!("{}", amount), "$3.24");
+}