Fixed bug by replacing 'raw' with 'val' and added support for anonymous structs

Author: StefanMathis

Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "compare_variables"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 description = "A Rust procedural macro for comparing the ordering of variables and creating useful error messages"
 readme = "README.md"
 license  = "MIT OR Apache-2.0"
 repository = "https://github.com/StefanMathis/cart_lin.git"
 
 [dependencies]
-compare_variables_macro = { version = "0.1", path = "compare_variables_macro", optional = true}
+compare_variables_macro = { version = "0.2.0", path = "compare_variables_macro", optional = true}
 
 [features]
 default = ["proc_macro"]

README.md

@@ -3,19 +3,21 @@ compare_variables
 
 A library for comparing the ordering of variables and producing useful error messages.
 
-[`ComparisonError`]: https://docs.rs/compare_variables/0.1.0/compare_variables/struct.ComparisonError.html
+[`ComparisonError`]: https://docs.rs/compare_variables/0.2.0/compare_variables/struct.ComparisonError.html
 [`PartialOrd`]: https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html
-[`compare_variables`]: https://docs.rs/compare_variables/0.1.0/compare_variables/macro.compare_variables.html
+[`compare_variables`]: https://docs.rs/compare_variables/0.2.0/compare_variables/macro.compare_variables.html
 
 This library is based on the struct [`ComparisonError`], which can be used to compare the partial ordering
 of two to three variables of any type `T` which implements the [`PartialOrd`] trait. If the comparison evaluates
 to false, [`ComparisonError`] can be formatted into a nice error message. To simplify the usage, the procedural
 macro [`compare_variables`] is provided via the feature flag **proc_macro** (enabled by default).
 
