fix(runtime): Never check for availability of protocols

Apple regularly create new protocols and move existing
interface members there. E.g. iOS 12.0 introduced the
UIFocusItemScrollableContainer protocol in UIKit which
contained members that have existed in UIScrollView
since iOS 2.0.

* Create `findProtocol` function in `GlobalTable`
* Use it instead of `findMeta` everwhere where a
protocol is looked for
* Add tests

refs #1084

Author: mbektchiev

src/NativeScript/Metadata/Metadata.h

@@ -292,6 +292,12 @@ struct GlobalTable {
 
     const InterfaceMeta* findInterfaceMeta(const char* identifierString, size_t length, unsigned hash) const;
 
+    const ProtocolMeta* findProtocol(WTF::StringImpl* identifier) const;
+
+    const ProtocolMeta* findProtocol(const char* identifierString) const;
+
+    const ProtocolMeta* findProtocol(const char* identifierString, size_t length, unsigned hash) const;
+
     const Meta* findMeta(WTF::StringImpl* identifier, bool onlyIfAvailable = true) const;
 
     const Meta* findMeta(const char* identifierString, bool onlyIfAvailable = true) const;

src/NativeScript/Metadata/Metadata.mm

@@ -79,6 +79,25 @@ static int compareIdentifiers(const char* nullTerminated, const char* notNullTer
     }
 }
 
+const ProtocolMeta* GlobalTable::findProtocol(WTF::StringImpl* identifier) const {
+    return this->findProtocol(reinterpret_cast<const char*>(identifier->characters8()), identifier->length(), identifier->hash());
+}
+
+const ProtocolMeta* GlobalTable::findProtocol(const char* identifierString) const {
+    unsigned hash = WTF::StringHasher::computeHashAndMaskTop8Bits<LChar>(reinterpret_cast<const LChar*>(identifierString));
+    return this->findProtocol(identifierString, strlen(identifierString), hash);
+}
+
+const ProtocolMeta* GlobalTable::findProtocol(const char* identifierString, size_t length, unsigned hash) const {
+    // Do not check for availability when returning a protocol. Apple regularly create new protocols and move
+    // existing interface members there (e.g. iOS 12.0 introduced the UIFocusItemScrollableContainer protocol
+    // in UIKit which contained members that have existed in UIScrollView since iOS 2.0)
+
+    auto meta = this->findMeta(identifierString, length, hash, /*onlyIfAvailable*/ false);
+    ASSERT(!meta || meta->type() == ProtocolType);
+    return static_cast<const ProtocolMeta*>(meta);
+}
+
 const Meta* GlobalTable::findMeta(WTF::StringImpl* identifier, bool onlyIfAvailable) const {
     return this->findMeta(reinterpret_cast<const char*>(identifier->characters8()), identifier->length(), identifier->hash(), onlyIfAvailable);
 }
@@ -186,10 +205,10 @@ void collectInheritanceChainMembers(const char* identifier, size_t length, Membe
         return result;
     }
 
