diff --git a/codegen/src/debug.rs b/codegen/src/debug.rs
index 0cda534..92f5dc4 100644
--- a/codegen/src/debug.rs
+++ b/codegen/src/debug.rs
@@ -120,13 +120,10 @@
     if fields.len() != 1 {
         return None;
     }
-    let mut outer = outer;
-    if outer == "Visibility" {
-        outer = "Vis";
-    }
+    const WHITELIST: &[&str] = &["PathArguments", "Visibility"];
     match &fields[0] {
-        Type::Syn(ty) if outer.to_owned() + inner == *ty => Some(ty),
-        _ => None
+        Type::Syn(ty) if WHITELIST.contains(&outer) || outer.to_owned() + inner == *ty => Some(ty),
+        _ => None,
     }
 }
 
diff --git a/tests/debug/gen.rs b/tests/debug/gen.rs
index 05a5f70..5cddc8f 100644
--- a/tests/debug/gen.rs
+++ b/tests/debug/gen.rs
@@ -4597,14 +4597,31 @@
         let _val = &self.value;
         match _val {
             syn::PathArguments::None => formatter.write_str("None"),
-            syn::PathArguments::AngleBracketed(_v0) => {
-                let mut formatter = formatter.debug_tuple("AngleBracketed");
-                formatter.field(Lite(_v0));
+            syn::PathArguments::AngleBracketed(_val) => {
+                let mut formatter = formatter.debug_struct("PathArguments::AngleBracketed");
+                if let Some(val) = &_val.colon2_token {
+                    #[derive(RefCast)]
+                    #[repr(transparent)]
+                    struct Print(syn::token::Colon2);
+                    impl Debug for Print {
+                        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                            formatter.write_str("Some")?;
+                            Ok(())
+                        }
+                    }
+                    formatter.field("colon2_token", Print::ref_cast(val));
+                }
+                if !_val.args.is_empty() {
+                    formatter.field("args", Lite(&_val.args));
+                }
                 formatter.finish()
             }
-            syn::PathArguments::Parenthesized(_v0) => {
-                let mut formatter = formatter.debug_tuple("Parenthesized");
-                formatter.field(Lite(_v0));
+            syn::PathArguments::Parenthesized(_val) => {
+                let mut formatter = formatter.debug_struct("PathArguments::Parenthesized");
+                if !_val.inputs.is_empty() {
+                    formatter.field("inputs", Lite(&_val.inputs));
+                }
+                formatter.field("output", Lite(&_val.output));
                 formatter.finish()
             }
         }
diff --git a/tests/test_derive_input.rs b/tests/test_derive_input.rs
index ef7d2c1..124cfde 100644
--- a/tests/test_derive_input.rs
+++ b/tests/test_derive_input.rs
@@ -85,24 +85,22 @@
        ⋮                            segments: [
        ⋮                                PathSegment {
        ⋮                                    ident: "Vec",
-       ⋮                                    arguments: AngleBracketed(
-       ⋮                                        AngleBracketedGenericArguments {
-       ⋮                                            args: [
-       ⋮                                                Type(
-       ⋮                                                    Type::Path {
-       ⋮                                                        path: Path {
-       ⋮                                                            segments: [
-       ⋮                                                                PathSegment {
-       ⋮                                                                    ident: "Attribute",
-       ⋮                                                                    arguments: None,
-       ⋮                                                                },
-       ⋮                                                            ],
-       ⋮                                                        },
+       ⋮                                    arguments: PathArguments::AngleBracketed {
+       ⋮                                        args: [
+       ⋮                                            Type(
+       ⋮                                                Type::Path {
+       ⋮                                                    path: Path {
+       ⋮                                                        segments: [
+       ⋮                                                            PathSegment {
+       ⋮                                                                ident: "Attribute",
+       ⋮                                                                arguments: None,
+       ⋮                                                            },
+       ⋮                                                        ],
        ⋮                                                    },
-       ⋮                                                ),
-       ⋮                                            ],
-       ⋮                                        },
-       ⋮                                    ),
+       ⋮                                                },
+       ⋮                                            ),
+       ⋮                                        ],
+       ⋮                                    },
        ⋮                                },
        ⋮                            ],
        ⋮                        },