-The full API documentation is available at [https://docs.rs/compare_variables/0.1.0/compare_variables/](https://docs.rs/compare_variables/0.1.0/compare_variables/).
+The full API documentation is available at [https://docs.rs/compare_variables/0.2.0/compare_variables/](https://docs.rs/compare_variables/0.2.0/compare_variables/).
 
 # Examples
 
+The type annotation of the error can be omitted and is only written out in these examples for clarity.
+
 ```rust
 use compare_variables::{compare_variables, ComparisonError};
 
@@ -27,21 +29,25 @@ assert_eq!(err.to_string(), "`x (value: 1.0) > 1.5` is false");
 
 assert!(compare_variables!(1.0 == x < 5.0).is_ok());
 
-// Named struct fields can also be used:
+// Named and unnamed struct fields can also be used:
 struct NamedField {
    x: usize
 }
-
 let n = NamedField {x: 1};
 assert!(compare_variables!(n.x > 0).is_ok());
 let err: ComparisonError<usize> = compare_variables!(n.x > 1).unwrap_err();
 assert_eq!(err.to_string(), "`n.x (value: 1) > 1` is false");
 
-// It is also possible to customize the error message via `as` (providing an alias) and `raw` (omit the variable name):
+struct AnonymousField(i32);
+let a = AnonymousField(-5);
+let err: ComparisonError<i32> = compare_variables!(a.0 > 1).unwrap_err();
+assert_eq!(err.to_string(), "`a.0 (value: -5) > 1` is false");
+
+// It is also possible to customize the error message via `as` (providing an alias) and `val` (omit the variable name):
 let x: u16 = 1;
 let y: u16 = 2;
 let z: u16 = 3;
-let err: ComparisonError<u16> = compare_variables!(x as arg > raw y > z).unwrap_err();
+let err: ComparisonError<u16> = compare_variables!(x as arg > val y > z).unwrap_err();
 assert_eq!(err.to_string(), "`arg (value: 1) > 2 > z (value: 3)` is false");
 ```
 

compare_variables_macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "compare_variables_macro"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 description = "Procedural macro for crate `compare_variables`"
 readme = "README.md"

compare_variables_macro/src/lib.rs

@@ -55,50 +55,54 @@ assert_eq!(checked_sub(2, 2).unwrap(), 0);
 assert!(checked_sub(2, 3).is_err());
 ```
 
-It is also possible to use named struct fields as inputs:
+It is also possible to use named and anonymous struct fields as inputs:
 
 ```
 use compare_variables::compare_variables;
 
 struct NamedField {
    x: f64
 }
-
 let n = NamedField {x: 1.0};
 assert!(compare_variables!(n.x > -1.0).is_ok());
 assert!(compare_variables!(n.x > 1.0).is_err());
+
+struct AnonymousField(i32);
+let a = AnonymousField(-5);
+assert!(compare_variables!(a.0 > -6).is_ok());
+assert!(compare_variables!(a.0 > 1).is_err());
 ```
 
 # Error message
 
 The error message is created via the struct [`ComparisonError`](https://docs.rs/compare_variables/0.1.0/compare_variables/struct.ComparisonError.html).
-Please refer to its documentation for more details. The keywords `raw` and `as` allow to customize the treatment of variable names in the error message:
+Please refer to its documentation for more details. The keywords `val` and `as` allow to customize the treatment of variable names in the error message:
 
 ```
 use compare_variables::compare_variables;
 
 // Error message with literals only
-let err = compare_variables!(5i32 <= -1i32);
-assert_eq!(err.unwrap_err().to_string(), "`5 <= -1` is false");
+let err = compare_variables!(5i32 <= -1i32).unwrap_err();
+assert_eq!(err.to_string(), "`5 <= -1` is false");
 
 let x = 1;
 let y = 2;
 
 // Default error message
-let err = compare_variables!(x > y);
-assert_eq!(err.unwrap_err().to_string(), "`x (value: 1) > y (value: 2)` is false");
+let err = compare_variables!(x > y).unwrap_err();
+assert_eq!(err.to_string(), "`x (value: 1) > y (value: 2)` is false");
 
 // Rename x in the error message
-let err = compare_variables!(x as variable > y);
-assert_eq!(err.unwrap_err().to_string(), "`variable (value: 1) > y (value: 2)` is false");
+let err = compare_variables!(x as variable > y).unwrap_err();
+assert_eq!(err.to_string(), "`variable (value: 1) > y (value: 2)` is false");
 
 // Only display the underlying value, not the variable name:
-let err = compare_variables!(raw x > y);
-assert_eq!(err.unwrap_err().to_string(), "`1 > y (value: 2)` is false");
+let err = compare_variables!(val x > y).unwrap_err();
+assert_eq!(err.to_string(), "`1 > y (value: 2)` is false");
 
-// `as` is ignored if used together with `raw`:
-let err = compare_variables!(raw x as variable > y);
-assert_eq!(err.unwrap_err().to_string(), "`1 > y (value: 2)` is false");
+// `as` is ignored if used together with `val`:
+let err = compare_variables!(val x as variable > y).unwrap_err();
+assert_eq!(err.to_string(), "`1 > y (value: 2)` is false");
 ```
 
 # Examples
@@ -111,7 +115,7 @@ assert!(compare_variables!(1.5 < 2.0 == 3.0).is_err());
 assert!(compare_variables!(1.7f32 == 1.7f32).is_ok());
 let f = 2.0;
 assert!(compare_variables!(f < 5.2).is_ok());
-assert!(compare_variables!(f as f_var == raw f).is_ok());
+assert!(compare_variables!(f as f_var == val f).is_ok());
 
 // Signed and unsigned integers
 assert!(compare_variables!(1i32 >= 2i32).is_err());
@@ -216,8 +220,8 @@ impl ComparisonError {
 
 enum VariableOrLiteral {
     Other {
-        arg_names: Vec<syn::Ident>,
-        arg_names_display: Vec<syn::Ident>,
+        arg_names: Vec<String>,
+        arg_names_display: Vec<String>,
     },
     LitFloat(syn::LitFloat),
     LitInt(syn::LitInt),
@@ -231,11 +235,7 @@ impl VariableOrLiteral {
                 arg_names_display,
             } => {
                 // Build a token stream out of arg_name and arg_name_display, using . as a delimiter
-                let arg_value = arg_names
-                    .into_iter()
-                    .map(|ident| ident.to_string())
-                    .collect::<Vec<String>>()
-                    .join(".");
+                let arg_value = arg_names.join(".");
                 let arg_value_ts: TokenStream2 = match str::parse::<TokenStream2>(&arg_value) {
                     Ok(ts) => ts,
                     Err(_) => abort!(
@@ -248,11 +248,7 @@ impl VariableOrLiteral {
                         compare_variables::ComparisonValue::new(#arg_value_ts, None)
                     }
                 } else {
-                    let arg_name_display = arg_names_display
-                        .into_iter()
-                        .map(|ident| ident.to_string())
-                        .collect::<Vec<String>>()
-                        .join(".");
+                    let arg_name_display = arg_names_display.join(".");
                     quote! {
                         compare_variables::ComparisonValue::new(#arg_value_ts, Some(#arg_name_display))
                     }
@@ -284,6 +280,30 @@ struct ComparisonErrorInfo {
 impl Parse for ComparisonErrorInfo {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         fn parse_arg(input: &syn::parse::ParseStream) -> syn::Result<VariableOrLiteral> {
+            fn parse_composite_varname(
+                input: &syn::parse::ParseStream,
+                vec: &mut Vec<String>,
+            ) -> syn::Result<()> {
+                loop {
+                    if input.peek(syn::LitInt) {
+                        let lit = input.parse::<syn::LitInt>()?;
+                        vec.push(lit.to_string());
+                    } else {
+                        let ident: syn::Ident = input.call(Ident::parse_any)?;
+                        vec.push(ident.to_string()); // parse_any also handles stuff like self
+                    }
+
+                    if input.peek(Token![.]) {
+                        // Throw the token away
+                        let _ = input.parse::<Token![.]>()?;
+                    } else {
+                        // Field access is done ==> Finish the loop
+                        break;
+                    }
+                }
+                return Ok(());
+            } // parse_composite_varname
+
             if input.peek(syn::LitFloat) {
                 // Parse the float literal
                 let val = input.parse::<syn::LitFloat>()?;
@@ -293,59 +313,64 @@ impl Parse for ComparisonErrorInfo {
                 let val = input.parse::<syn::LitInt>()?;
                 return Ok(VariableOrLiteral::LitInt(val));
             } else {
-                // If the first token is "raw", do not display the variable name
-                let no_arg_name_display = input.peek(Token![raw]);
-                if no_arg_name_display {
-                    // Remove the "raw" token
-                    let _ = input.parse::<Token![raw]>()?;
-                }
+                let mut display_arg_names = true;
 
-                // Resolve field accesses like self.field or variable.field.field
-                let mut arg_names: Vec<Ident> = Vec::new();
-                loop {
-                    let arg_name: Ident = input.call(Ident::parse_any)?; // parse_any also handles stuff like self
-                    arg_names.push(arg_name);
+                // Input is possibly a variable name.
+                let mut arg_names: Vec<String> = Vec::new();
 
-                    if input.peek(Token![.]) {
-                        // Throw the token away
-                        let _ = input.parse::<Token![.]>()?;
+                // First check if the first identifier is "val":
+                let first_ident: Ident = input.call(Ident::parse_any)?; // parse_any also handles stuff like self
+
+                // Next identifier is not a "." -> Check if first_ident is "val". If not, the macro is used wrong
+                if input.peek(Token![.]) {
+                    // Throw the token away
+                    let _ = input.parse::<Token![.]>()?;
+
+                    // Try continuing to parse and keep the first identifier
+                    arg_names.push(first_ident.to_string());
+                    parse_composite_varname(input, &mut arg_names)?;
+                } else {
+                    if input.peek(syn::Ident) {
+                        if first_ident == "val" {
+                            display_arg_names = false;
+
+                            // Try continuing to parse
+                            parse_composite_varname(input, &mut arg_names)?;
+                        } else {
+                            abort!(
+                                Span::call_site(),
+                                format!("found unexpected tokens behind {first_ident}")
+                            )
+                        }
                     } else {
-                        // Field access is done ==> Finish the loop
-                        break;
+                        arg_names.push(first_ident.to_string());
                     }
                 }
 
-                let arg_names_display = if input.peek(Token![as]) {
+                // Resolve the alias, if the variable name should be displayed
+                let arg_names_display: Vec<String> = if input.peek(Token![as]) {
                     input.parse::<Token![as]>()?;
-                    let mut arg_names_display: Vec<Ident> = Vec::new();
-                    loop {
-                        let arg_name: Ident = input.call(Ident::parse_any)?; // parse_any also handles stuff like self
-                        if !no_arg_name_display {
-                            arg_names_display.push(arg_name);
-                        }
-
-                        if input.peek(Token![.]) {
-                            // Throw the token away
-                            let _ = input.parse::<Token![.]>()?;
-                        } else {
-                            // Field access is done ==> Finish the loop
-                            break;
-                        }
+                    let mut arg_names_display: Vec<String> = Vec::new();
+                    parse_composite_varname(input, &mut arg_names_display)?;
+                    if display_arg_names {
+                        arg_names_display
+                    } else {
+                        Vec::new()
                     }
-                    arg_names_display
                 } else {
-                    if no_arg_name_display {
-                        Vec::new()
-                    } else {
+                    if display_arg_names {
                         arg_names.clone()
+                    } else {
+                        Vec::new()
                     }
                 };
+
                 return Ok(VariableOrLiteral::Other {
                     arg_names,
                     arg_names_display,
                 });
             }
-        }
+        } // parse_arg
 
         fn parse_comparison_operator(
             input: &syn::parse::ParseStream,
@@ -372,7 +397,7 @@ impl Parse for ComparisonErrorInfo {
                     "no comparison operator could be identified. Valid operators are \"<\", \"<=\", \"==\", \">=\" or \">\".",
                 ))
             }
-        }
+        } // parse_comparison_operator
 
         // Read the arguments
         let first_arg: VariableOrLiteral = parse_arg(&input)?;

tests/struct_fields.rs

@@ -1,11 +1,13 @@
 use compare_variables::compare_variables;
 
-struct Struct {
+struct NamedFields {
     field1: f64,
     field2: f64,
 }
 
-impl Struct {
+struct AnonymousField(f64);
+
+impl NamedFields {
     fn field1_larger_than_0(&self) -> bool {
         return compare_variables!(self.field1 > 0.0).is_ok();
     }
@@ -30,8 +32,8 @@ impl Struct {
 }
 
 #[test]
-fn test_check_struct_fields() {
-    let instance = Struct {
+fn test_named_struct_fields() {
+    let instance = NamedFields {
         field1: 1.0,
         field2: 2.0,
     };
@@ -62,3 +64,11 @@ fn test_check_struct_fields() {
         .to_string();
     assert!(error_msg.contains("`field2 (value: 2.0) < value (value: 1.0)` is false"));
 }
+
+#[test]
+fn test_anonymous_struct_fields() {
+    let anon = AnonymousField(1.0);
+    assert!(compare_variables!(0.0 < anon.0 <= 1.0).is_ok());
+    let err = compare_variables!(0.0 > anon.0).unwrap_err();
+    assert_eq!(err.to_string(), "`0.0 > anon.0 (value: 1.0)` is false");
+}