modify {:#?} to print the traditional debug

It is sometimes useful to see EXACTLY what is going on

Author: nikomatsakis

crates/formality-macros/src/debug.rs

@@ -1,4 +1,5 @@
 extern crate proc_macro;
+
 use convert_case::{Case, Casing};
 use proc_macro2::{Ident, Literal, TokenStream};
 use quote::{quote, quote_spanned};
@@ -20,6 +21,7 @@ pub(crate) fn derive_debug_with_spec(
             .into_compile_error();
     }
 
+    let default_debug = default_debug_variant(&s);
     let debug_arms = s.each_variant(|v| debug_variant(v, external_spec));
 
     s.gen_impl(quote! {
@@ -29,15 +31,50 @@ pub(crate) fn derive_debug_with_spec(
             fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
             {
                 #[allow(unused_assignments)]
-                match self {
-                    #debug_arms
+                if fmt.alternate() {
+                    #default_debug
+                } else {
+                    match self {
+                        #debug_arms
+                    }
+                    Ok(())
                 }
-                Ok(())
             }
         }
     })
 }
 
+fn default_debug_variant(s: &synstructure::Structure) -> TokenStream {
+    let arms = s.each_variant(|v| {
+        let fields: TokenStream = v.bindings().iter().map(|bi| {
+            if let Some(name) = &bi.ast().ident {
+                let name = as_literal(name);
+                quote_spanned!(name.span() => .field(#name, #bi))
+            } else {
+                quote_spanned!(bi.span() => .field(#bi))
+            }
+        }).collect();
+        let variant_name = as_literal(v.ast().ident);
+        match v.ast().fields {
+            syn::Fields::Named(_) => {
+                quote_spanned!(variant_name.span() => fmt.debug_struct(#variant_name) #fields .finish())
+            }
+            syn::Fields::Unnamed(_) => {
+                quote_spanned!(variant_name.span() => fmt.debug_tuple(#variant_name) #fields .finish())
+            }
+            syn::Fields::Unit => {
+                quote_spanned!(variant_name.span() => fmt.debug_tuple(#variant_name) .finish())
+            }
+        }
+    });
+
+    quote_spanned! { s.ast().span() =>
+        match self {
+            #arms
+        }
+    }
+}
+
 fn debug_variant(
     variant: &synstructure::VariantInfo,
     external_spec: Option<&FormalitySpec>,

crates/formality-prove/src/prove/minimize/test.rs

@@ -17,42 +17,13 @@ fn minimize_a() {
     let (env, subst) = env.existential_substitution(&term);
     let term = term.instantiate_with(&subst).unwrap();
 
-    expect![[r#"
-        (
-            Env {
-                variables: [
-                    ?ty_1,
-                    ?ty_2,
-                    ?ty_3,
-                ],
-                coherence_mode: false,
-            },
-            [
-                ?ty_1,
-                ?ty_3,
-            ],
-        )
-    "#]]
-    .assert_debug_eq(&(&env, &term));
+    expect!["(Env { variables: [?ty_1, ?ty_2, ?ty_3], coherence_mode: false }, [?ty_1, ?ty_3])"]
+        .assert_eq(&format!("{:?}", (&env, &term)));
 
     let (mut env_min, term_min, m) = minimize(env, term);
 
-    expect![[r#"
-        (
-            Env {
-                variables: [
-                    ?ty_0,
-                    ?ty_1,
-                ],
-                coherence_mode: false,
-            },
-            [
-                ?ty_0,
-                ?ty_1,
-            ],
-        )
-    "#]]
-    .assert_debug_eq(&(&env_min, &term_min));
+    expect!["(Env { variables: [?ty_0, ?ty_1], coherence_mode: false }, [?ty_0, ?ty_1])"]
+    .assert_eq(&format!("{:?}", (&env_min, &term_min)));
 
     let ty0 = term_min[0].as_variable().unwrap();
     let ty1 = term_min[1].as_variable().unwrap();

examples/formality-eg/grammar/test.rs

@@ -8,7 +8,10 @@ use super::{Expr, StructDecl, Ty};
 fn test_struct_decl() {
     let r: StructDecl = term("struct Point { x: integer, y: integer }");
     expect_test::expect![[r#"
-        struct Point { x : integer, y : integer }
+        StructDecl {
+            id: Point,
+            bound: { x : integer, y : integer },
+        }
     "#]]
     .assert_debug_eq(&r);
 }
@@ -17,7 +20,12 @@ fn test_struct_decl() {
 fn test_struct_ty_empty_args() {
     let r: Ty = term("Point");
     expect_test::expect![[r#"
-        Point
+        StructTy(
+            StructTy {
+                id: Point,
+                parameters: [],
+            },
+        )
     "#]]
     .assert_debug_eq(&r);
 }
@@ -26,7 +34,12 @@ fn test_struct_ty_empty_args() {
 fn test_struct_ty_no_args() {
     let r: Ty = term("Point");
     expect_test::expect![[r#"
-        Point
+        StructTy(
+            StructTy {
+                id: Point,
+                parameters: [],
+            },
+        )
     "#]]
     .assert_debug_eq(&r);
 }
@@ -35,7 +48,16 @@ fn test_struct_ty_no_args() {
 fn test_vec_int_ty() {
     let r: Ty = term("Vec<integer>");
     expect_test::expect![[r#"
-        Vec <integer>
+        StructTy(
+            StructTy {
+                id: Vec,
+                parameters: [
+                    Ty(
+                        Integer,
+                    ),
+                ],
+            },
+        )
     "#]]
     .assert_debug_eq(&r);
 }
@@ -44,7 +66,19 @@ fn test_vec_int_ty() {
 fn test_expression() {
     let r: Expr = term("3 + 5 * 6");
     expect_test::expect![[r#"
-        3 + 5 * 6
+        Add(
+            IntegerLiteral(
+                3,
+            ),
+            Mul(
+                IntegerLiteral(
+                    5,
+                ),
+                IntegerLiteral(
+                    6,
+                ),
+            ),
+        )
     "#]]
     .assert_debug_eq(&r);
 }

tests/parser-torture-tests/ambiguity.rs

@@ -27,7 +27,12 @@ fn reduce_reduce_ok() {
 
     let term: Root = crate::ptt::term("my String");
     expect_test::expect![[r#"
-        my String
+        ClassTy(
+            ClassTy {
+                perm: My,
+                class_id: String,
+            },
+        )
     "#]]
     .assert_debug_eq(&term);
 }

tests/parser-torture-tests/precedence.rs

@@ -20,16 +20,41 @@ formality_core::id!(Id);
 fn mul_is_higher_precedence() {
     let term: Expr = crate::ptt::term("a + b * c");
     expect_test::expect![[r#"
-        a + b * c
+        Add(
+            Id(
+                a,
+            ),
+            Mul(
+                Id(
+                    b,
+                ),
+                Id(
+                    c,
+                ),
+            ),
+        )
     "#]]
     .assert_debug_eq(&term);
 }
 
 #[test]
+// FIXME #[should_panic(expected = "ambiguous parse")]
 fn equal_precedence_panics() {
     let term: Expr = crate::ptt::term("a + b * c");
     expect_test::expect![[r#"
-        a + b * c
+        Add(
+            Id(
+                a,
+            ),
+            Mul(
+                Id(
+                    b,
+                ),
+                Id(
+                    c,
+                ),
+            ),
+        )
     "#]]
     .assert_debug_eq(&term);
 }