node-gtk 0.8.1 → 0.11.0

package/src/function.cc

@@ -1,4 +1,3 @@
-
 #include <string.h>
 #include <girffi.h>
 
@@ -44,8 +43,8 @@ static int GetV8ArrayLength (Local<Value> value) {
     else if (value->IsNull() || value->IsUndefined())
         return 0;
 
-    printf("%s\n", *Nan::Utf8String(TO_STRING (value)));
-    g_assert_not_reached();
+    ERROR("Could not determine array length for value %s",
+            *Nan::Utf8String(TO_STRING (value)));
 }
 
 static void* AllocateArgument (GIBaseInfo *arg_info) {
@@ -56,7 +55,7 @@ static void* AllocateArgument (GIBaseInfo *arg_info) {
 
     GIBaseInfo* base_info = g_type_info_get_interface (&arg_type);
     size_t size = Boxed::GetSize (base_info);
-    void* pointer = calloc(1, size);
+    void* pointer = g_malloc0(size);
 
     g_base_info_unref(base_info);
     return pointer;
@@ -106,7 +105,196 @@ bool IsDestroyNotify (GIBaseInfo *info) {
 
 
 /**
- * Calls a function
+ * The constructor just stores the GIBaseInfo ref. The rest of the
+ * initialization is done in FunctionInfo::Init, lazily.
+ */
+FunctionInfo::FunctionInfo (GIBaseInfo* gi_info) {
+    info = g_base_info_ref (gi_info);
+    call_parameters = nullptr;
+}
+
+FunctionInfo::~FunctionInfo () {
+    g_base_info_unref (info);
+
+    if (call_parameters != nullptr) {
+        g_function_invoker_destroy (&invoker);
+        delete[] call_parameters;
+    }
+}
+
+/**
+ * Initializes the parameters metadata (number, directionality, type) and caches it
+ */
+bool FunctionInfo::Init() {
+
+    if (call_parameters != nullptr)
+        return true;
+
+    g_function_info_prep_invoker (info, &invoker, NULL);
+
+    is_method = IsMethod(info);
+    can_throw = g_callable_info_can_throw_gerror (info);
+
+    n_callable_args = g_callable_info_get_n_args (info);
+    n_total_args = n_callable_args;
+    n_out_args = 0;
+    n_in_args = 0;
+
+    if (is_method)
+        n_total_args++;
+
+    if (can_throw)
+        n_total_args++;
+
+    call_parameters = new Parameter[n_callable_args]();
+
+    /*
+     * Examine load parameter types and count arguments
+     */
+
+    for (int i = 0; i < n_callable_args; i++) {
+        GIArgInfo arg_info;
+        GITypeInfo type_info;
+        g_callable_info_load_arg ((GICallableInfo *) info, i, &arg_info);
+        g_arg_info_load_type (&arg_info, &type_info);
+
+        bool may_be_null = g_arg_info_may_be_null (&arg_info);
+        GIDirection direction = g_arg_info_get_direction (&arg_info);
+        GITypeTag tag = g_type_info_get_tag(&type_info);
+
+        call_parameters[i].direction = direction;
+
+        if (call_parameters[i].type == ParameterType::kSKIP)
+            continue;
+
+        // If there is an array length, this is an array
+        int length_i = g_type_info_get_array_length (&type_info);
+        if (tag == GI_TYPE_TAG_ARRAY && length_i >= 0) {
+            call_parameters[i].type        = ParameterType::kARRAY;
+            call_parameters[length_i].type = ParameterType::kSKIP;
+
+            // If array length came before, we need to remove it from args count
+
+            if (IsDirectionIn(call_parameters[length_i].direction) && length_i < i)
+                n_in_args--;
+
+            if (IsDirectionOut(call_parameters[length_i].direction) && length_i < i)
+                n_out_args--;
+
+        } else if (tag == GI_TYPE_TAG_INTERFACE) {
+
+            GIBaseInfo* interface_info = g_type_info_get_interface(&type_info);
+            GIInfoType  interface_type = g_base_info_get_type(interface_info);
+
+            if (interface_type == GI_INFO_TYPE_CALLBACK) {
+                if (IsDestroyNotify(interface_info)) {
+                    /* Skip GDestroyNotify if they appear before the respective callback */
+                    call_parameters[i].type = ParameterType::kSKIP;
+                } else {
+                    call_parameters[i].type = ParameterType::kCALLBACK;
+
+                    int destroy_i = g_arg_info_get_destroy(&arg_info);
+                    int closure_i = g_arg_info_get_closure(&arg_info);
+
+                    if (destroy_i >= 0 && closure_i < 0) {
+                        Throw::UnsupportedCallback (info);
+                        g_base_info_unref(interface_info);
+                        return false;
+                    }
+
+                    if (destroy_i >= 0 && destroy_i < n_callable_args)
+                        call_parameters[destroy_i].type = ParameterType::kSKIP;
+
+                    if (closure_i >= 0 && closure_i < n_callable_args)
+                        call_parameters[closure_i].type = ParameterType::kSKIP;
+
+                    if (destroy_i < i) {
+                        if (IsDirectionIn(call_parameters[destroy_i].direction))
+                            n_in_args--;
+                        if (IsDirectionOut(call_parameters[destroy_i].direction))
+                            n_out_args--;
+                    }
+
+                    if (closure_i < i) {
+                        if (IsDirectionIn(call_parameters[closure_i].direction))
+                            n_in_args--;
+                        if (IsDirectionOut(call_parameters[closure_i].direction))
+                            n_out_args--;
+                    }
+                }
+            }
+
+            g_base_info_unref(interface_info);
+        }
+
+        if (IsDirectionIn(call_parameters[i].direction) && !may_be_null)
+            n_in_args++;
+
+        if (IsDirectionOut(call_parameters[i].direction))
+            n_out_args++;
+
+    }
+
+    /*
+     * Examine return type
+     */
+
+    GITypeInfo return_type;
+    g_callable_info_load_return_type(info, &return_type);
+    int return_length_i = g_type_info_get_array_length(&return_type);
+
+    if (return_length_i != -1)
+        n_out_args--;
+
+    if (!ShouldSkipReturn(info, &return_type))
+        n_out_args++;
+
+    return true;
+}
+
+/**
+ * Type checks the JS arguments, throwing an error.
+ * @returns true if types match
+ */
+bool FunctionInfo::TypeCheck (const Nan::FunctionCallbackInfo<Value> &arguments) {
+
+    if (arguments.Length() < n_in_args) {
+        Throw::NotEnoughArguments(n_in_args, arguments.Length());
+        return false;
+    }
+
+    /*
+     * Type check every IN-argument that is not skipped
+     */
+
+    for (int in_arg = 0, i = 0; i < n_callable_args; i++) {
+        Parameter &param = call_parameters[i];
+
+        if (param.type == ParameterType::kSKIP)
+            continue;
+
+        GIArgInfo arg_info;
+        g_callable_info_load_arg (info, i, &arg_info);
+        GIDirection direction = g_arg_info_get_direction (&arg_info);
+
+        if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
+            GITypeInfo type_info;
+            g_arg_info_load_type (&arg_info, &type_info);
+            bool may_be_null = g_arg_info_may_be_null (&arg_info);
+
+            if (!CanConvertV8ToGIArgument(&type_info, arguments[in_arg], may_be_null)) {
+                Throw::InvalidType(&arg_info, &type_info, arguments[in_arg]);
+                return false;
+            }
+            in_arg++;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Calls a C function from JS arguments
  * @param func the function info
  * @param info JS call informations
  * @param return_value (out, nullable) the C return value
@@ -119,19 +307,12 @@ Local<Value> FunctionCall (
         GIArgument *return_value,
         GError **error
     ) {
-    /* FIXME(return_value is never use) */
 
     Local<Value> jsReturnValue;
     GIBaseInfo *gi_info = func->info; // do-not-free
     bool use_return_value = return_value != NULL;
     bool use_error = error != NULL;
 
-    // bool debug_mode = strcmp(g_base_info_get_name(gi_info), "parse") == 0;
-    bool debug_mode = false;
-
-    if (debug_mode)
-        print_callable_info(gi_info);
-
     if (!func->Init())
         return jsReturnValue;
 
@@ -143,7 +324,12 @@ Local<Value> FunctionCall (
      * and for error, if it can throw
      */
 
-    GIArgument total_arg_values[func->n_total_args];
+    #ifndef __linux__
+        GIArgument *total_arg_values = new GIArgument[func->n_total_args]();
+    #else
+        GIArgument total_arg_values[func->n_total_args];
+    #endif
+
     GIArgument *callable_arg_values;
     GError *error_stack = nullptr;
 
@@ -158,7 +344,6 @@ Local<Value> FunctionCall (
     if (func->can_throw)
         callable_arg_values[func->n_callable_args].v_pointer = error != NULL ? error : &error_stack;
 
-
     /*
      * Second, allocate OUT-arguments and fill IN-arguments
      */
@@ -166,7 +351,7 @@ Local<Value> FunctionCall (
     for (int in_arg = 0, i = 0; i < func->n_callable_args; i++) {
         Parameter& param = func->call_parameters[i];
 
-        if (param.type == ParameterType::SKIP)
+        if (param.type == ParameterType::kSKIP)
             continue;
 
         GIArgInfo arg_info;
@@ -175,7 +360,7 @@ Local<Value> FunctionCall (
         g_arg_info_load_type (&arg_info, &type_info);
         GIDirection direction = g_arg_info_get_direction (&arg_info);
 
-        if (param.type == ParameterType::ARRAY) {
+        if (param.type == ParameterType::kARRAY) {
             GIArgInfo  array_length_arg;
             GITypeInfo array_length_type;
 
@@ -201,8 +386,7 @@ Local<Value> FunctionCall (
                 callable_arg_values[length_i].v_pointer = &len_param.data;
             }
         }
-        else if (param.type == ParameterType::CALLBACK) {
-            // GIScopeType scope = g_arg_info_get_scope(&arg_info);
+        else if (param.type == ParameterType::kCALLBACK) {
             Callback *callback;
             ffi_closure *closure;
 
@@ -221,12 +405,12 @@ Local<Value> FunctionCall (
             int closure_i = g_arg_info_get_closure(&arg_info);
 
             if (destroy_i >= 0) {
-                g_assert (func->call_parameters[destroy_i].type == ParameterType::SKIP);
+                g_assert (func->call_parameters[destroy_i].type == ParameterType::kSKIP);
                 callable_arg_values[destroy_i].v_pointer = callback ? (void*) Callback::DestroyNotify : NULL;
             }
 
             if (closure_i >= 0) {
-                g_assert (func->call_parameters[closure_i].type == ParameterType::SKIP);
+                g_assert (func->call_parameters[closure_i].type == ParameterType::kSKIP);
                 callable_arg_values[closure_i].v_pointer = callback;
             }
 
@@ -245,7 +429,7 @@ Local<Value> FunctionCall (
         else /* (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) */ {
 
             // Callback GIArgument is filled above, for the rest...
-            if (param.type != ParameterType::CALLBACK) {
+            if (param.type != ParameterType::kCALLBACK) {
 
                 // FIXME(handle failure here)
                 FillArgument(&arg_info, &callable_arg_values[i], info[in_arg]);
@@ -267,16 +451,24 @@ Local<Value> FunctionCall (
      * Third, make the actual ffi_call
      */
 
-    void *ffi_args[func->n_total_args];
-    for (int i = 0; i < func->n_total_args; i++)
-        ffi_args[i] = &total_arg_values[i];
+    #ifndef __linux__
+        void **ffi_args = new void*[func->n_total_args]();
+    #else
+        void *ffi_args[func->n_total_args];
+    #endif
 
+    for (int i = 0; i < func->n_total_args; i++)
+        ffi_args[i] = (void *)&total_arg_values[i];
 
-    GIArgument return_value_stack;
+    GIArgument return_value_stack = {0};
 
     ffi_call (&func->invoker.cif, FFI_FN (func->invoker.native_address),
               use_return_value ? return_value : &return_value_stack, ffi_args);
 
+    #ifndef __linux__
+        delete[] ffi_args;
+    #endif
+
 
     /*
      * Fourth, convert the return value & OUT-arguments back to JS
@@ -326,13 +518,13 @@ Local<Value> FunctionCall (
         GIDirection direction = g_arg_info_get_direction (&arg_info);
         GITransfer transfer   = g_arg_info_get_ownership_transfer (&arg_info);
 
-        if (param.type == ParameterType::ARRAY) {
+        if (param.type == ParameterType::kARRAY) {
             if (direction == GI_DIRECTION_INOUT || direction == GI_DIRECTION_OUT)
                 FreeGIArgumentArray (&arg_type, (GIArgument*)arg_value.v_pointer, transfer, direction, param.length);
             else
                 FreeGIArgumentArray (&arg_type, &arg_value, transfer, direction, param.length);
         }
-        else if (param.type == ParameterType::CALLBACK) {
+        else if (param.type == ParameterType::kCALLBACK) {
             Callback *callback = static_cast<Callback*>(func->call_parameters[i].data.v_pointer);
 
             g_assert(direction == GI_DIRECTION_IN);
@@ -349,198 +541,13 @@ Local<Value> FunctionCall (
         }
     }
 
-    return jsReturnValue;
-}
-
-
-/**
- * The constructor just stores the GIBaseInfo ref. The rest of the
- * initialization is done in FunctionInfo::Init, lazily.
- */
-FunctionInfo::FunctionInfo (GIBaseInfo* gi_info) {
-    info = g_base_info_ref (gi_info);
-    call_parameters = nullptr;
-}
-
-FunctionInfo::~FunctionInfo () {
-    g_base_info_unref (info);
-
-    if (call_parameters != nullptr) {
-        g_function_invoker_destroy (&invoker);
-        delete[] call_parameters;
-    }
-}
-
-/**
- * Initializes the function calling data.
- */
-bool FunctionInfo::Init() {
-
-    if (call_parameters != nullptr)
-        return true;
-
-    g_function_info_prep_invoker (info, &invoker, NULL);
-
-    is_method = IsMethod(info);
-    can_throw = g_callable_info_can_throw_gerror (info);
-
-    n_callable_args = g_callable_info_get_n_args (info);
-    n_total_args = n_callable_args;
-    n_out_args = 0;
-    n_in_args = 0;
-
-    if (is_method)
-        n_total_args++;
-
-    if (can_throw)
-        n_total_args++;
-
-    call_parameters = new Parameter[n_callable_args]();
-
-    /*
-     * Examine load parameter types and count arguments
-     */
-
-    for (int i = 0; i < n_callable_args; i++) {
-        GIArgInfo arg_info;
-        GITypeInfo type_info;
-        g_callable_info_load_arg ((GICallableInfo *) info, i, &arg_info);
-        g_arg_info_load_type (&arg_info, &type_info);
-
-        bool may_be_null = g_arg_info_may_be_null (&arg_info);
-        GIDirection direction = g_arg_info_get_direction (&arg_info);
-        GITypeTag tag = g_type_info_get_tag(&type_info);
-
-        call_parameters[i].direction = direction;
-
-        if (call_parameters[i].type == ParameterType::SKIP)
-            continue;
-
-        // If there is an array length, this is an array
-        int length_i = g_type_info_get_array_length (&type_info);
-        if (tag == GI_TYPE_TAG_ARRAY && length_i >= 0) {
-            call_parameters[i].type        = ParameterType::ARRAY;
-            call_parameters[length_i].type = ParameterType::SKIP;
-
-            // If array length came before, we need to remove it from args count
-
-            if (IsDirectionIn(call_parameters[length_i].direction) && length_i < i)
-                n_in_args--;
-
-            if (IsDirectionOut(call_parameters[length_i].direction) && length_i < i)
-                n_out_args--;
-
-        } else if (tag == GI_TYPE_TAG_INTERFACE) {
-
-            GIBaseInfo* interface_info = g_type_info_get_interface(&type_info);
-            GIInfoType  interface_type = g_base_info_get_type(interface_info);
-
-            if (interface_type == GI_INFO_TYPE_CALLBACK) {
-                if (IsDestroyNotify(interface_info)) {
-                    /* Skip GDestroyNotify if they appear before the respective callback */
-                    call_parameters[i].type = ParameterType::SKIP;
-                } else {
-                    call_parameters[i].type = ParameterType::CALLBACK;
-
-                    int destroy_i = g_arg_info_get_destroy(&arg_info);
-                    int closure_i = g_arg_info_get_closure(&arg_info);
-
-                    if (destroy_i >= 0 && closure_i < 0) {
-                        Throw::UnsupportedCallback (info);
-                        g_base_info_unref(interface_info);
-                        return false;
-                    }
-
-                    if (destroy_i >= 0 && destroy_i < n_callable_args)
-                        call_parameters[destroy_i].type = ParameterType::SKIP;
-
-                    if (closure_i >= 0 && closure_i < n_callable_args)
-                        call_parameters[closure_i].type = ParameterType::SKIP;
-
-                    if (destroy_i < i) {
-                        if (IsDirectionIn(call_parameters[destroy_i].direction))
-                            n_in_args--;
-                        if (IsDirectionOut(call_parameters[destroy_i].direction))
-                            n_out_args--;
-                    }
-
-                    if (closure_i < i) {
-                        if (IsDirectionIn(call_parameters[closure_i].direction))
-                            n_in_args--;
-                        if (IsDirectionOut(call_parameters[closure_i].direction))
-                            n_out_args--;
-                    }
-                }
-            }
-
-            g_base_info_unref(interface_info);
-        }
-
-        if (IsDirectionIn(call_parameters[i].direction) && !may_be_null)
-            n_in_args++;
-
-        if (IsDirectionOut(call_parameters[i].direction))
-            n_out_args++;
-
-    }
-
-    /*
-     * Examine return type
-     */
-
-    GITypeInfo return_type;
-    g_callable_info_load_return_type(info, &return_type);
-    int return_length_i = g_type_info_get_array_length(&return_type);
-
-    if (return_length_i != -1)
-        n_out_args--;
+    #ifndef __linux__
+        delete[] total_arg_values;
+    #endif
 
-    if (!ShouldSkipReturn(info, &return_type))
-        n_out_args++;
-
-    return true;
+    return jsReturnValue;
 }
 
-/**
- * Type checks the JS arguments, throwing an error.
- * @returns true if types match
- */
-bool FunctionInfo::TypeCheck (const Nan::FunctionCallbackInfo<Value> &arguments) {
-
-    if (arguments.Length() < n_in_args) {
-        Throw::NotEnoughArguments(n_in_args, arguments.Length());
-        return false;
-    }
-
-    /*
-     * Type check every IN-argument that is not skipped
-     */
-
-    for (int in_arg = 0, i = 0; i < n_callable_args; i++) {
-        Parameter &param = call_parameters[i];
-
-        if (param.type == ParameterType::SKIP)
-            continue;
-
-        GIArgInfo arg_info;
-        g_callable_info_load_arg (info, i, &arg_info);
-        GIDirection direction = g_arg_info_get_direction (&arg_info);
-
-        if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
-            GITypeInfo type_info;
-            g_arg_info_load_type (&arg_info, &type_info);
-            bool may_be_null = g_arg_info_may_be_null (&arg_info);
-
-            if (!CanConvertV8ToGIArgument(&type_info, arguments[in_arg], may_be_null)) {
-                Throw::InvalidType(&arg_info, &type_info, arguments[in_arg]);
-                return false;
-            }
-            in_arg++;
-        }
-    }
-
-    return true;
-}
 
 /**
  * Creates the JS return value from the C arguments list
@@ -603,7 +610,7 @@ Local<Value> FunctionInfo::GetReturnValue (
 
         if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT) {
 
-            if (param.type == ParameterType::ARRAY) {
+            if (param.type == ParameterType::kARRAY) {
 
                 int length_i = g_type_info_get_array_length(&arg_type);
                 GIArgInfo length_arg;
@@ -622,7 +629,7 @@ Local<Value> FunctionInfo::GetReturnValue (
 
                 ADD_RETURN (result)
 
-            } else if (param.type == ParameterType::NORMAL) {
+            } else if (param.type == ParameterType::kNORMAL) {
 
                 if (IsPointerType(&arg_type) && g_arg_info_is_caller_allocates(&arg_info)) {
                     void *pointer = &arg_value.v_pointer;
@@ -681,7 +688,6 @@ void FunctionInvoker(const Nan::FunctionCallbackInfo<Value> &info) {
         RETURN (jsReturnValue);
     }
 
-    // see src/callback.cc
     Callback::AsyncFree();
 }
 
@@ -690,118 +696,4 @@ void FunctionDestroyed(const v8::WeakCallbackInfo<FunctionInfo> &data) {
     delete func;
 }
 
-
-bool PrepareVFuncInvoker (GIFunctionInfo *info, GIFunctionInvoker *invoker, GType implementor, GError **error) {
-    gpointer address;
-    ffi_type **atypes;
-    GITypeInfo *tinfo;
-    gint n_args, n_invoke_args, in_pos, out_pos;
-    bool success;
-
-    GITypeInfo *rinfo = g_callable_info_get_return_type ((GICallableInfo *)info);
-    ffi_type *rtype = g_type_info_get_ffi_type (rinfo);
-
-    in_pos = 0;
-    out_pos = 0;
-
-    n_args = g_callable_info_get_n_args ((GICallableInfo *)info);
-
-    n_invoke_args = n_args;
-
-    /* is_method */
-    n_invoke_args += 1;
-    in_pos++;
-
-    int n_in_args = 0;
-    int n_out_args = 0;
-
-    for (int i = 0; i < n_args; i++) {
-        GIArgInfo arg_info;
-        g_callable_info_load_arg(info, i, &arg_info);
-        auto direction = g_arg_info_get_direction(&arg_info);
-
-        if (IsDirectionIn(direction))
-            n_in_args++;
-        if (IsDirectionOut(direction))
-            n_out_args++;
-    }
-
-    atypes = (ffi_type**)g_alloca (sizeof (ffi_type*) * n_invoke_args);
-
-    /* is_method */
-    atypes[0] = &ffi_type_pointer;
-
-    for (int i = 0; i < n_args; i++) {
-        int offset = 1;
-        GIArgInfo *ainfo = g_callable_info_get_arg ((GICallableInfo *)info, i);
-
-        switch (g_arg_info_get_direction (ainfo)) {
-            case GI_DIRECTION_IN:
-                tinfo = g_arg_info_get_type (ainfo);
-                atypes[i+offset] = g_type_info_get_ffi_type (tinfo);
-                g_base_info_unref ((GIBaseInfo *)tinfo);
-
-                in_pos++;
-
-                break;
-            case GI_DIRECTION_OUT:
-                atypes[i+offset] = &ffi_type_pointer;
-
-                out_pos++;
-                break;
-            case GI_DIRECTION_INOUT:
-                atypes[i+offset] = &ffi_type_pointer;
-
-                in_pos++;
-                out_pos++;
-                break;
-            default:
-                g_assert_not_reached ();
-        }
-        g_base_info_unref ((GIBaseInfo *)ainfo);
-    }
-
-    success = ffi_prep_cif (&invoker->cif, FFI_DEFAULT_ABI, n_invoke_args, rtype, atypes) == FFI_OK;
-
-    address = g_vfunc_info_get_address (info, implementor, error);
-    invoker->native_address = address;
-
-    g_base_info_unref ((GIBaseInfo *)rinfo);
-    return success;
-}
-
-MaybeLocal<Function> MakeVirtualFunction(GIBaseInfo *info, GType implementor) {
-    GError* error = NULL;
-
-    FunctionInfo *func = g_new0 (FunctionInfo, 1);
-    func->info = g_base_info_ref (info);
-    PrepareVFuncInvoker(info, &func->invoker, implementor, &error);
-
-    if (error != NULL) {
-        char* message = g_strdup_printf("Couldn't create virtual function '%s': %s",
-                g_base_info_get_name(info), error->message);
-        Nan::ThrowError(message);
-        g_free (message);
-        g_base_info_unref (func->info);
-        g_function_invoker_destroy (&func->invoker);
-        g_free (func);
-        g_error_free (error);
-        return MaybeLocal<Function>();
-    }
-
-    auto external = New<External>(func);
-    auto name = UTF8(g_base_info_get_name (info));
-
-    auto tpl = New<FunctionTemplate>(FunctionInvoker, external);
-    tpl->SetLength(g_callable_info_get_n_args (info));
-
-    auto fn = Nan::GetFunction (tpl).ToLocalChecked();
-    fn->SetName(name);
-
-    Persistent<FunctionTemplate> persistent(Isolate::GetCurrent(), tpl);
-    persistent.SetWeak(func, FunctionDestroyed, WeakCallbackType::kParameter);
-
-    return MaybeLocal<Function>(fn);
-}
-
 };