Tweaks to Hook.originalImp

Author: lukaskubanek

Sources/InterposeKit/Hooks/Hook.swift

@@ -128,11 +128,14 @@ public final class Hook {
     // MARK: Original Implementation
     // ============================================================================ //
 
-    // TODO: Make originalIMP private
-    
-    /// The effective original implementation of the hook. Might be looked up at runtime.
-    /// Do not cache this.
-    internal var originalIMP: IMP? {
+    /// The effective original implementation of the method being hooked.
+    ///
+    /// Resolved via the active strategy. If the hook has been applied, it returns a stored
+    /// original implementation. Otherwise, it performs a dynamic lookup at runtime.
+    ///
+    /// Provided to the hook builder via a proxy to enable calls to the original implementation.
+    /// This value is dynamic and must not be cached.
+    internal var originalIMP: IMP {
         self.strategy.originalIMP
     }
 

Sources/InterposeKit/Hooks/HookStrategy/HookStrategy.swift

@@ -49,7 +49,12 @@ extension HookStrategy {
             return originalIMP
         }
 
-        fatalError()
+        fatalError(
+            """
+            No original implementation found for selector \(self.selector) on \(self.class). 
+            This likely  indicates a corrupted or misconfigured class.
+            """
+        )
     }
 
     /// Dynamically resolves the current implementation of the hooked method by walking the class

Tests/InterposeKitTests/HookDynamicLookupTests.swift

@@ -21,15 +21,14 @@ class HookDynamicLookupTests: XCTestCase {
             object: object,
             selector: #selector(ExampleClass.greet(name:)),
             build: { (hook: HookProxy<MethodSignature>) -> HookSignature in
-                // Build a replacement block that calls the original implementation via the hook proxy.
                 return { `self`, name in
                     return hook.original(self, hook.selector, name)
                 }
             }
         )
 
         // Force the dynamic lookup path by ensuring no original IMP has been cached.
-        // The following call will use `lookupOrigIMP` to find the method implementation.
+        // The following call will use `strategy.lookUpIMP()` to find the method implementation.
         let original = unsafeBitCast(
             hook.originalIMP,
             to: (@convention(c) (ExampleClass, Selector, String) -> String).self
@@ -38,5 +37,15 @@ class HookDynamicLookupTests: XCTestCase {
         // Call the original implementation via the looked-up IMP.
         let result = original(object, #selector(ExampleClass.greet(name:)), "World")
         XCTAssertEqual(result, "Hello, World!")
+        
+        try hook.apply()
+        
+        let original2 = unsafeBitCast(
+            hook.originalIMP,
+            to: (@convention(c) (ExampleClass, Selector, String) -> String).self
+        )
+        
+        let result2 = original2(object, #selector(ExampleClass.greet(name:)), "World")
+        XCTAssertEqual(result2, "Hello, World!")
     }
 }