Enable module lookup in TurboModules

Summary:
NativeModules are instantiated by the bridge. If they choose, they can capture the bridge instance that instantiated them. From within the NativeModule, the bridge can then be used to lookup other NativeModules. TurboModules have no way to do such a lookup.

Both NativeModules and TurboModules need to be able to query for one another. Therefore, we have four cases:
1. NativeModule accesses NativeModule.
2. NativeModule accesses TurboModule.
3. TurboModule accesses NativeModule.
4. TurboModule accesses TurboModule.

In summary, this solution extends the bridge to support querying TurboModules. It also introduces a `RCTTurboModuleLookupDelegate` protocol, which, implemented by `RCTTurboModuleManager`, supports querying TurboModules:
```
protocol RCTTurboModuleLookupDelegate <NSObject>
- (id)moduleForName:(NSString *)moduleName;
- (id)moduleForName:(NSString *)moduleName warnOnLookupFailure:(BOOL)warnOnLookupFailure;
- (BOOL)moduleIsInitialized:(NSString *)moduleName
end
```

If TurboModules want to query other TurboModules, then they need to implement this protocol and synthesize `turboModuleLookupDelegate`:

```
protocol RCTTurboModuleWithLookupCapabilities
property (nonatomic, weak) id<RCTTurboModuleLookupDelegate> turboModuleLookupDelegate;
end
```

NativeModules will continue to use `RCTBridge` to access other NativeModules. Nothing needs to change.

When we attach the bridge to `RCTTurboModuleManager`, we also attach `RCTTurboModuleManager` to the bridge as a `RCTTurboModuleLookupDelegate`. This allows the bridge to query TurboModules, which enables our NativeModules to transparently (i.e: without any NativeModule code modification) query TurboModules.

In an ideal world, all modules would be TurboModules. Until then, we're going to require that TurboModules use the bridge to query for NativeModules or TurboModules.

`RCTTurboModuleManager` keeps a map of all TurboModules that we instantiated. We simply search in this map and return the TurboModule.

This setup allows us to switch NativeModules to TurboModules without compromising their ability to use the bridge to search for other NativeModules (and TurboModules). When we write new TurboModules, we can have them use `RCTTurboModuleLookupDelegate` to do access other TurboModules. Eventually, after we migrate all NativeModules to TurboModules, we can migrate all old callsites to use `RCTTurboModuleLookupDelegate`.

Reviewed By: fkgozali

Differential Revision: D13553186

fbshipit-source-id: 4d0488eef081332c8b70782e1337eccf10717dae

Author: RSNara

React/Base/RCTBridge.h

@@ -159,6 +159,12 @@ RCT_EXTERN void RCTEnableTurboModule(BOOL enabled);
 // Note: This method lazily load the module as necessary.
 - (id)moduleForClass:(Class)moduleClass;
 