-    // search in protcols
+    // search in protocols
     if (includeProtocols) {
         for (Array<String>::iterator it = protocols->begin(); it != protocols->end(); ++it) {
-            const ProtocolMeta* protocolMeta = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr()));
+            const ProtocolMeta* protocolMeta = MetaFile::instance()->globalTable()->findProtocol((*it).valuePtr());
             if (protocolMeta != nullptr) {
                 const MembersCollection members = protocolMeta->members(identifier, length, type, onlyIfAvailable);
                 if (members.size() > 0) {
@@ -205,7 +224,7 @@ void collectInheritanceChainMembers(const char* identifier, size_t length, Membe
 std::vector<const PropertyMeta*> BaseClassMeta::instancePropertiesWithProtocols(std::vector<const PropertyMeta*>& container, Class klass) const {
     this->instanceProperties(container, klass);
     for (Array<String>::iterator it = protocols->begin(); it != protocols->end(); ++it) {
-        const ProtocolMeta* protocolMeta = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr(), false));
+        const ProtocolMeta* protocolMeta = MetaFile::instance()->globalTable()->findProtocol((*it).valuePtr());
         if (protocolMeta != nullptr)
             protocolMeta->instancePropertiesWithProtocols(container, klass);
     }
@@ -215,7 +234,7 @@ void collectInheritanceChainMembers(const char* identifier, size_t length, Membe
 std::vector<const PropertyMeta*> BaseClassMeta::staticPropertiesWithProtocols(std::vector<const PropertyMeta*>& container, Class klass) const {
     this->staticProperties(container, klass);
     for (Array<String>::iterator it = protocols->begin(); it != protocols->end(); ++it) {
-        const ProtocolMeta* protocolMeta = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr(), false));
+        const ProtocolMeta* protocolMeta = MetaFile::instance()->globalTable()->findProtocol((*it).valuePtr());
         if (protocolMeta != nullptr)
             protocolMeta->staticPropertiesWithProtocols(container, klass);
     }
@@ -241,7 +260,7 @@ void collectInheritanceChainMembers(const char* identifier, size_t length, Membe
 vector<const MethodMeta*> BaseClassMeta::initializersWithProtocols(vector<const MethodMeta*>& container, Class klass) const {
     this->initializers(container, klass);
     for (Array<String>::iterator it = this->protocols->begin(); it != this->protocols->end(); it++) {
-        const ProtocolMeta* protocolMeta = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr(), false));
+        const ProtocolMeta* protocolMeta = MetaFile::instance()->globalTable()->findProtocol((*it).valuePtr());
         if (protocolMeta != nullptr)
             protocolMeta->initializersWithProtocols(container, klass);
     }

src/NativeScript/ObjC/Constructor/ObjCConstructorNative.mm

@@ -105,7 +105,7 @@
         }
 
         for (Array<Metadata::String>::iterator it = baseClassMeta->protocols->begin(); it != baseClassMeta->protocols->end(); it++) {
-            const ProtocolMeta* protocolMeta = (const ProtocolMeta*)MetaFile::instance()->globalTable()->findMeta((*it).valuePtr());
+            const ProtocolMeta* protocolMeta = MetaFile::instance()->globalTable()->findProtocol((*it).valuePtr());
             if (protocolMeta != nullptr) {
                 baseClassMetaStack.push_back(protocolMeta);
             }

src/NativeScript/ObjC/ObjCPrototype.mm

@@ -162,7 +162,7 @@ static EncodedJSValue JSC_HOST_CALL getIterator(ExecState* execState) {
         }
 
         for (Metadata::Array<Metadata::String>::iterator it = baseClassMeta->protocols->begin(); it != baseClassMeta->protocols->end(); it++) {
-            const ProtocolMeta* protocolMeta = (const ProtocolMeta*)MetaFile::instance()->globalTable()->findMeta((*it).valuePtr());
+            const ProtocolMeta* protocolMeta = MetaFile::instance()->globalTable()->findProtocol((*it).valuePtr());
             if (protocolMeta != nullptr)
                 baseClassMetaStack.push_back(protocolMeta);
         }

tests/TestFixtures/Api/TNSVersions.h

@@ -75,7 +75,37 @@ generateMinors(15);
 // max availability version that can be currently represented in the binary metadata is 31.7 (major << 3 | minor) -> uint8_t
 #define MAX_AVAILABILITY 31.7
 
-@interface TNSInterfaceAlwaysAvailable : NSObject
+__attribute__((availability(ios, introduced = MAX_AVAILABILITY)))
+@protocol TNSProtocolNeverAvailable<NSObject>
+
+@property(class, readonly) int staticPropertyFromProtocolNeverAvailable;
+@property(class, readonly) int staticPropertyFromProtocolNeverAvailableNotImplemented;
+
++ (void)staticMethodFromProtocolNeverAvailable;
++ (void)staticMethodFromProtocolNeverAvailableNotImplemented;
+
+@property(readonly) int propertyFromProtocolNeverAvailable;
+@property(readonly) int propertyFromProtocolNeverAvailableNotImplemented;
+
+- (void)methodFromProtocolNeverAvailable;
+- (void)methodFromProtocolNeverAvailableNotImplemented;
+
+@end
+
+__attribute__((availability(ios, introduced = 1.0)))
+@protocol TNSProtocolAlwaysAvailable<NSObject>
+
+@property(class, readonly) int staticPropertyFromProtocolAlwaysAvailable;
+
++ (void)staticMethodFromProtocolAlwaysAvailable;
+
+@property(readonly) int propertyFromProtocolAlwaysAvailable;
+
+- (void)methodFromProtocolAlwaysAvailable;
+
+@end
+
+@interface TNSInterfaceAlwaysAvailable : NSObject <TNSProtocolNeverAvailable, TNSProtocolAlwaysAvailable>
 @end
 
 __attribute__((availability(ios, introduced = MAX_AVAILABILITY)))

tests/TestFixtures/Api/TNSVersions.m

@@ -10,11 +10,50 @@
 #import "TNSVersions.h"
 #undef generateVersionImpl
 
+#pragma clang diagnostic push
+// Ignore warnings about not implemented required protocol members.
+// Those coming from TNSProtocolNeverAvailable are intentionally left unimplemented
+#pragma clang diagnostic ignored "-Wobjc-protocol-property-synthesis"
+#pragma clang diagnostic ignored "-Wobjc-property-implementation"
+#pragma clang diagnostic ignored "-Wprotocol"
+
 @implementation TNSInterfaceAlwaysAvailable
+
++ (int)staticPropertyFromProtocolAlwaysAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+    return 12;
+}
+
++ (int)staticPropertyFromProtocolNeverAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+    return 23;
+}
+
++ (void)staticMethodFromProtocolAlwaysAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+}
+
++ (void)staticMethodFromProtocolNeverAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+}
+
+@synthesize propertyFromProtocolAlwaysAvailable;
+@synthesize propertyFromProtocolNeverAvailable;
+
+- (void)methodFromProtocolAlwaysAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+}
+
+- (void)methodFromProtocolNeverAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+}
+
 @end
 
 @implementation TNSInterfaceNeverAvailable : TNSInterfaceAlwaysAvailable
 @end
 
 @implementation TNSInterfaceNeverAvailableDescendant : TNSInterfaceNeverAvailable
 @end
