Avoid IR cycle for compiler-builtin ObjC typedefs shadowing themselves

bindgen-tests/tests/headers/objc_builtin_typedef_cycle.h

@@ -0,0 +1,7 @@
+// bindgen-flags: -- -x objective-c -isystem tests/headers/support/objc-builtin-typedef-cycle
+
+#include <system-objc.h>
+
+@protocol Foo
+- (id)foo;
+@end

bindgen-tests/tests/headers/support/objc-builtin-typedef-cycle/system-objc.h

@@ -0,0 +1,9 @@
+/* Minimal stand-in for a platform SDK's objc/objc.h: a typedef that
+ * shadows a compiler builtin ObjC type by aliasing its own underlying
+ * representation. Included via `-isystem` so clang treats it as a system
+ * header, matching how real SDKs provide it. */
+typedef struct objc_class *Class;
+struct objc_object {
+    Class isa;
+};
+typedef struct objc_object *id;

bindgen/ir/ty.rs

@@ -1068,6 +1068,39 @@ impl Type {
                 }
                 CXType_Typedef => {
                     let inner = cursor.typedef_type().expect("Not valid Type?");
+
+                    // Some compiler builtins (Objective-C's `id`, `SEL`,
+                    // `Class`) can also be redeclared via a same-named
+                    // typedef aliasing their underlying representation (see
+                    // e.g. objc/objc.h's `#if !OBJC_TYPES_DEFINED` block,
+                    // meant to avoid clashing when the builtins aren't
+                    // already provided by the compiler). Depending on
+                    // libclang's version, asking such a typedef for its
+                    // underlying type can report the *same* declaration
+                    // (identical USR) back instead of desugaring to the
+                    // written-out type. Treating that as an ordinary
+                    // `Alias` would make this type indirectly reference
+                    // itself once bindgen's deferred `resolve_typerefs`
+                    // finishes resolving the "already resolved" builtin
+                    // lookup, looping forever when e.g. computing its
+                    // canonical type. Detect the same-USR case up front and
+                    // resolve directly as the inner kind instead of
+                    // aliasing to it, exactly as we would if `ty` itself had
+                    // reported that kind.
+                    let same_underlying_decl = matches!(
+                        (cursor.usr(), inner.declaration().usr()),
+                        (Some(outer), Some(inner)) if outer == inner
+                    );
+                    if same_underlying_decl {
+                        return Self::from_clang_ty(
+                            potential_id,
+                            &inner,
+                            location,
+                            parent_id,
+                            ctx,
+                        );
+                    }
+
                     let inner_id =
                         Item::from_ty_or_ref(inner, location, None, ctx);
                     if inner_id == potential_id {