More refactoring in ObjectSubclassManager

Author: lukaskubanek

Sources/InterposeKit/Hooks/HookStrategy/ObjectHookStrategy/ObjectSubclassManager.swift

@@ -36,17 +36,16 @@ internal enum ObjectSubclassManager {
         // with the runtime.
         let subclass: AnyClass = try self.makeSubclass(for: object)
 
-        // Then, set the created class on the object.
-        object_setClass(object, subclass)
+        // Finally, set the created class on the object.
+        let previousClass: AnyClass? = object_setClass(object, subclass)
 
         Interpose.log({
             let subclassName = NSStringFromClass(subclass)
             let objectAddress = String(format: "%p", object)
             var message = "Created subclass: \(subclassName) for object \(objectAddress)"
 
-            if let superclass = class_getSuperclass(subclass) {
-                let superclassName = NSStringFromClass(superclass)
-                message += " (was: \(superclassName))"
+            if let previousClass {
+                message += " (previously: \(NSStringFromClass(previousClass)))"
             }
 
             return message
@@ -74,14 +73,18 @@ internal enum ObjectSubclassManager {
         let subclassName = self.uniqueSubclassName(for: perceivedClass)
 
         return try subclassName.withCString { cString in
+            // Attempt to allocate a new subclass that inherits from the object’s actual class.
             guard let subclass: AnyClass = objc_allocateClassPair(actualClass, cString, 0) else {
-                throw InterposeError.failedToAllocateClassPair(
-                    class: perceivedClass,
-                    subclassName: subclassName
+                throw InterposeError.subclassCreationFailed(
+                    subclassName: subclassName,
+                    object: object
                 )
             }
 
+            // Set the perceived class to make the runtime report the original type.
             class_setPerceivedClass(for: subclass, to: perceivedClass)
+            
+            // Register the subclass with the runtime.
             objc_registerClassPair(subclass)
 
             return subclass

Sources/InterposeKit/InterposeError.swift

@@ -44,9 +44,19 @@ public enum InterposeError: LocalizedError {
         selector: Selector,
         imp: IMP?
     )
-
-    /// Unable to register subclass for object-based interposing.
-    case failedToAllocateClassPair(class: AnyClass, subclassName: String)
+    
+    /// Failed to create a dynamic subclass for the given object.
+    ///
+    /// This can occur if the desired subclass name is already in use. While InterposeKit
+    /// generates globally unique subclass names using an internal counter, a name collision may
+    /// still happen if another system has registered a class with the same name earlier during
+    /// the process lifetime.
+    case subclassCreationFailed(
+        subclassName: String,
+        object: NSObject
+    )
+    
+    // ---
 
     /// Object-based hooking does not work if an object is using KVO.
     /// The KVO mechanism also uses subclasses created at runtime but doesn't check for additional overrides.
@@ -81,8 +91,8 @@ extension InterposeError: Equatable {
             return "Implementation not found: -[\(`class`) \(selector)]"
         case .revertCorrupted(let `class`, let selector, let IMP):
             return "Unexpected Implementation in -[\(`class`) \(selector)]: \(String(describing: IMP))"
-        case .failedToAllocateClassPair(let `class`, let subclassName):
-            return "Failed to allocate class pair: \(`class`), \(subclassName)"
+        case .subclassCreationFailed(let subclassName, let object):
+            return "Failed to allocate class pair: \(object), \(subclassName)"
         case .kvoDetected(let obj):
             return "Unable to hook object that uses Key Value Observing: \(obj)"
         case .objectPosingAsDifferentClass(let obj, let actualClass):