+
+#pragma clang diagnostic pop

tests/TestRunner/app/VersionDiffTests.js

@@ -78,4 +78,37 @@ describe(module.id, function() {
         // TNSInterfaceNeverAvailableDescendant : TNSInterfaceNeverAvailable(API31.7 - skipped) : TNSInterfaceAlwaysAvailable
         expect(Object.getPrototypeOf(TNSInterfaceNeverAvailableDescendant).toString()).toBe(TNSInterfaceAlwaysAvailable.toString(), "TNSInterfaceNeverAvailable base class should be skipped as it is unavailable");
     });
+
+    it("Members of a protocol which is unavailable should be skipped only when not implemented by class", function() {
+       expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable)).toContain("staticPropertyFromProtocolNeverAvailable", "TNSProtocolNeverAvailable static properties that are implemented should be present although the protocol is unavailable");
+       expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable)).not.toContain("staticPropertyFromProtocolNeverAvailableNotImplemented", "TNSProtocolNeverAvailable unimplemented static properties should be skipped");
+       expect(TNSInterfaceAlwaysAvailable.staticMethodFromProtocolNeverAvailable).toBeDefined("TNSProtocolNeverAvailable static methods that are implemented should be present although the protocol is unavailable");
+       expect(TNSInterfaceAlwaysAvailable.staticMethodFromProtocolNeverAvailableNotImplemented).toBeUndefined("TNSProtocolNeverAvailable unimplemented static methods should be skipped");
+       expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable.prototype)).toContain("propertyFromProtocolNeverAvailable", "TNSProtocolNeverAvailable properties that are implemented should be present although the protocol is unavailable");
+       expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable.prototype)).not.toContain("propertyFromProtocolNeverAvailableNotImplemented", "TNSProtocolNeverAvailable unimplemented properties should be skipped");
+       expect(new TNSInterfaceAlwaysAvailable().methodFromProtocolNeverAvailable).toBeDefined("TNSProtocolNeverAvailable methods that are implemented should be present although the protocol is unavailable");
+       expect(new TNSInterfaceAlwaysAvailable().methodFromProtocolNeverAvailableNotImplemented).toBeUndefined("TNSProtocolNeverAvailable unimplemented methods should be skipped");
+    });
+
+    it("Members of a protocol which is available should be present", function() {
+        const obj = new TNSInterfaceAlwaysAvailable();
+        let expectedOutput = "";
+        expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable.prototype)).toContain("propertyFromProtocolAlwaysAvailable", "TNSProtocolAlwaysAvailable properties should be present as it is available");
+        expect(obj.propertyFromProtocolAlwaysAvailable).toBe(0);
+       
+        expect(obj.methodFromProtocolAlwaysAvailable).toBeDefined("TNSProtocolAlwaysAvailable methods should be present as it is available");
+        obj.methodFromProtocolAlwaysAvailable(); expectedOutput += "methodFromProtocolAlwaysAvailable called";
+        expect(TNSGetOutput()).toBe(expectedOutput);
+       
+        TNSClearOutput();
+       
+        expectedOutput = "";
+        expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable)).toContain("staticPropertyFromProtocolAlwaysAvailable", "TNSProtocolAlwaysAvailable static properties should be present as it is available");
+        TNSInterfaceAlwaysAvailable.staticPropertyFromProtocolAlwaysAvailable; expectedOutput += "staticPropertyFromProtocolAlwaysAvailable called";
+       
+        expect(TNSInterfaceAlwaysAvailable.staticMethodFromProtocolAlwaysAvailable).toBeDefined("TNSProtocolAlwaysAvailable static methods should be present as it is available");
+        TNSInterfaceAlwaysAvailable.staticMethodFromProtocolAlwaysAvailable(); expectedOutput += "staticMethodFromProtocolAlwaysAvailable called";
+       
+       expect(TNSGetOutput()).toBe(expectedOutput);
+    });
 });