Support printing the two sides of a binary operator and traversing inside a unary operator in verify_pred.

PiperOrigin-RevId: 691782094

Author: marcianx

googletest/tests/assertions_test.rs

@@ -333,4 +333,95 @@ mod verify_pred {
             })))
         )
     }
+
+    #[test]
+    fn binary_operator() -> Result<()> {
+        // Add chaining and function calls.
+        fn f(x: u32) -> u32 {
+            x + 1
+        }
+        #[derive(Debug)]
+        struct Apple;
+        impl Apple {
+            fn b(&self, y: u32) -> u32 {
+                y + 10
+            }
+        }
+        let a = Apple;
+        let x = 1;
+        let y = 2;
+        let res = verify_pred!(f(x) - 1 == a.b(y + 1) + f(y));
+        verify_that!(
+            res,
+            err(displays_as(contains_substring(indoc! {"
+                f(x) - 1 == a.b(y + 1) + f(y) was false with
+                  x = 1,
+                  f(x) = 2,
+                  f(x) - 1 = 1,
+                  a = Apple,
+                  y + 1 = 3,
+                  a.b(y + 1) = 13,
+                  y = 2,
+                  f(y) = 3,
+                  a.b(y + 1) + f(y) = 16,
+                  at"
+            })))
+        )
+    }
+
+    #[rustversion::before(1.77)]
+    #[test]
+    fn unary_operator() -> Result<()> {
+        #[derive(Debug)]
+        struct Apple;
+        impl Apple {
+            fn b(&self, _b: u32, _c: i32) -> i32 {
+                0
+            }
+        }
+
+        let a = Apple;
+        let b = 1;
+        let res = verify_pred!(!a.b(b, -1) == !-2);
+        verify_that!(
+            res,
+            err(displays_as(contains_substring(indoc! {"
+                ! a.b(b, - 1) ==! - 2 was false with
+                  a = Apple,
+                  b = 1,
+                  a.b(b, - 1) = 0,
+                  ! a.b(b, - 1) = -1,
+                  ! - 2 = 1,
+                  at"
+            })))
+        )
+    }
+
+    #[rustversion::since(1.77)]
+    #[test]
+    fn unary_operator() -> Result<()> {
+        #[derive(Debug)]
+        struct Apple;
+        impl Apple {
+            fn b(&self, _b: u32, _c: i32) -> i32 {
+                0
+            }
+        }
+
+        let a = Apple;
+        let b = 1;
+        let res = verify_pred!(!a.b(b, -1) == !-2);
+        verify_that!(
+            res,
+            err(displays_as(contains_substring(indoc! {"
+                ! a.b(b, - 1) == ! - 2 was false with
+                  a = Apple,
+                  b = 1,
+                  a.b(b, - 1) = 0,
+                  ! a.b(b, - 1) = -1,
+                  ! - 2 = 1,
+                  at"
+            })))
+        )
+    }
 }

googletest_macro/src/verify_pred.rs

@@ -45,6 +45,10 @@ impl AccumulatePartsState {
     /// of the input expression with parts of it potentially replaced by the
     /// intermediate variables.
     fn accumulate_parts(&mut self, expr: Expr) -> Expr {
+        // Literals don't need to be printed or stored in intermediate variables.
+        if is_literal(&expr) {
+            return expr;
+        }
         let expr_string = expr_to_string(&expr);
         let new_expr = match expr {
             Expr::Group(mut group) => {
@@ -53,8 +57,6 @@ impl AccumulatePartsState {
                 *group.expr = self.accumulate_parts(*group.expr);
                 return Expr::Group(group);
             }
-            // Literals don't need to be printed or stored in intermediate variables.
-            Expr::Lit(_) => return expr,
             Expr::Field(mut field) => {
                 // Don't assign field access to an intermediate variable to avoid moving out of
                 // non-`Copy` fields.
@@ -74,6 +76,15 @@ impl AccumulatePartsState {
                 // Cache method value into an intermediate variable.
                 self.define_variable(&Expr::MethodCall(method_call))
             }
+            Expr::Binary(mut binary) => {
+                *binary.left = self.accumulate_parts(*binary.left);
+                *binary.right = self.accumulate_parts(*binary.right);
+                Expr::Binary(binary)
+            }
+            Expr::Unary(mut unary) => {
+                *unary.expr = self.accumulate_parts(*unary.expr);
+                Expr::Unary(unary)
+            }
             // A path expression doesn't need to be stored in an intermediate variable.
             // This avoids moving out of an existing variable.
             Expr::Path(_) => expr,
@@ -101,7 +112,7 @@ impl AccumulatePartsState {
         args.into_pairs()
             .map(|mut pair| {
                 // Don't need to assign literals to intermediate variables.
-                if let Expr::Lit(_) = pair.value() {
+                if is_literal(pair.value()) {
                     return pair;
                 }
 
@@ -137,6 +148,15 @@ impl AccumulatePartsState {
     }
 }
 
+// Whether it's a literal or unary operator applied to a literal (1, -1).
+fn is_literal(expr: &Expr) -> bool {
+    match expr {
+        Expr::Lit(_) => true,
+        Expr::Unary(unary) => matches!(&*unary.expr, Expr::Lit(_)),
+        _ => false,
+    }
+}
+
 pub fn verify_pred_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let parsed = parse_macro_input!(input as Expr);
     let error_message = quote!(#parsed).to_string() + " was false with";