Merge pull request #1246 from NativeScript/bektchiev/filter-metadata

feat(metadata-generator): Filter according to specified black/white lists

Author: mbektchiev

blacklist.mdg

@@ -0,0 +1 @@
+tests/TestRunner/blacklist.mdg

build/scripts/build-step-metadata-generator.py

@@ -37,6 +37,7 @@ def map_and_list(func, iterable):
 # process environment variables
 conf_build_dir = env("CONFIGURATION_BUILD_DIR")
 sdk_root = env("SDKROOT")
+src_root = env("SRCROOT")
 deployment_target_flag_name = env("DEPLOYMENT_TARGET_CLANG_FLAG_NAME")
 deployment_target = env(env("DEPLOYMENT_TARGET_CLANG_ENV_NAME"))
 std = env("GCC_C_LANGUAGE_STANDARD")
@@ -97,6 +98,14 @@ def generate_metadata(arch):
         generator_call.extend(["-output-yaml", current_yaml_output_folder])
         print("Generating debug metadata in: \"{}\"".format(current_yaml_output_folder))
 
+    whitelist_file_name = os.path.join(src_root, "whitelist.mdg")
+    if os.path.exists(whitelist_file_name):
+      generator_call.extend(["--whitelist-modules-file", whitelist_file_name])
+
+    blacklist_file_name = os.path.join(src_root, "blacklist.mdg")
+    if os.path.exists(blacklist_file_name):
+      generator_call.extend(["--blacklist-modules-file", blacklist_file_name])
+
     # clang arguments
     generator_call.extend(["Xclang",
                            "-isysroot", sdk_root,

src/NativeScript/CMakeLists.txt

@@ -120,7 +120,7 @@ set(HEADER_FILES
 set(SOURCE_FILES
     Calling/FFICache.cpp
     Calling/FFICall.cpp
-    Calling/FFICallPrototype.cpp
+    Calling/FFICallPrototype.mm
     Calling/CFunctionWrapper.mm
     Calling/FFIFunctionCallback.mm
     Calling/FunctionWrapper.mm
@@ -148,25 +148,25 @@ set(SOURCE_FILES
     Marshalling/FFIType.cpp
     Marshalling/FunctionReference/FunctionReferenceConstructor.cpp
     Marshalling/FunctionReference/FunctionReferenceInstance.cpp
-    Marshalling/FunctionReference/FunctionReferenceTypeConstructor.cpp
+    Marshalling/FunctionReference/FunctionReferenceTypeConstructor.mm
     Marshalling/FunctionReference/FunctionReferenceTypeInstance.cpp
     Marshalling/Fundamentals/FFINumericTypes.mm
     Marshalling/Fundamentals/FFIPrimitiveTypes.cpp
-    Marshalling/Pointer/PointerConstructor.cpp
+    Marshalling/Pointer/PointerConstructor.mm
     Marshalling/Pointer/PointerInstance.cpp
     Marshalling/Pointer/PointerPrototype.cpp
-    Marshalling/Record/RecordConstructor.cpp
+    Marshalling/Record/RecordConstructor.mm
     Marshalling/Record/RecordField.cpp
     Marshalling/Record/RecordInstance.cpp
     Marshalling/Record/RecordPrototype.cpp
     Marshalling/Record/RecordPrototypeFunctions.cpp
-    Marshalling/Reference/ReferenceConstructor.cpp
-    Marshalling/Reference/ReferenceInstance.cpp
+    Marshalling/Reference/ReferenceConstructor.mm
+    Marshalling/Reference/ReferenceInstance.mm
     Marshalling/Reference/ReferencePrototype.cpp
-    Marshalling/Reference/ReferenceTypeConstructor.cpp
+    Marshalling/Reference/ReferenceTypeConstructor.mm
     Marshalling/Reference/ReferenceTypeInstance.cpp
     Marshalling/Reference/IndexedRefTypeInstance.cpp
-    Marshalling/Reference/IndexedRefInstance.cpp
+    Marshalling/Reference/IndexedRefInstance.mm
     Marshalling/Reference/IndexedRefPrototype.cpp
     Marshalling/Reference/ExtVectorTypeInstance.cpp
     Metadata/Metadata.mm
@@ -175,7 +175,7 @@ set(SOURCE_FILES
     ObjC/Block/ObjCBlockCall.mm
     ObjC/Block/ObjCBlockCallback.mm
     ObjC/Block/ObjCBlockType.mm
-    ObjC/Block/ObjCBlockTypeConstructor.cpp
+    ObjC/Block/ObjCBlockTypeConstructor.mm
     ObjC/Constructor/ObjCConstructorBase.mm
     ObjC/Constructor/ObjCConstructorCall.mm
     ObjC/Constructor/ObjCConstructorDerived.cpp

src/NativeScript/Calling/FFICallPrototype.cpp

@@ -0,0 +1,61 @@
+//
+//  FFICallPrototype.cpp
+//  NativeScript
+//
+//  Created by Yavor Georgiev on 25.09.15.
+//  Copyright (c) 2015 Telerik. All rights reserved.
+//
+
+#include "FFICallPrototype.h"
+#include "FFICall.h"
+#include "FunctionWrapper.h"
+#include "JSErrors.h"
+#include <JavaScriptCore/interpreter/Interpreter.h>
+
+namespace NativeScript {
+using namespace JSC;
+
+const ClassInfo FFICallPrototype::s_info = { "FFIFunction", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(FFICallPrototype) };
+
+EncodedJSValue JSC_HOST_CALL FFICallPrototypeFuncAsync(ExecState*);
+
+void FFICallPrototype::finishCreation(VM& vm, JSGlobalObject* globalObject) {
+    Base::finishCreation(vm);
+    didBecomePrototype();
+
+    JSC_NATIVE_FUNCTION(Identifier::fromString(&vm, "async"), FFICallPrototypeFuncAsync, static_cast<unsigned>(PropertyAttribute::DontEnum), 0);
+}
+
+EncodedJSValue JSC_HOST_CALL FFICallPrototypeFuncAsync(ExecState* execState) {
+    NS_TRY {
+        auto call = jsCast<FunctionWrapper*>(execState->thisValue());
+        JSC::VM& vm = execState->vm();
+        auto scope = DECLARE_THROW_SCOPE(vm);
+
+        JSValue array = execState->argument(1);
+
+        MarkedArgumentBuffer applyArgs;
+        if (!array.isUndefinedOrNull()) {
+            if (!array.isObject())
+                return throwVMTypeError(execState, scope);
+            if (isJSArray(array)) {
+                if (asArray(array)->length() > JSC::maxArguments)
+                    return JSValue::encode(throwStackOverflowError(execState, scope));
+                asArray(array)->fillArgList(execState, applyArgs);
+            } else {
+                unsigned length = asObject(array)->get(execState, vm.propertyNames->length).toUInt32(execState);
+                if (length > JSC::maxArguments)
+                    return JSValue::encode(throwStackOverflowError(execState, scope));
+
+                for (unsigned i = 0; i < length; ++i)
+                    applyArgs.append(asObject(array)->get(execState, i));
+            }
+        }
+
+        return JSValue::encode(call->async(execState, execState->argument(0), applyArgs));
+    }
+    NS_CATCH_THROW_TO_JS(execState)
+
+    return JSValue::encode(jsUndefined());
+}
+} // namespace NativeScript

src/NativeScript/Calling/FFICallPrototype.mm

@@ -9,6 +9,7 @@
 #include "FFIFunctionCallback.h"
 #include "FFICallbackInlines.h"
 #include "FunctionReferenceTypeInstance.h"
+#include "JSErrors.h"
 
 namespace NativeScript {
 using namespace JSC;
@@ -17,18 +18,21 @@
 
 void FFIFunctionCallback::ffiClosureCallback(void* retValue, void** argValues, void* userData) {
     FFIFunctionCallback* functionCallback = reinterpret_cast<FFIFunctionCallback*>(userData);
+    NS_TRY {
 
-    JSC::VM& vm = functionCallback->execState()->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
+        JSC::VM& vm = functionCallback->execState()->vm();
+        auto scope = DECLARE_THROW_SCOPE(vm);
 
-    MarkedArgumentBuffer arguments;
-    functionCallback->marshallArguments(argValues, arguments, functionCallback);
-    if (scope.exception()) {
-        return;
-    }
+        MarkedArgumentBuffer arguments;
+        functionCallback->marshallArguments(argValues, arguments, functionCallback);
+        if (scope.exception()) {
+            return;
+        }
 
-    ASSERT(!arguments.hasOverflowed());
-    functionCallback->callFunction(functionCallback->execState()->globalThisValue(), arguments, retValue);
+        ASSERT(!arguments.hasOverflowed());
+        functionCallback->callFunction(functionCallback->execState()->globalThisValue(), arguments, retValue);
+    }
+    NS_CATCH_THROW_TO_JS(functionCallback->execState());
 }
 
 void FFIFunctionCallback::finishCreation(VM& vm, JSGlobalObject* globalObject, JSCell* function, FunctionReferenceTypeInstance* functionReferenceType) {

src/NativeScript/Calling/FFIFunctionCallback.mm

@@ -8,6 +8,7 @@
 
 #include "FFICache.h"
 #include "FFICall.h"
+#include "JSErrors.h"
 #include "ObjCTypes.h"
 #include <JavaScriptCore/JSObjectRef.h>
 #include <JavaScriptCore/JSPromiseDeferred.h>
@@ -70,45 +71,50 @@
 }
 
 EncodedJSValue JSC_HOST_CALL FunctionWrapper::call(ExecState* execState) {
-    FunctionWrapper* call = jsCast<FunctionWrapper*>(execState->callee().asCell());
+    NS_TRY {
+        FunctionWrapper* call = jsCast<FunctionWrapper*>(execState->callee().asCell());
 
-    const std::unique_ptr<FFICall>& c = Metadata::getProperFunctionFromContainer<std::unique_ptr<FFICall>>(call->functionsContainer(), execState->argumentCount(), [](const std::unique_ptr<FFICall>& fficall) { return static_cast<int>(fficall.get()->parametersCount()); });
-    FFICall* callee = c.get();
+        const std::unique_ptr<FFICall>& c = Metadata::getProperFunctionFromContainer<std::unique_ptr<FFICall>>(call->functionsContainer(), execState->argumentCount(), [](const std::unique_ptr<FFICall>& fficall) { return static_cast<int>(fficall.get()->parametersCount()); });
+        FFICall* callee = c.get();
 
-    ASSERT(callee);
+        ASSERT(callee);
 
-    FFICall::Invocation invocation(callee);
-    ReleasePoolHolder releasePoolHolder(execState);
-
-    JSC::VM& vm = execState->vm();
+        FFICall::Invocation invocation(callee);
+        ReleasePoolHolder releasePoolHolder(execState);
 
-    [[TNSRuntime current] tryCollectGarbage];
+        JSC::VM& vm = execState->vm();
 
-    auto scope = DECLARE_THROW_SCOPE(vm);
+        [[TNSRuntime current] tryCollectGarbage];
 
-    callee->preCall(execState, invocation);
-    if (scope.exception()) {
-        return JSValue::encode(scope.exception());
-    }
-
-    @try {
-        {
-            JSLock::DropAllLocks locksDropper(execState);
-            ffi_call(callee->cif()->get(), FFI_FN(invocation.function), invocation.resultBuffer(), reinterpret_cast<void**>(invocation._buffer + callee->argsArrayOffset()));
-        }
+        auto scope = DECLARE_THROW_SCOPE(vm);
 
+        callee->preCall(execState, invocation);
         if (scope.exception()) {
-            // in the ffi call the native method could reach javascript code throwing an error we don't need the code below to execute
             return JSValue::encode(scope.exception());
         }
 
-        JSValue result = callee->returnType().read(execState, invocation._buffer + callee->returnOffset(), callee->returnTypeCell().get());
+        @try {
+            {
+                JSLock::DropAllLocks locksDropper(execState);
+                ffi_call(callee->cif()->get(), FFI_FN(invocation.function), invocation.resultBuffer(), reinterpret_cast<void**>(invocation._buffer + callee->argsArrayOffset()));
+            }
+
+            if (scope.exception()) {
+                // in the ffi call the native method could reach javascript code throwing an error we don't need the code below to execute
+                return JSValue::encode(scope.exception());
+            }
 
-        callee->postCall(execState, invocation);
-        return JSValue::encode(result);
-    } @catch (NSException* exception) {
-        return throwVMError(execState, scope, createErrorFromNSException([TNSRuntime current], execState, exception));
+            JSValue result = callee->returnType().read(execState, invocation._buffer + callee->returnOffset(), callee->returnTypeCell().get());
+
+            callee->postCall(execState, invocation);
+            return JSValue::encode(result);
+        } @catch (NSException* exception) {
+            return throwVMError(execState, scope, createErrorFromNSException([TNSRuntime current], execState, exception));
+        }
     }
+    NS_CATCH_THROW_TO_JS(execState)
+
+    return JSValue::encode(jsUndefined());
 }
 
 JSObject* FunctionWrapper::async(ExecState* execState, JSValue thisValue, const ArgList& arguments) {