fix(runtime): Filter members which are unavailable in the current SDK

* Add `isImplementedInClass` and `isAvailableInClass` methods in
`PropertyMeta` and `MethodMeta` which additionally check whether a Class
instance supports a given optional method
* Use `isAvailableInClass` instead of `isAvailable` in `getOwnPropertySlot` of
`ObjCPrototype`, `ObjCConstructorBase`, `ObjCConstructorNative`
* Add `findInterfaceMeta` function with fallback to base interface
if the desired one is unavailable in the current SDK version
* Add `encodeVersion` `getMajorVersion` and `getMinorVersion` helpers
* Remove hacky patch from `ObjCMethodWrapper::preInvocation` which
fixed the symptoms of #978 but not its root cause
* Modify fixtures and add test cases for methods availability in
`InheritanceTests.js`
* Add test case for unavailable base class

refs #1085

Author: mbektchiev

src/NativeScript/GlobalObject.mm

@@ -89,7 +89,7 @@
 
 static Strong<ObjCProtocolWrapper> createProtocolWrapper(GlobalObject* globalObject, const ProtocolMeta* protocolMeta, Protocol* aProtocol) {
     Structure* prototypeStructure = ObjCPrototype::createStructure(globalObject->vm(), globalObject, globalObject->objectPrototype());
-    auto prototype = ObjCPrototype::create(globalObject->vm(), globalObject, prototypeStructure, protocolMeta);
+    auto prototype = ObjCPrototype::create(globalObject->vm(), globalObject, prototypeStructure, protocolMeta, nullptr);
     Structure* protocolWrapperStructure = ObjCProtocolWrapper::createStructure(globalObject->vm(), globalObject, globalObject->objectPrototype());
     auto protocolWrapper = ObjCProtocolWrapper::create(globalObject->vm(), protocolWrapperStructure, prototype.get(), protocolMeta, aProtocol);
     prototype->materializeProperties(globalObject->vm(), globalObject);

src/NativeScript/Metadata/Metadata.h

@@ -46,6 +46,18 @@ static const V& getProperFunctionFromContainer(const std::vector<V>& container,
     return *callee;
 }
 
+inline UInt8 encodeVersion(UInt8 majorVersion, UInt8 minorVersion) {
+    return (majorVersion << 3) | minorVersion;
+}
+
+inline UInt8 getMajorVersion(UInt8 encodedVersion) {
+    return encodedVersion >> 3;
+}
+
+inline UInt8 getMinorVersion(UInt8 encodedVersion) {
+    return encodedVersion & 0b111;
+}
+
 // Bit indices in flags section
 enum MetaFlags {
     HasName = 7,
@@ -126,6 +138,7 @@ enum BinaryTypeEncodingType : Byte {
 template <typename T>
 struct PtrTo;
 struct Meta;
+struct InterfaceMeta;
 struct ProtocolMeta;
 struct ModuleMeta;
 struct LibraryMeta;
@@ -273,6 +286,12 @@ struct GlobalTable {
 
     ArrayOfPtrTo<ArrayOfPtrTo<Meta>> buckets;
 
+    const InterfaceMeta* findInterfaceMeta(WTF::StringImpl* identifier) const;
+
+    const InterfaceMeta* findInterfaceMeta(const char* identifierString) const;
+
+    const InterfaceMeta* findInterfaceMeta(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;
@@ -667,6 +686,24 @@ struct MethodMeta : MemberMeta {
     const char* constructorTokens() const {
         return this->_constructorTokens.valuePtr();
     }
+
+    bool isImplementedInClass(Class klass, bool isStatic) const {
+        // Required methods are treated as implemented
+        if (!this->isOptional()) {
+            return true;
+        }
+
+        // class can be null for Protocol prototypes, treat all members in a protocol as implemented
+        if (klass == nullptr) {
+            return true;
+        }
+
+        return nullptr != (isStatic ? class_getClassMethod(klass, this->selector()) : class_getInstanceMethod(klass, this->selector()));
+    }
+
+    bool isAvailableInClass(Class klass, bool isStatic) const {
+        return this->isAvailable() && this->isImplementedInClass(klass, isStatic);
+    }
 };
 
 std::unordered_map<std::string, std::vector<const MemberMeta*>> getMetasByJSNames(std::vector<const MemberMeta*> methods);
@@ -691,6 +728,16 @@ struct PropertyMeta : MemberMeta {
     const MethodMeta* setter() const {
         return (this->hasSetter()) ? (this->hasGetter() ? method2.valuePtr() : method1.valuePtr()) : nullptr;
     }
+
+    bool isImplementedInClass(Class klass, bool isStatic) const {
+        bool getterAvailable = this->hasGetter() && this->getter()->isImplementedInClass(klass, isStatic);
+        bool setterAvailable = this->hasSetter() && this->setter()->isImplementedInClass(klass, isStatic);
+        return !this->isOptional() || getterAvailable || setterAvailable;
+    }
+
+    bool isAvailableInClass(Class klass, bool isStatic) const {
+        return this->isAvailable() && this->isImplementedInClass(klass, isStatic);
+    }
 };
 
 struct BaseClassMeta : Meta {
@@ -843,9 +890,10 @@ struct InterfaceMeta : BaseClassMeta {
 
     const InterfaceMeta* baseMeta() const {
         if (this->baseName() != nullptr) {
-            const Meta* baseMeta = MetaFile::instance()->globalTable()->findMeta(this->baseName());
-            return baseMeta->type() == MetaType::Interface ? reinterpret_cast<const InterfaceMeta*>(baseMeta) : nullptr;
+            const InterfaceMeta* baseMeta = MetaFile::instance()->globalTable()->findInterfaceMeta(this->baseName());
+            return baseMeta;
         }
+
         return nullptr;
     }
 };

src/NativeScript/Metadata/Metadata.mm

@@ -28,9 +28,7 @@ static UInt8 getSystemVersion() {
     UInt8 majorVersion = (UInt8)[versionTokens[0] intValue];
     UInt8 minorVersion = (UInt8)[versionTokens[1] intValue];
 
-    iosVersion = (majorVersion << 3) | minorVersion;
-
-    return iosVersion;
+    return encodeVersion(majorVersion, minorVersion);
 }
 std::unordered_map<std::string, std::vector<const MemberMeta*>> getMetasByJSNames(std::vector<const MemberMeta*> members) {
     std::unordered_map<std::string, std::vector<const MemberMeta*>> result;
@@ -45,6 +43,42 @@ static int compareIdentifiers(const char* nullTerminated, const char* notNullTer
     return (result == 0) ? strlen(nullTerminated) - length : result;
 }
 
+const InterfaceMeta* GlobalTable::findInterfaceMeta(WTF::StringImpl* identifier) const {
+    return this->findInterfaceMeta(reinterpret_cast<const char*>(identifier->characters8()), identifier->length(), identifier->hash());
+}
+
+const InterfaceMeta* GlobalTable::findInterfaceMeta(const char* identifierString) const {
+    unsigned hash = WTF::StringHasher::computeHashAndMaskTop8Bits<LChar>(reinterpret_cast<const LChar*>(identifierString));
+    return this->findInterfaceMeta(identifierString, strlen(identifierString), hash);
+}
+
+const InterfaceMeta* GlobalTable::findInterfaceMeta(const char* identifierString, size_t length, unsigned hash) const {
+    const Meta* meta = MetaFile::instance()->globalTable()->findMeta(identifierString, length, hash, /*onlyIfAvailable*/ false);
+    if (meta == nullptr) {
+        return nullptr;
+    }
+
+    assert(meta->type() == MetaType::Interface);
+    if (meta->type() != MetaType::Interface) {
+        return nullptr;
+    }
+
+    const InterfaceMeta* interfaceMeta = static_cast<const InterfaceMeta*>(meta);
+    if (interfaceMeta->isAvailable()) {
+        return interfaceMeta;
+    } else {
+        const char* baseName = static_cast<const InterfaceMeta*>(interfaceMeta)->baseName();
+
+        NSLog(@"** \"%s\" introduced in iOS SDK %d.%d is currently unavailable, attempting to load its base: \"%s\". **",
+              std::string(identifierString, length).c_str(),
+              getMajorVersion(interfaceMeta->introducedIn()),
+              getMinorVersion(interfaceMeta->introducedIn()),
+              baseName);
+
+        return this->findInterfaceMeta(baseName);
+    }
+}
+
 const Meta* GlobalTable::findMeta(WTF::StringImpl* identifier, bool onlyIfAvailable) const {
     return this->findMeta(reinterpret_cast<const char*>(identifier->characters8()), identifier->length(), identifier->hash(), onlyIfAvailable);
 }

src/NativeScript/ObjC/Constructor/ObjCConstructorBase.mm

@@ -171,7 +171,7 @@ static void writeAdapter(ExecState* execState, const JSValue& value, void* buffe
         do {
             std::vector<const Metadata::MethodMeta*> initializers = metadata->initializersWithProtcols();
             for (const Metadata::MethodMeta* method : initializers) {
-                if (method->isAvailable()) {
+                if (method->isAvailableInClass(this->klass(), /*isStatic*/ false)) {
                     auto constructorWrapper = ObjCConstructorWrapper::create(vm, globalObject, globalObject->objCConstructorWrapperStructure(), this->_klass, method);
                     this->_initializers.append(WriteBarrier<ObjCConstructorWrapper>(vm, this, constructorWrapper.get()));
                 }
@@ -218,7 +218,7 @@ static JSValue getInitializerForSwiftStyleConstruction(ExecState* execState, Obj
     do {
         interface->initializersWithProtcols(initializers);
         for (const Metadata::MethodMeta* method : initializers) {
-            if (method->isAvailable() && strcmp(method->constructorTokens(), ctorMetadata.data()) == 0) {
+            if (strcmp(method->constructorTokens(), ctorMetadata.data()) == 0) {
                 result = method;
                 break;
             }

src/NativeScript/ObjC/Constructor/ObjCConstructorNative.mm

@@ -93,19 +93,22 @@
 
         for (ArrayOfPtrTo<MethodMeta>::iterator it = baseClassMeta->staticMethods->begin(); it != baseClassMeta->staticMethods->end(); it++) {
             const MethodMeta* meta = (*it).valuePtr();
-            if (meta->isAvailable())
+            if (meta->isAvailableInClass(constructor->klass(), /*isStatic*/ true)) {
                 propertyNames.add(Identifier::fromString(execState, meta->jsName()));
+            }
         }
 
         for (Metadata::ArrayOfPtrTo<PropertyMeta>::iterator it = baseClassMeta->staticProps->begin(); it != baseClassMeta->staticProps->end(); it++) {
-            if ((*it)->isAvailable())
+            if ((*it)->isAvailableInClass(constructor->klass(), /*isStatic*/ true)) {
                 propertyNames.add(Identifier::fromString(execState, (*it)->jsName()));
+            }
         }
 
         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());
-            if (protocolMeta != nullptr)
+            if (protocolMeta != nullptr) {
                 baseClassMetaStack.push_back(protocolMeta);
+            }
         }
     }
 
@@ -116,11 +119,11 @@
     std::vector<const PropertyMeta*> properties = this->metadata()->staticPropertiesWithProtocols();
 
     for (const PropertyMeta* propertyMeta : properties) {
-        if (propertyMeta->isAvailable()) {
+        if (propertyMeta->isAvailableInClass(this->klass(), /*isStatic*/ true)) {
             SymbolLoader::instance().ensureModule(propertyMeta->topLevelModule());
 
-            const MethodMeta* getterMeta = (propertyMeta->getter() != nullptr && propertyMeta->getter()->isAvailable()) ? propertyMeta->getter() : nullptr;
-            const MethodMeta* setterMeta = (propertyMeta->setter() != nullptr && propertyMeta->setter()->isAvailable()) ? propertyMeta->setter() : nullptr;
+            const MethodMeta* getterMeta = (propertyMeta->getter() != nullptr && propertyMeta->getter()->isAvailableInClass(this->klass(), /*isStatic*/ true)) ? propertyMeta->getter() : nullptr;
+            const MethodMeta* setterMeta = (propertyMeta->setter() != nullptr && propertyMeta->setter()->isAvailableInClass(this->klass(), /*isStatic*/ true)) ? propertyMeta->setter() : nullptr;
 
             PropertyDescriptor descriptor;
             Strong<ObjCMethodWrapper> getter;

src/NativeScript/ObjC/ObjCMethodCall.mm

@@ -146,12 +146,7 @@ static bool isJavaScriptDerived(JSC::JSValue value) {
         bool isInstance = !class_isMetaClass(object_getClass(target));
         NSLog(@"> %@[%@ %@]", isInstance ? @"-" : @"+", NSStringFromClass(object_getClass(target)), NSStringFromSelector(call->_selector));
 #endif
-        if (call->_isOptional && ![target respondsToSelector:call->_selector]) {
-            // Unimplemented optional method: Silently perform a dummy call to nil object
-            invocation.setArgument(0, nil);
-        } else {
-            invocation.setArgument(0, target);
-        }
+        invocation.setArgument(0, target);
         invocation.setArgument(1, call->_selector);
         invocation.function = call->_msgSend;
     }

src/NativeScript/ObjC/ObjCPrototype.h

@@ -23,8 +23,8 @@ class ObjCPrototype : public JSC::JSDestructibleObject {
 
     static const unsigned StructureFlags;
 
-    static JSC::Strong<ObjCPrototype> create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, const Metadata::BaseClassMeta* metadata) {
-        JSC::Strong<ObjCPrototype> prototype(vm, new (NotNull, JSC::allocateCell<ObjCPrototype>(globalObject->vm().heap)) ObjCPrototype(globalObject->vm(), structure));
+    static JSC::Strong<ObjCPrototype> create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, const Metadata::BaseClassMeta* metadata, Class klass) {
+        JSC::Strong<ObjCPrototype> prototype(vm, new (NotNull, JSC::allocateCell<ObjCPrototype>(globalObject->vm().heap)) ObjCPrototype(globalObject->vm(), structure, klass));
         prototype->finishCreation(vm, globalObject, metadata);
         return prototype;
     }
@@ -39,13 +39,18 @@ class ObjCPrototype : public JSC::JSDestructibleObject {
 
     void materializeProperties(JSC::VM& vm, GlobalObject* globalObject);
 
-    const Metadata::BaseClassMeta* metadata() {
+    const Metadata::BaseClassMeta* metadata() const {
         return this->_metadata;
     }
 
+    Class klass() const {
+        return this->_klass;
+    }
+
 private:
-    ObjCPrototype(JSC::VM& vm, JSC::Structure* structure)
-        : Base(vm, structure) {
+    ObjCPrototype(JSC::VM& vm, JSC::Structure* structure, Class klass)
+        : Base(vm, structure)
+        , _klass(klass) {
     }
 
     void finishCreation(JSC::VM&, JSC::JSGlobalObject*, const Metadata::BaseClassMeta*);
@@ -59,6 +64,8 @@ class ObjCPrototype : public JSC::JSDestructibleObject {
     static void getOwnPropertyNames(JSC::JSObject*, JSC::ExecState*, JSC::PropertyNameArray&, JSC::EnumerationMode);
 
     const Metadata::BaseClassMeta* _metadata;
+
+    Class _klass;
 };
 } // namespace NativeScript
 

src/NativeScript/ObjC/ObjCPrototype.mm

@@ -150,6 +150,7 @@ static EncodedJSValue JSC_HOST_CALL getIterator(ExecState* execState) {
 
 void ObjCPrototype::getOwnPropertyNames(JSObject* object, ExecState* execState, PropertyNameArray& propertyNames, EnumerationMode enumerationMode) {
     ObjCPrototype* prototype = jsCast<ObjCPrototype*>(object);
+    Class klass = prototype->klass();
 
     std::vector<const BaseClassMeta*> baseClassMetaStack;
     baseClassMetaStack.push_back(prototype->_metadata);
@@ -159,12 +160,12 @@ static EncodedJSValue JSC_HOST_CALL getIterator(ExecState* execState) {
         baseClassMetaStack.pop_back();
 
         for (Metadata::ArrayOfPtrTo<MethodMeta>::iterator it = baseClassMeta->instanceMethods->begin(); it != baseClassMeta->instanceMethods->end(); it++) {
-            if ((*it)->isAvailable())
+            if ((*it)->isAvailableInClass(klass, /*isStatic*/ false))
                 propertyNames.add(Identifier::fromString(execState, (*it)->jsName()));
         }
 
         for (Metadata::ArrayOfPtrTo<PropertyMeta>::iterator it = baseClassMeta->instanceProps->begin(); it != baseClassMeta->instanceProps->end(); it++) {
-            if ((*it)->isAvailable())
+            if ((*it)->isAvailableInClass(prototype->klass(), /*isStatic*/ false))
                 propertyNames.add(Identifier::fromString(execState, (*it)->jsName()));
         }
 

src/NativeScript/TypeFactory.mm

@@ -247,7 +247,7 @@
 
     VM& vm = globalObject->vm();
 
-    const InterfaceMeta* metadata = static_cast<const InterfaceMeta*>(MetaFile::instance()->globalTable()->findMeta(klassName.impl()));
+    const InterfaceMeta* metadata = MetaFile::instance()->globalTable()->findInterfaceMeta(klassName.impl());
     Class klass = Nil;
 
     if (metadata) {
@@ -289,7 +289,7 @@
     }
 
     Structure* prototypeStructure = ObjCPrototype::createStructure(vm, globalObject, parentPrototype);
-    auto prototype = ObjCPrototype::create(vm, globalObject, prototypeStructure, metadata);
+    auto prototype = ObjCPrototype::create(vm, globalObject, prototypeStructure, metadata, klass);
 
     Structure* constructorStructure = ObjCConstructorNative::createStructure(vm, globalObject, parentConstructor);
     auto constructor = ObjCConstructorNative::create(vm, globalObject, constructorStructure, prototype.get(), klass);