nodejs
diff --git a/‎lib/internal/ffi-shared-buffer.js‎
Lines changed: 36 additions & 34 deletions b/‎lib/internal/ffi-shared-buffer.js‎
Lines changed: 36 additions & 34 deletions
diff --git a/‎lib/internal/ffi/fast-api.js‎
Lines changed: 10 additions & 8 deletions b/‎lib/internal/ffi/fast-api.js‎
Lines changed: 10 additions & 8 deletions
diff --git a/‎src/node_ffi.cc‎
Lines changed: 8 additions & 3 deletions b/‎src/node_ffi.cc‎
Lines changed: 8 additions & 3 deletions
diff --git a/‎test/ffi/test-ffi-dynamic-library.js‎
Lines changed: 21 additions & 0 deletions b/‎test/ffi/test-ffi-dynamic-library.js‎
Lines changed: 21 additions & 0 deletions
@@ -198,6 +198,8 @@ function inheritMetadata(wrapper, rawFn, nargs) {
 // arguments out of it into invocation-local storage before `ffi_call` and
 // reads the return value back only after, so nested/reentrant calls into
 // the same function are safe.
+// Concise methods do not have [[Construct]], unlike function expressions, so
+// use them below to match the native FFI functions' non-constructible behavior.
 function wrapWithSharedBuffer(rawFn, signature) {
   if (rawFn == null) return rawFn;
   const buffer = rawFn[kSbSharedBuffer];
@@ -254,7 +256,7 @@ function wrapWithSharedBuffer(rawFn, signature) {
     // so arity specialization wouldn't buy much here.
     assert(slowInvoke !== undefined,
            'FFI: shared-buffer raw function with pointer arguments is missing kSbInvokeSlow');
-    wrapper = function(...args) {
+    wrapper = { invoke(...args) {
       if (args.length !== nargs) {
         throwFFIArgCountError(nargs, args.length);
       }
@@ -271,7 +273,7 @@ function wrapWithSharedBuffer(rawFn, signature) {
       }
       rawFn();
       return retGetter === null ? undefined : retGetter(view, 0, true);
-    };
+    } }.invoke;
   } else {
     // Arity specialization avoids the per-call `Array` allocation of
     // `...args`; the void/non-void split removes a per-call branch on
@@ -295,67 +297,67 @@ function buildNumericWrapper(
   /* c8 ignore start */
   if (nargs === 0) {
     if (retGetter === null) {
-      return function() {
+      return { invoke() {
         if (arguments.length !== 0) {
           throwFFIArgCountError(0, arguments.length);
         }
         rawFn();
-      };
+      } }.invoke;
     }
-    return function() {
+    return { invoke() {
       if (arguments.length !== 0) {
         throwFFIArgCountError(0, arguments.length);
       }
       rawFn();
       return retGetter(view, 0, true);
-    };
+    } }.invoke;
   }
   /* c8 ignore stop */
   if (nargs === 1) {
     const i0 = argInfos[0];
     const o0 = argOffsets[0];
     if (retGetter === null) {
-      return function(a0) {
+      return { invoke(a0) {
         if (arguments.length !== 1) {
           throwFFIArgCountError(1, arguments.length);
         }
         writeNumericArg(view, i0, o0, a0, 0);
         rawFn();
-      };
+      } }.invoke;
     }
-    return function(a0) {
+    return { invoke(a0) {
       if (arguments.length !== 1) {
         throwFFIArgCountError(1, arguments.length);
       }
       writeNumericArg(view, i0, o0, a0, 0);
       rawFn();
       return retGetter(view, 0, true);
-    };
+    } }.invoke;
   }
   if (nargs === 2) {
     const i0 = argInfos[0];
     const i1 = argInfos[1];
     const o0 = argOffsets[0];
     const o1 = argOffsets[1];
     if (retGetter === null) {
-      return function(a0, a1) {
+      return { invoke(a0, a1) {
         if (arguments.length !== 2) {
           throwFFIArgCountError(2, arguments.length);
         }
         writeNumericArg(view, i0, o0, a0, 0);
         writeNumericArg(view, i1, o1, a1, 1);
         rawFn();
-      };
+      } }.invoke;
     }
-    return function(a0, a1) {
+    return { invoke(a0, a1) {
       if (arguments.length !== 2) {
         throwFFIArgCountError(2, arguments.length);
       }
       writeNumericArg(view, i0, o0, a0, 0);
       writeNumericArg(view, i1, o1, a1, 1);
       rawFn();
       return retGetter(view, 0, true);
-    };
+    } }.invoke;
   }
   if (nargs === 3) {
     const i0 = argInfos[0];
@@ -365,17 +367,17 @@ function buildNumericWrapper(
     const o1 = argOffsets[1];
     const o2 = argOffsets[2];
     if (retGetter === null) {
-      return function(a0, a1, a2) {
+      return { invoke(a0, a1, a2) {
         if (arguments.length !== 3) {
           throwFFIArgCountError(3, arguments.length);
         }
         writeNumericArg(view, i0, o0, a0, 0);
         writeNumericArg(view, i1, o1, a1, 1);
         writeNumericArg(view, i2, o2, a2, 2);
         rawFn();
-      };
+      } }.invoke;
     }
-    return function(a0, a1, a2) {
+    return { invoke(a0, a1, a2) {
       if (arguments.length !== 3) {
         throwFFIArgCountError(3, arguments.length);
       }
@@ -384,7 +386,7 @@ function buildNumericWrapper(
       writeNumericArg(view, i2, o2, a2, 2);
       rawFn();
       return retGetter(view, 0, true);
-    };
+    } }.invoke;
   }
   if (nargs === 4) {
     const i0 = argInfos[0];
@@ -396,7 +398,7 @@ function buildNumericWrapper(
     const o2 = argOffsets[2];
     const o3 = argOffsets[3];
     if (retGetter === null) {
-      return function(a0, a1, a2, a3) {
+      return { invoke(a0, a1, a2, a3) {
         if (arguments.length !== 4) {
           throwFFIArgCountError(4, arguments.length);
         }
@@ -405,9 +407,9 @@ function buildNumericWrapper(
         writeNumericArg(view, i2, o2, a2, 2);
         writeNumericArg(view, i3, o3, a3, 3);
         rawFn();
-      };
+      } }.invoke;
     }
-    return function(a0, a1, a2, a3) {
+    return { invoke(a0, a1, a2, a3) {
       if (arguments.length !== 4) {
         throwFFIArgCountError(4, arguments.length);
       }
@@ -417,7 +419,7 @@ function buildNumericWrapper(
       writeNumericArg(view, i3, o3, a3, 3);
       rawFn();
       return retGetter(view, 0, true);
-    };
+    } }.invoke;
   }
   if (nargs === 5) {
     const i0 = argInfos[0];
@@ -431,7 +433,7 @@ function buildNumericWrapper(
     const o3 = argOffsets[3];
     const o4 = argOffsets[4];
     if (retGetter === null) {
-      return function(a0, a1, a2, a3, a4) {
+      return { invoke(a0, a1, a2, a3, a4) {
         if (arguments.length !== 5) {
           throwFFIArgCountError(5, arguments.length);
         }
@@ -441,9 +443,9 @@ function buildNumericWrapper(
         writeNumericArg(view, i3, o3, a3, 3);
         writeNumericArg(view, i4, o4, a4, 4);
         rawFn();
-      };
+      } }.invoke;
     }
-    return function(a0, a1, a2, a3, a4) {
+    return { invoke(a0, a1, a2, a3, a4) {
       if (arguments.length !== 5) {
         throwFFIArgCountError(5, arguments.length);
       }
@@ -454,7 +456,7 @@ function buildNumericWrapper(
       writeNumericArg(view, i4, o4, a4, 4);
       rawFn();
       return retGetter(view, 0, true);
-    };
+    } }.invoke;
   }
   if (nargs === 6) {
     const i0 = argInfos[0];
@@ -470,7 +472,7 @@ function buildNumericWrapper(
     const o4 = argOffsets[4];
     const o5 = argOffsets[5];
     if (retGetter === null) {
-      return function(a0, a1, a2, a3, a4, a5) {
+      return { invoke(a0, a1, a2, a3, a4, a5) {
         if (arguments.length !== 6) {
           throwFFIArgCountError(6, arguments.length);
         }
@@ -481,9 +483,9 @@ function buildNumericWrapper(
         writeNumericArg(view, i4, o4, a4, 4);
         writeNumericArg(view, i5, o5, a5, 5);
         rawFn();
-      };
+      } }.invoke;
     }
-    return function(a0, a1, a2, a3, a4, a5) {
+    return { invoke(a0, a1, a2, a3, a4, a5) {
       if (arguments.length !== 6) {
         throwFFIArgCountError(6, arguments.length);
       }
@@ -495,22 +497,22 @@ function buildNumericWrapper(
       writeNumericArg(view, i5, o5, a5, 5);
       rawFn();
       return retGetter(view, 0, true);
-    };
+    } }.invoke;
   }
   // 7+ args: further specialization is diminishing returns and bloats
   // this builder.
   if (retGetter === null) {
-    return function(...args) {
+    return { invoke(...args) {
       if (args.length !== nargs) {
         throwFFIArgCountError(nargs, args.length);
       }
       for (let i = 0; i < nargs; i++) {
         writeNumericArg(view, argInfos[i], argOffsets[i], args[i], i);
       }
       rawFn();
-    };
+    } }.invoke;
   }
-  return function(...args) {
+  return { invoke(...args) {
     if (args.length !== nargs) {
       throwFFIArgCountError(nargs, args.length);
     }
@@ -519,7 +521,7 @@ function buildNumericWrapper(
     }
     rawFn();
     return retGetter(view, 0, true);
-  };
+  } }.invoke;
 }
 
 module.exports = {
 
@@ -254,6 +254,8 @@ function throwIfFastLibraryClosed(state) {
   }
 }
 
+// Concise methods do not have [[Construct]], unlike function expressions.
+// Keep wrappers non-constructible to match the native FFI functions.
 function wrapWithRawPointerConversions(rawFn, argumentTypes, owner) {
   if (rawFn === undefined || rawFn === null) {
     return rawFn;
@@ -287,7 +289,7 @@ function wrapWithRawPointerConversions(rawFn, argumentTypes, owner) {
     const memory0 = needsRawPointerConversion(t0) || string0;
     const fastBufferInvoke = needsPointerLikeConversion(t0) ?
       rawFn[kFastBufferInvoke] : undefined;
-    wrapper = function(a0) {
+    wrapper = { invoke(a0) {
       throwIfFastLibraryClosed(state);
       if (arguments.length !== 1) {
         throwFFIArgCountError(1, arguments.length);
@@ -312,13 +314,13 @@ function wrapWithRawPointerConversions(rawFn, argumentTypes, owner) {
         arg = getRawPointerArg(arg, 0);
       }
       return rawFn(arg);
-    };
+    } }.invoke;
   } else if (nargs === 2) {
     const c0 = ArrayPrototypeIncludes(indexes, 0);
     const c1 = ArrayPrototypeIncludes(indexes, 1);
     const t0 = argumentTypes[0];
     const t1 = argumentTypes[1];
-    wrapper = function(a0, a1) {
+    wrapper = { invoke(a0, a1) {
       throwIfFastLibraryClosed(state);
       if (arguments.length !== 2) {
         throwFFIArgCountError(2, arguments.length);
@@ -332,15 +334,15 @@ function wrapWithRawPointerConversions(rawFn, argumentTypes, owner) {
       } finally {
         if (stringCall) exitStringConversion(stringState);
       }
-    };
+    } }.invoke;
   } else if (nargs === 3) {
     const c0 = ArrayPrototypeIncludes(indexes, 0);
     const c1 = ArrayPrototypeIncludes(indexes, 1);
     const c2 = ArrayPrototypeIncludes(indexes, 2);
     const t0 = argumentTypes[0];
     const t1 = argumentTypes[1];
     const t2 = argumentTypes[2];
-    wrapper = function(a0, a1, a2) {
+    wrapper = { invoke(a0, a1, a2) {
       throwIfFastLibraryClosed(state);
       if (arguments.length !== 3) {
         throwFFIArgCountError(3, arguments.length);
@@ -356,9 +358,9 @@ function wrapWithRawPointerConversions(rawFn, argumentTypes, owner) {
       } finally {
         if (stringCall) exitStringConversion(stringState);
       }
-    };
+    } }.invoke;
   } else {
-    wrapper = function(...args) {
+    wrapper = { invoke(...args) {
       throwIfFastLibraryClosed(state);
       if (args.length !== nargs) {
         throwFFIArgCountError(nargs, args.length);
@@ -382,7 +384,7 @@ function wrapWithRawPointerConversions(rawFn, argumentTypes, owner) {
       } finally {
         if (stringCall) exitStringConversion(stringState);
       }
-    };
+    } }.invoke;
   }
 
   return inheritMetadata(wrapper, rawFn, nargs);
 
@@ -324,7 +324,9 @@ MaybeLocal<Function> DynamicLibrary::CreateFunction(
     maybe_ret = Function::New(context,
                               use_sb ? DynamicLibrary::InvokeFunctionSB
                                      : DynamicLibrary::InvokeFunction,
-                              info->object());
+                              info->object(),
+                              0,
+                              v8::ConstructorBehavior::kThrow);
   }
 
   Local<Function> ret;
@@ -377,8 +379,11 @@ MaybeLocal<Function> DynamicLibrary::CreateFunction(
     // (strings, Buffers, ArrayBuffers, and ArrayBufferViews).
     if (has_ptr_args) {
       Local<Function> slow_fn;
-      if (!Function::New(
-               context, DynamicLibrary::InvokeFunction, info->object())
+      if (!Function::New(context,
+                         DynamicLibrary::InvokeFunction,
+                         info->object(),
+                         0,
+                         v8::ConstructorBehavior::kThrow)
                .ToLocal(&slow_fn)) {
         return MaybeLocal<Function>();
       }
 
@@ -67,6 +67,27 @@ test('dlopen resolves functions from definitions', () => {
   }
 });
 
+test('FFI functions are not constructible', () => {
+  const { lib, functions } = ffi.dlopen(libraryPath, {
+    add_i32: fixtureSymbols.add_i32,
+    multiply_f64: fixtureSymbols.multiply_f64,
+  });
+
+  try {
+    assert.strictEqual(Object.hasOwn(functions.add_i32, 'prototype'), false);
+    assert.strictEqual(
+      Object.hasOwn(functions.multiply_f64, 'prototype'), false);
+    assert.throws(
+      () => Reflect.construct(functions.add_i32, [20, 22]),
+      TypeError);
+    assert.throws(
+      () => Reflect.construct(functions.multiply_f64, [6, 7]),
+      TypeError);
+  } finally {
+    lib.close();
+  }
+});
+
 test('DynamicLibrary exposes functions and symbols', () => {
   const lib = new ffi.DynamicLibrary(libraryPath);