Ported a few changes from the Swift implementation.

Swift PR: ReactiveCocoa/ReactiveCocoa#3302
1. Improved performance in general method interception.
2. Reduced the overhead of computing selector aliases.
3. Reliable invocation of the next implementation of `-forwardInvocation:`, `-methodSignatureForSelector:` and `-respondsToSelector:` in the superclass hierarchy.

Author: andersio

ReactiveObjC/NSObject+RACSelectorSignal.m

@@ -15,16 +15,18 @@
 #import "RACSubject.h"
 #import "RACTuple.h"
 #import "NSObject+RACDescription.h"
+#import "EXTScope.h"
 #import <objc/message.h>
 #import <objc/runtime.h>
 
 NSString * const RACSelectorSignalErrorDomain = @"RACSelectorSignalErrorDomain";
 const NSInteger RACSelectorSignalErrorMethodSwizzlingRace = 1;
 
-static NSString * const RACSignalForSelectorAliasPrefix = @"rac_alias_";
-static NSString * const RACSignalForSelectorAliasOfOriginalPrefix = @"rac_runtime_";
 static NSString * const RACSubclassSuffix = @"_RACSelectorSignal";
+static const char * RACSignalForSelectorAliasPrefix = "rac_alias_";
+static const int RACSignalForSelectorAliasPrefixLength = 10;
 static void *RACSubclassAssociationKey = &RACSubclassAssociationKey;
