fix(runtime): Add forgotten check for protocol availability

* Respect availability attribute in protocols
* Fix typo Protcols -> Protocols
* Add tests

refs #1084

Author: mbektchiev

src/NativeScript/Metadata/Metadata.h

@@ -865,14 +865,14 @@ struct BaseClassMeta : Meta {
         return this->initializers(initializers);
     }
 
-    std::vector<const MethodMeta*> initializersWithProtcols() const {
+    std::vector<const MethodMeta*> initializersWithProtocols() const {
         std::vector<const MethodMeta*> initializers;
-        return this->initializersWithProtcols(initializers);
+        return this->initializersWithProtocols(initializers);
     }
 
     std::vector<const MethodMeta*> initializers(std::vector<const MethodMeta*>& container) const;
 
-    std::vector<const MethodMeta*> initializersWithProtcols(std::vector<const MethodMeta*>& container) const;
+    std::vector<const MethodMeta*> initializersWithProtocols(std::vector<const MethodMeta*>& container) const;
 };
 
 struct ProtocolMeta : BaseClassMeta {

src/NativeScript/Metadata/Metadata.mm

@@ -198,10 +198,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 std::vector<const MemberMeta*> members = protocolMeta->members(identifier, length, type, onlyIfAvailable);
                 if (members.size() > 0) {
@@ -250,12 +250,12 @@ void collectInheritanceChainMembers(const char* identifier, size_t length, Membe
     return container;
 }
 
-vector<const MethodMeta*> BaseClassMeta::initializersWithProtcols(vector<const MethodMeta*>& container) const {
+vector<const MethodMeta*> BaseClassMeta::initializersWithProtocols(vector<const MethodMeta*>& container) const {
     this->initializers(container);
     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));
         if (protocolMeta != nullptr)
-            protocolMeta->initializersWithProtcols(container);
+            protocolMeta->initializersWithProtocols(container);
     }
     return container;
 }

src/NativeScript/ObjC/Constructor/ObjCConstructorBase.mm

@@ -169,7 +169,7 @@ static void writeAdapter(ExecState* execState, const JSValue& value, void* buffe
         const Metadata::InterfaceMeta* metadata = this->metadata();
 
         do {
-            std::vector<const Metadata::MethodMeta*> initializers = metadata->initializersWithProtcols();
+            std::vector<const Metadata::MethodMeta*> initializers = metadata->initializersWithProtocols();
             for (const Metadata::MethodMeta* method : initializers) {
                 if (method->isAvailableInClass(this->klass(), /*isStatic*/ false)) {
                     auto constructorWrapper = ObjCConstructorWrapper::create(vm, globalObject, globalObject->objCConstructorWrapperStructure(), this->_klass, method);
@@ -216,7 +216,7 @@ static JSValue getInitializerForSwiftStyleConstruction(ExecState* execState, Obj
     std::vector<const Metadata::MethodMeta*> initializers;
     initializers.reserve(16);
     do {
-        interface->initializersWithProtcols(initializers);
+        interface->initializersWithProtocols(initializers);
         for (const Metadata::MethodMeta* method : initializers) {
             if (strcmp(method->constructorTokens(), ctorMetadata.data()) == 0) {
                 result = method;

tests/TestFixtures/Api/TNSVersions.h

@@ -75,7 +75,23 @@ 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>
+
++ (void)staticMethodFromProtocolNeverAvailable;
+- (void)methodFromProtocolNeverAvailable;
+
+@end
+
+__attribute__((availability(ios, introduced = 1.0)))
+@protocol TNSProtocolAlwaysAvailable<NSObject>
+
++ (void)staticMethodFromProtocolAlwaysAvailable;
+- (void)methodFromProtocolAlwaysAvailable;
+
+@end
+
+@interface TNSInterfaceAlwaysAvailable : NSObject <TNSProtocolNeverAvailable, TNSProtocolAlwaysAvailable>
 @end
 
 __attribute__((availability(ios, introduced = MAX_AVAILABILITY)))

tests/TestFixtures/Api/TNSVersions.m

@@ -11,6 +11,22 @@
 #undef generateVersionImpl
 
 @implementation TNSInterfaceAlwaysAvailable
+
++ (void)staticMethodFromProtocolAlwaysAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+}
+
++ (void)staticMethodFromProtocolNeverAvailable {
+    TNSLog([NSString stringWithFormat:@"%@ called", NSStringFromSelector(_cmd)]);
+}
+
+- (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,21 @@ 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("Methods of a protocol which is unavailable should be skipped", function() {
+        expect(new TNSInterfaceAlwaysAvailable().methodFromProtocolNeverAvailable).toBeUndefined("TNSProtocolNeverAvailable methods should be skipped as it is unavailable");
+        expect(TNSInterfaceAlwaysAvailable.staticMethodFromProtocolNeverAvailable).toBeUndefined("TNSProtocolNeverAvailable static methods should be skipped as it is unavailable");
+    });
+
+    it("Methods of a protocol which is available should be present", function() {
+        const obj = new TNSInterfaceAlwaysAvailable();
+        expect(obj.methodFromProtocolAlwaysAvailable).toBeDefined("TNSProtocolAlwaysAvailable methods should be present as it is available");
+        obj.methodFromProtocolAlwaysAvailable();
+        expect(TNSGetOutput()).toBe("methodFromProtocolAlwaysAvailable called");
+       TNSClearOutput();
+       
+        expect(TNSInterfaceAlwaysAvailable.staticMethodFromProtocolAlwaysAvailable).toBeDefined("TNSProtocolAlwaysAvailable static methods should be present as it is available");
+        TNSInterfaceAlwaysAvailable.staticMethodFromProtocolAlwaysAvailable();
+        expect(TNSGetOutput()).toBe("staticMethodFromProtocolAlwaysAvailable called");
+    });
 });