+/**
+ * When a NativeModule performs a lookup for a TurboModule, we need to query
+ * the lookupDelegate.
+ */
+- (void)setRCTTurboModuleLookupDelegate:(id<RCTTurboModuleLookupDelegate>)turboModuleLookupDelegate;
+
 /**
  * Convenience method for retrieving all modules conforming to a given protocol.
  * Modules will be sychronously instantiated if they haven't already been,

React/Base/RCTBridge.m

@@ -226,6 +226,11 @@ - (void)dealloc
   [self invalidate];
 }
 
+- (void)setRCTTurboModuleLookupDelegate:(id<RCTTurboModuleLookupDelegate>)turboModuleLookupDelegate
+{
+  [self.batchedBridge setRCTTurboModuleLookupDelegate:turboModuleLookupDelegate];
+}
+
 - (void)didReceiveReloadCommand
 {
   [self reload];

React/Base/RCTBridgeModule.h

@@ -322,6 +322,26 @@ RCT_EXTERN void RCTRegisterModule(Class); \
 
 @end
 
+/**
+ * A protocol that allows TurboModules to do lookup on other TurboModules.
+ * Calling these methods may cause a module to be synchronously instantiated.
+ */
+ @protocol RCTTurboModuleLookupDelegate <NSObject>
+ - (id)moduleForName:(const char *)moduleName;
+
+ /**
+  * Rationale:
+  * When TurboModules lookup other modules by name, we first check the TurboModule
+  * registry to see if a TurboModule exists with the respective name. In this case,
+  * we don't want a RedBox to be raised if the TurboModule isn't found.
+  *
+  * This method is deprecated and will be deleted after the migration from
+  * TurboModules to TurboModules is complete.
+  */
+ - (id)moduleForName:(const char *)moduleName warnOnLookupFailure:(BOOL)warnOnLookupFailure;
+ - (BOOL)moduleIsInitialized:(const char *)moduleName;
+ @end
+
 /**
  * Experimental.
  * A protocol to declare that a class supports TurboModule.

React/CxxBridge/RCTCxxBridge.mm

@@ -172,13 +172,21 @@ @implementation RCTCxxBridge
 
   // This is uniquely owned, but weak_ptr is used.
   std::shared_ptr<Instance> _reactInstance;
+
+  // Necessary for searching in TurboModuleRegistry
+  id<RCTTurboModuleLookupDelegate> _turboModuleLookupDelegate;
 }
 
 @synthesize bridgeDescription = _bridgeDescription;
 @synthesize loading = _loading;
 @synthesize performanceLogger = _performanceLogger;
 @synthesize valid = _valid;
 
+- (void) setRCTTurboModuleLookupDelegate:(id<RCTTurboModuleLookupDelegate>)turboModuleLookupDelegate
+{
+  _turboModuleLookupDelegate = turboModuleLookupDelegate;
+}
+
 - (std::shared_ptr<MessageQueueThread>)jsMessageThread
 {
   return _jsMessageThread;
@@ -428,13 +436,23 @@ - (RCTModuleData *)moduleDataForName:(NSString *)moduleName
 
 - (id)moduleForName:(NSString *)moduleName
 {
-  return _moduleDataByName[moduleName].instance;
+  return [self moduleForName:moduleName lazilyLoadIfNecessary:NO];
 }
 
 - (id)moduleForName:(NSString *)moduleName lazilyLoadIfNecessary:(BOOL)lazilyLoad
 {
+  if (RCTTurboModuleEnabled() && _turboModuleLookupDelegate) {
+    const char* moduleNameCStr = [moduleName UTF8String];
+    if (lazilyLoad || [_turboModuleLookupDelegate moduleIsInitialized:moduleNameCStr]) {
+      id<RCTTurboModule> module = [_turboModuleLookupDelegate moduleForName:moduleNameCStr warnOnLookupFailure:NO];
+      if (module != nil) {
+        return module;
+      }
+    }
+  }
+
   if (!lazilyLoad) {
-    return [self moduleForName:moduleName];
+    return _moduleDataByName[moduleName].instance;
   }
 
   RCTModuleData *moduleData = _moduleDataByName[moduleName];
@@ -463,7 +481,16 @@ - (id)moduleForName:(NSString *)moduleName lazilyLoadIfNecessary:(BOOL)lazilyLoa
 
 - (BOOL)moduleIsInitialized:(Class)moduleClass
 {
-  return _moduleDataByName[RCTBridgeModuleNameForClass(moduleClass)].hasInstance;
+  NSString* moduleName = RCTBridgeModuleNameForClass(moduleClass);
+  if (_moduleDataByName[moduleName].hasInstance) {
+    return YES;
+  }
+
+  if (_turboModuleLookupDelegate) {
+    return [_turboModuleLookupDelegate moduleIsInitialized:[moduleName UTF8String]];
+  }
+
+  return NO;
 }
 
 - (id)moduleForClass:(Class)moduleClass

ReactCommon/turbomodule/core/platform/ios/RCTTurboModule.h

@@ -39,9 +39,17 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
 } // namespace facebook
 
 @protocol RCTTurboModule <NSObject>
-
 @optional
+/**
+ * Used by TurboModules to get access to other TurboModules.
+ *
+ * Usage:
+ * Place `@synthesize turboModuleLookupDelegate = _turboModuleLookupDelegate`
+ * in the @implementation section of your TurboModule.
+ */
+@property (nonatomic, weak) id<RCTTurboModuleLookupDelegate> turboModuleLookupDelegate;
 
+@optional
 // This should be required, after migration is done.
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModuleWithJsInvoker:(std::shared_ptr<facebook::react::JSCallInvoker>)jsInvoker;
 

ReactCommon/turbomodule/core/platform/ios/RCTTurboModuleManager.h

@@ -34,7 +34,7 @@
 
 @end
 
-@interface RCTTurboModuleManager : NSObject
+@interface RCTTurboModuleManager : NSObject<RCTTurboModuleLookupDelegate>
 
 - (instancetype)initWithRuntime:(facebook::jsi::Runtime *)runtime
                          bridge:(RCTBridge *)bridge