+static void *RACInteropImplsKey = &RACInteropImplsKey;
 
 static NSMutableSet *swizzledClasses() {
 	static NSMutableSet *set;
@@ -39,8 +41,9 @@
 
 @implementation NSObject (RACSelectorSignal)
 
-static void RACSwizzleForwardInvocation(Class class) {
-	Class superclass = class_getSuperclass(class);
+static void RACSwizzleForwardInvocation(Class baseClass, NSDictionary *interopImpls) {
+	Class statedClass = class_getSuperclass(baseClass);
+
 	SEL forwardInvocationSEL = @selector(forwardInvocation:);
 
 	// Set up a new version of -forwardInvocation:.
@@ -53,81 +56,80 @@ static void RACSwizzleForwardInvocation(Class class) {
 	// was no existing implementation, throw an unrecognized selector
 	// exception.
 	id newForwardInvocation = ^(id self, NSInvocation *invocation) {
-		BOOL forward = NO;
-
 		SEL originalSelector = invocation.selector;
 		SEL aliasSelector = RACAliasForSelector(originalSelector);
-		SEL aliasOfOriginalSelector = RACAliasOfOriginalForSelector(originalSelector);
 
 		RACSubject* subject = objc_getAssociatedObject(self, aliasSelector);
 
-		Class baseClass = object_getClass(self);
+		@onExit {
+			if (subject != nil) {
+				[subject sendNext:invocation.rac_argumentsTuple];
+			}
+		};
 
 		// RAC exchanges implementations at runtime so as to invoke the desired
 		// version without using fragile dependencies like libffi. This means
 		// all instances that had been applied `signalForSelector:` are
 		// non-threadsafe as any mutable instances.
 
-		if ([baseClass instancesRespondToSelector:aliasOfOriginalSelector]) {
+		Method method = class_getInstanceMethod(statedClass, originalSelector);
+		const char* typeEncoding = method_getTypeEncoding(method);
+
+		IMP interopImpl = [[interopImpls objectForKey:[NSValue valueWithPointer:originalSelector]] pointerValue];
+		if (interopImpl != nil) {
 			// `self` uses a runtime subclass generated by third-party APIs, and RAC
 			// found an existing implementation for the selector at the setup time.
 			// Call that implementation if it is not the ObjC message forwarder.
-			Method xchgMethod = class_getInstanceMethod(baseClass, aliasOfOriginalSelector);
-			IMP impl = method_getImplementation(xchgMethod);
+			IMP oldImpl = class_replaceMethod(baseClass, originalSelector, interopImpl, typeEncoding);
+			invocation.selector = originalSelector;
+			[invocation invoke];
+			class_replaceMethod(baseClass, originalSelector, oldImpl, typeEncoding);
+			return;
+		}
+
+		BOOL forwardRegardless = NO;
+
+		if (method != nil) {
+			IMP statedClassImpl = method_getImplementation(method);
+
+			if (statedClassImpl != _objc_msgForward) {
+				// The stated class has an implementation of the selector. Call that
+				// implementation if it is not the ObjC message forwarder.
+				Method aliasMethod = rac_getImmediateInstanceMethod(baseClass, aliasSelector);
+
+				if (statedClassImpl != method_getImplementation(aliasMethod)) {
+					class_replaceMethod(baseClass, aliasSelector, statedClassImpl, typeEncoding);
+				}
 
-			if (impl != _objc_msgForward) {
-				IMP oldImpl = class_replaceMethod(baseClass, originalSelector, impl, method_getTypeEncoding(xchgMethod));
-				invocation.selector = originalSelector;
-				[invocation invoke];
-				class_replaceMethod(baseClass, originalSelector, oldImpl, method_getTypeEncoding(xchgMethod));
-			} else {
-				forward = YES;
-			}
-		} else if ([superclass instancesRespondToSelector:originalSelector]) {
-			// The stated class has an implementation of the selector. Call that
-			// implementation if it is not the ObjC message forwarder.
-			Method method = class_getInstanceMethod(superclass, originalSelector);
-			IMP impl = method_getImplementation(method);
-
-			if (impl != _objc_msgForward) {
-				class_replaceMethod(baseClass, aliasSelector, impl, method_getTypeEncoding(method));
 				invocation.selector = aliasSelector;
 				[invocation invoke];
-			} else {
-				forward = YES;
+
+				return;
 			}
-		} else {
-			// No appropriate implementation was found. Forward the invocation to the
-			// stated class' `forwardInvocation:` only if the selector had not been
-			// intercepted via `signalForSelector:`.
-			//
-			// `subject` is usually null except for optional protocol requirements
-			// that are implemented at runtime through RAC.
-			forward = subject == nil;
+
+			forwardRegardless = YES;
 		}
 
-		if (forward) {
+		// No appropriate implementation was found. Forward the invocation to the
+		// stated class' `forwardInvocation:` only if the selector had not been
+		// intercepted via `signalForSelector:`.
+		//
+		// `subject` is usually null except for optional protocol requirements
+		// that are implemented at runtime through RAC.
+		if (subject == nil || forwardRegardless) {
 			// Forward the invocation to the closest `forwardInvocation:` in the
 			// inheritance hierarchy.
-			struct objc_super target = {
-				.super_class = superclass,
-				.receiver = self,
-			};
-
-			void*(*superForwardInvocation)(struct objc_super *, SEL, NSInvocation*) = (__typeof__(superForwardInvocation)) objc_msgSendSuper;
-			superForwardInvocation(&target, forwardInvocationSEL, invocation);
-		}
-
-		if (subject != nil) {
-			[subject sendNext:invocation.rac_argumentsTuple];
+			Method forwardInvocationMethod = class_getInstanceMethod(statedClass, forwardInvocationSEL);
+			void*(*superForwardInvocation)(id, SEL, NSInvocation*) = (__typeof__(superForwardInvocation)) method_getImplementation(forwardInvocationMethod);
+			superForwardInvocation(self, forwardInvocationSEL, invocation);
 		}
 	};
 
-	class_replaceMethod(class, forwardInvocationSEL, imp_implementationWithBlock(newForwardInvocation), "v@:@");
+	class_replaceMethod(baseClass, forwardInvocationSEL, imp_implementationWithBlock(newForwardInvocation), "v@:@");
 }
 
-static void RACSwizzleRespondsToSelector(Class class) {
-	Class superclass = class_getSuperclass(class);
+static void RACSwizzleRespondsToSelector(Class baseClass) {
+	Class statedClass = class_getSuperclass(baseClass);
 	SEL respondsToSelectorSEL = @selector(respondsToSelector:);
 
 	// Set up a new version of -respondsToSelector: that returns YES for methods
@@ -138,24 +140,19 @@ static void RACSwizzleRespondsToSelector(Class class) {
 	// the instance has a signal for the selector.
 	// Otherwise, call the original -respondsToSelector:.
 	id newRespondsToSelector = ^ BOOL (id self, SEL selector) {
-		Method method = rac_getImmediateInstanceMethod(class, selector);
+		Method method = rac_getImmediateInstanceMethod(baseClass, selector);
 
 		if (method != NULL && method_getImplementation(method) == _objc_msgForward) {
 			SEL aliasSelector = RACAliasForSelector(selector);
 			if (objc_getAssociatedObject(self, aliasSelector) != nil) return YES;
 		}
 
-		struct objc_super target = {
-			.super_class = superclass,
-			.receiver = self,
-		};
-
-		BOOL(*superRespondsToSelector)(struct objc_super *, SEL, SEL) = (__typeof__(superRespondsToSelector)) objc_msgSendSuper;
-
-		return superRespondsToSelector(&target, respondsToSelectorSEL, selector);
+		Method superMethod = class_getInstanceMethod(statedClass, respondsToSelectorSEL);
+		BOOL(*superRespondsToSelector)(id, SEL, SEL) = (__typeof__(superRespondsToSelector)) method_getImplementation(superMethod);
+		return superRespondsToSelector(self, respondsToSelectorSEL, selector);
 	};
 
-	class_replaceMethod(class, respondsToSelectorSEL, imp_implementationWithBlock(newRespondsToSelector), "v@::");
+	class_replaceMethod(baseClass, respondsToSelectorSEL, imp_implementationWithBlock(newRespondsToSelector), "v@::");
 }
 
 static void RACSwizzleGetClass(Class class, Class statedClass) {
@@ -167,32 +164,30 @@ static void RACSwizzleGetClass(Class class, Class statedClass) {
 	class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(method));
 }
 
-static void RACSwizzleMethodSignatureForSelector(Class class) {
+static void RACSwizzleMethodSignatureForSelector(Class baseClass) {
+	Class statedClass = class_getSuperclass(baseClass);
+	SEL methodSignatureForSelectorSEL = @selector(methodSignatureForSelector:);
+
 	IMP newIMP = imp_implementationWithBlock(^(id self, SEL selector) {
 		// Don't send the -class message to the receiver because we've changed
 		// that to return the original class.
-		Class actualClass = object_getClass(self);
-		Method method = class_getInstanceMethod(actualClass, selector);
+		Method method = class_getInstanceMethod(baseClass, selector);
+
 		if (method == NULL) {
 			// Messages that the original class dynamically implements fall
 			// here.
 			//
 			// Call the original class' -methodSignatureForSelector:.
-			struct objc_super target = {
-				.super_class = class_getSuperclass(class),
-				.receiver = self,
-			};
-			NSMethodSignature * (*messageSend)(struct objc_super *, SEL, SEL) = (__typeof__(messageSend))objc_msgSendSuper;
-			return messageSend(&target, @selector(methodSignatureForSelector:), selector);
+			Method superMethod = class_getInstanceMethod(statedClass, methodSignatureForSelectorSEL);
+			NSMethodSignature * (*messageSend)(id, SEL, SEL) = (__typeof__(messageSend)) method_getImplementation(superMethod);
+			return messageSend(self, methodSignatureForSelectorSEL, selector);
 		}
 
 		char const *encoding = method_getTypeEncoding(method);
 		return [NSMethodSignature signatureWithObjCTypes:encoding];
 	});
 
-	SEL selector = @selector(methodSignatureForSelector:);
-	Method methodSignatureForSelectorMethod = class_getInstanceMethod(class, selector);
-	class_replaceMethod(class, selector, newIMP, method_getTypeEncoding(methodSignatureForSelectorMethod));
+	class_replaceMethod(baseClass, methodSignatureForSelectorSEL, newIMP, "@@::");
 }
 
 // It's hard to tell which struct return types use _objc_msgForward, and
@@ -266,12 +261,20 @@ static void RACCheckTypeEncoding(const char *typeEncoding) {
 
 			RACCheckTypeEncoding(typeEncoding);
 
-			Method existingMethod = rac_getImmediateInstanceMethod(class, selector);
-
-			if (existingMethod) {
-				SEL sel = RACAliasOfOriginalForSelector(selector);
-				BOOL addedAlias __attribute__((unused)) = class_addMethod(class, sel, method_getImplementation(existingMethod), typeEncoding);
-				NSCAssert(addedAlias, @"Existing external implementation for %@ has already been copied to %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(sel), class);
+			Method dynamicImmediateMethod = rac_getImmediateInstanceMethod(class, selector);
+			if (dynamicImmediateMethod) {
+				IMP dynamicImmediateImpl = method_getImplementation(dynamicImmediateMethod);
+				if (dynamicImmediateImpl != _objc_msgForward) {
+					@synchronized (class) {
+						NSMutableDictionary* interopImpls = objc_getAssociatedObject(class, RACInteropImplsKey);
+						NSValue* key = [NSValue valueWithPointer:selector];
+
+						if ([interopImpls objectForKey:key] == nil) {
+							[interopImpls setObject:[NSValue valueWithPointer:dynamicImmediateImpl]
+															 forKey:key];
+						}
+					}
+				}
 			}
 
 			// Redefine the selector to call -forwardInvocation:.
@@ -282,14 +285,21 @@ static void RACCheckTypeEncoding(const char *typeEncoding) {
 	}
 }
 
-static SEL RACAliasOfOriginalForSelector(SEL originalSelector) {
-	NSString *selectorName = NSStringFromSelector(originalSelector);
-	return NSSelectorFromString([RACSignalForSelectorAliasOfOriginalPrefix stringByAppendingString:selectorName]);
-}
-
 static SEL RACAliasForSelector(SEL originalSelector) {
-	NSString *selectorName = NSStringFromSelector(originalSelector);
-	return NSSelectorFromString([RACSignalForSelectorAliasPrefix stringByAppendingString:selectorName]);
+	const char* selectorString = sel_getName(originalSelector);
+	unsigned long length = strlen(selectorString);
+	unsigned long prefixedLength = length + RACSignalForSelectorAliasPrefixLength;
+
+	char* buffer = malloc(length + RACSignalForSelectorAliasPrefixLength + 1);
+	@onExit {
+		free(buffer);
+	};
+
+	memcpy(buffer, RACSignalForSelectorAliasPrefix, RACSignalForSelectorAliasPrefixLength);
+	memcpy(buffer + RACSignalForSelectorAliasPrefixLength, selectorString, length);
+	*(buffer + prefixedLength) = '\0';
+
+	return sel_registerName(buffer);
 }
 
 static const char *RACSignatureForUndefinedSelector(SEL selector) {
@@ -304,6 +314,20 @@ static SEL RACAliasForSelector(SEL originalSelector) {
 	return signature.UTF8String;
 }
 
+static NSDictionary* RACSetupInteropImplDictionary(Class baseClass) {
+	NSDictionary* interopImpls;
+
+	@synchronized (baseClass) {
+		interopImpls = objc_getAssociatedObject(baseClass, RACInteropImplsKey);
+		if (interopImpls == nil) {
+			interopImpls = [[NSMutableDictionary alloc] init];
+			objc_setAssociatedObject(baseClass, RACInteropImplsKey, interopImpls, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+		}
+	}
+
+	return interopImpls;
+}
+
 static Class RACSwizzleClass(NSObject *self) {
 	Class statedClass = self.class;
 	Class baseClass = object_getClass(self);
@@ -330,7 +354,7 @@ static Class RACSwizzleClass(NSObject *self) {
 		// implementation may be ignorant of methods added to this class.
 		@synchronized (swizzledClasses()) {
 			if (![swizzledClasses() containsObject:className]) {
-				RACSwizzleForwardInvocation(baseClass);
+				RACSwizzleForwardInvocation(baseClass, RACSetupInteropImplDictionary(baseClass));
 				RACSwizzleRespondsToSelector(baseClass);
 				RACSwizzleGetClass(baseClass, statedClass);
 				RACSwizzleGetClass(object_getClass(baseClass), statedClass);
@@ -349,7 +373,7 @@ static Class RACSwizzleClass(NSObject *self) {
 		subclass = objc_allocateClassPair(baseClass, subclassName, 0);
 		if (subclass == nil) return nil;
 
-		RACSwizzleForwardInvocation(subclass);
+		RACSwizzleForwardInvocation(subclass, RACSetupInteropImplDictionary(subclass));
 		RACSwizzleRespondsToSelector(subclass);
 
 		RACSwizzleGetClass(subclass, statedClass);