fix(runtime): Add forgotten check for protocol availability

* Respect availability attribute in protocols
* Add tests

refs #1084

Author: mbektchiev

src/NativeScript/Metadata/Metadata.mm

@@ -186,10 +186,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 = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr(), onlyIfAvailable));
             if (protocolMeta != nullptr) {
                 const MembersCollection members = protocolMeta->members(identifier, length, type, onlyIfAvailable);
                 if (members.size() > 0) {
@@ -205,7 +205,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 = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr()));
         if (protocolMeta != nullptr)
             protocolMeta->instancePropertiesWithProtocols(container, klass);
     }
@@ -215,7 +215,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 = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr()));
         if (protocolMeta != nullptr)
             protocolMeta->staticPropertiesWithProtocols(container, klass);
     }
@@ -241,7 +241,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 = static_cast<const ProtocolMeta*>(MetaFile::instance()->globalTable()->findMeta((*it).valuePtr()));
         if (protocolMeta != nullptr)
             protocolMeta->initializersWithProtocols(container, klass);
     }

tests/TestFixtures/Api/TNSVersions.h

@@ -75,7 +75,33 @@ 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;
+
++ (void)staticMethodFromProtocolNeverAvailable;
+
+@property(readonly) int propertyFromProtocolNeverAvailable;
+
+- (void)methodFromProtocolNeverAvailable;
+
+@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

@@ -11,6 +11,36 @@
 #undef generateVersionImpl
 
 @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

tests/TestRunner/app/VersionDiffTests.js

@@ -78,4 +78,33 @@ 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", function() {
+       expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable)).not.toContain("staticPropertyFromProtocolNeverAvailable", "TNSProtocolNeverAvailable static properties should be skipped as it is unavailable");
+       expect(TNSInterfaceAlwaysAvailable.staticMethodFromProtocolNeverAvailable).toBeUndefined("TNSProtocolNeverAvailable static methods should be skipped as it is unavailable");
+       expect(Object.getOwnPropertyNames(TNSInterfaceAlwaysAvailable.prototype)).not.toContain("propertyFromProtocolNeverAvailable", "TNSProtocolNeverAvailable properties should be skipped as it is unavailable");
+       expect(new TNSInterfaceAlwaysAvailable().methodFromProtocolNeverAvailable).toBeUndefined("TNSProtocolNeverAvailable methods should be skipped as it is unavailable");
+    });
+
+    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);
+    });
 });