Implementation builder block no longer has optional return value

Author: lukaskubanek

Sources/InterposeKit/ClassHook.swift

@@ -3,13 +3,14 @@ import Foundation
 extension Interpose {
     /// A hook to an instance method and stores both the original and new implementation.
     final public class ClassHook<MethodSignature, HookSignature>: TypedHook<MethodSignature, HookSignature> {
-        /* HookSignature?: This must be optional or swift runtime will crash.
-         Or swiftc may segfault. Compiler bug? */
-        /// Initialize a new hook to interpose an instance method.
-        public init(`class`: AnyClass, selector: Selector,
-                    implementation: (ClassHook<MethodSignature, HookSignature>) -> HookSignature?) throws {
+        
+        public init(
+            `class`: AnyClass,
+            selector: Selector,
+            implementation: (ClassHook<MethodSignature, HookSignature>) -> HookSignature
+        ) throws {
             try super.init(class: `class`, selector: selector)
-            replacementIMP = imp_implementationWithBlock(implementation(self) as Any)
+            replacementIMP = imp_implementationWithBlock(implementation(self))
         }
 
         override func replaceImplementation() throws {

Sources/InterposeKit/InterposeKit.swift

@@ -69,8 +69,8 @@ final public class Interpose {
         _ selName: String,
         methodSignature: MethodSignature.Type = MethodSignature.self,
         hookSignature: HookSignature.Type = HookSignature.self,
-        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature?)
-        throws -> TypedHook<MethodSignature, HookSignature> {
+        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature
+    ) throws -> TypedHook<MethodSignature, HookSignature> {
         try hook(NSSelectorFromString(selName),
             methodSignature: methodSignature, hookSignature: hookSignature, implementation)
     }
@@ -80,30 +80,29 @@ final public class Interpose {
         _ selector: Selector,
         methodSignature: MethodSignature.Type = MethodSignature.self,
         hookSignature: HookSignature.Type = HookSignature.self,
-        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature?)
-        throws -> TypedHook<MethodSignature, HookSignature> {
-            let hook = try prepareHook(selector, methodSignature: methodSignature,
-                                       hookSignature: hookSignature, implementation)
-            try hook.apply()
-            return hook
-
+        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature
+    ) throws -> TypedHook<MethodSignature, HookSignature> {
+        let hook = try prepareHook(selector, methodSignature: methodSignature,
+                                   hookSignature: hookSignature, implementation)
+        try hook.apply()
+        return hook
     }
 
     /// Prepares a hook, but does not call apply immediately.
     @discardableResult public func prepareHook<MethodSignature, HookSignature> (
         _ selector: Selector,
         methodSignature: MethodSignature.Type = MethodSignature.self,
         hookSignature: HookSignature.Type = HookSignature.self,
-        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature?)
-        throws -> TypedHook<MethodSignature, HookSignature> {
-            var hook: TypedHook<MethodSignature, HookSignature>
-            if let object = self.object {
-                hook = try ObjectHook(object: object, selector: selector, implementation: implementation)
-            } else {
-                hook = try ClassHook(class: `class`, selector: selector, implementation: implementation)
-            }
-            hooks.append(hook)
-            return hook
+        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature
+    ) throws -> TypedHook<MethodSignature, HookSignature> {
+        var hook: TypedHook<MethodSignature, HookSignature>
+        if let object = self.object {
+            hook = try ObjectHook(object: object, selector: selector, implementation: implementation)
+        } else {
+            hook = try ClassHook(class: `class`, selector: selector, implementation: implementation)
+        }
+        hooks.append(hook)
+        return hook
     }
 
     /// Apply all stored hooks.

Sources/InterposeKit/NSObject+InterposeKit.swift

@@ -44,7 +44,7 @@ extension NSObject {
         for selector: Selector,
         methodSignature: MethodSignature.Type,
         hookSignature: HookSignature.Type,
-        implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature?
+        implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature
     ) throws -> AnyHook {
         try Interpose.ObjectHook(
             object: self,
@@ -63,7 +63,7 @@ extension NSObject {
         _ selector: Selector,
         methodSignature: MethodSignature.Type = MethodSignature.self,
         hookSignature: HookSignature.Type = HookSignature.self,
-        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature?
+        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature
     ) throws -> AnyHook {
         precondition(
             !(self is AnyClass),
@@ -88,7 +88,7 @@ extension NSObject {
         _ selector: Selector,
         methodSignature: MethodSignature.Type = MethodSignature.self,
         hookSignature: HookSignature.Type = HookSignature.self,
-        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature?
+        _ implementation: (TypedHook<MethodSignature, HookSignature>) -> HookSignature
     ) throws -> AnyHook {
         return try Interpose.ClassHook(
             class: self as AnyClass,

Sources/InterposeKit/ObjectHook.swift

@@ -16,8 +16,11 @@ extension Interpose {
         let generatesSuperIMP = InterposeSubclass.supportsSuperTrampolines
 
         /// Initialize a new hook to interpose an instance method.
-        public init(object: AnyObject, selector: Selector,
-                    implementation: (ObjectHook<MethodSignature, HookSignature>) -> HookSignature?) throws {
+        public init(
+            object: AnyObject,
+            selector: Selector,
+            implementation: (ObjectHook<MethodSignature, HookSignature>) -> HookSignature
+        ) throws {
             self.object = object
             try super.init(class: type(of: object), selector: selector)
             let block = implementation(self) as AnyObject