test: add permission fast api test

Signed-off-by: James M Snell <jasnell@gmail.com>

Author: jasnell

src/permission/permission.cc

@@ -127,7 +127,6 @@ static void Has(const FunctionCallbackInfo<Value>& args) {
 
 static bool FastHas(Local<Value> receiver,
                     Local<Value> scope_arg,
-                    Local<Value> resource_arg,
                     // NOLINTNEXTLINE(runtime/references) This is V8 api.
                     FastApiCallbackOptions& options) {
   TRACK_V8_FAST_API_CALL("permission.has");
@@ -148,8 +147,30 @@ static bool FastHas(Local<Value> receiver,
     return false;
   }
 
-  if (resource_arg->IsUndefined()) {
-    return env->permission()->is_granted(env, scope);
+  return env->permission()->is_granted(env, scope);
+}
+
+static bool FastHasResource(Local<Value> receiver,
+                            Local<Value> scope_arg,
+                            Local<Value> resource_arg,
+                            // NOLINTNEXTLINE(runtime/references) This is V8 api.
+                            FastApiCallbackOptions& options) {
+  TRACK_V8_FAST_API_CALL("permission.has");
+  auto isolate = options.isolate;
+  v8::HandleScope handle_scope(isolate);
+  auto context = isolate->GetCurrentContext();
+
+  Environment* env = Environment::GetCurrent(context);
+
+  Local<String> str;
+  if (!scope_arg->ToString(context).ToLocal(&str)) {
+    return false;
+  }
+  Utf8Value utf8_scope(isolate, str);
+  PermissionScope scope =
+      Permission::StringToPermission(utf8_scope.ToStringView());
+  if (scope == PermissionScope::kPermissionsRoot) {
+    return false;
   }
 
   Local<String> res_str;
@@ -164,7 +185,8 @@ static bool FastHas(Local<Value> receiver,
   return env->permission()->is_granted(env, scope, utf8_res.ToStringView());
 }
 
-static CFunction fast_has_(CFunction::Make(FastHas));
+static CFunction fast_has_methods_[] = {CFunction::Make(FastHas),
+                                        CFunction::Make(FastHasResource)};
 
 }  // namespace
 
@@ -370,15 +392,18 @@ void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context,
                 void* priv) {
-  SetFastMethodNoSideEffect(context, target, "has", Has, &fast_has_);
+  SetFastMethodNoSideEffect(
+      context, target, "has", Has, {fast_has_methods_, 2});
   SetMethod(context, target, "drop", Drop);
 
   target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
 }
 
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(Has);
-  registry->Register(fast_has_);
+  for (const CFunction& method : fast_has_methods_) {
+    registry->Register(method);
+  }
   registry->Register(Drop);
 }
 

src/util.cc

@@ -468,6 +468,32 @@ void SetFastMethodNoSideEffect(
   that->Set(name_string, t);
 }
 
+void SetFastMethodNoSideEffect(
+    Local<v8::Context> context,
+    Local<v8::Object> that,
+    const std::string_view name,
+    v8::FunctionCallback slow_callback,
+    const v8::MemorySpan<const v8::CFunction>& methods) {
+  Isolate* isolate = Isolate::GetCurrent();
+  Local<v8::Function> function =
+      FunctionTemplate::NewWithCFunctionOverloads(
+          isolate,
+          slow_callback,
+          Local<Value>(),
+          Local<v8::Signature>(),
+          0,
+          v8::ConstructorBehavior::kThrow,
+          v8::SideEffectType::kHasNoSideEffect,
+          methods)
+          ->GetFunction(context)
+          .ToLocalChecked();
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  Local<v8::String> name_string =
+      v8::String::NewFromUtf8(isolate, name.data(), type, name.size())
+          .ToLocalChecked();
+  that->Set(context, name_string, function).Check();
+}
+
 void SetMethodNoSideEffect(Local<v8::Context> context,
                            Local<v8::Object> that,
                            const std::string_view name,

src/util.h

@@ -921,6 +921,12 @@ void SetFastMethodNoSideEffect(
     const std::string_view name,
     v8::FunctionCallback slow_callback,
     const v8::MemorySpan<const v8::CFunction>& methods);
+void SetFastMethodNoSideEffect(
+    v8::Local<v8::Context> context,
+    v8::Local<v8::Object> that,
+    const std::string_view name,
+    v8::FunctionCallback slow_callback,
+    const v8::MemorySpan<const v8::CFunction>& methods);
 void SetProtoMethod(v8::Isolate* isolate,
                     v8::Local<v8::FunctionTemplate> that,
                     const std::string_view name,

test/parallel/test-permission-has-fast-api.js

@@ -0,0 +1,38 @@
+// Flags: --permission --allow-fs-read=* --allow-fs-write=* --allow-natives-syntax --expose-internals --no-warnings
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+const path = require('path');
+
+// Test that process.permission.has() uses the V8 fast API path.
+
+// Test with scope only (no resource argument).
+function testHasScope() {
+  assert.strictEqual(process.permission.has('fs.read', __filename), true);
+  assert.strictEqual(process.permission.has('fs.write', __dirname), true);
+  assert.strictEqual(
+    process.permission.has('fs.read', path.resolve('/nonexistent')),
+    true
+  );
+  assert.strictEqual(process.permission.has('fs.read'), true);
+  assert.strictEqual(process.permission.has('fs.write'), true);
+  assert.strictEqual(process.permission.has('child'), false);
+  assert.strictEqual(process.permission.has('worker'), false);
+  assert.strictEqual(process.permission.has('invalid-key'), false);
+}
+
+// Warm up and optimize for the fast API path.
+eval('%PrepareFunctionForOptimization(testHasScope)');
+testHasScope();
+testHasScope();
+
+eval('%OptimizeFunctionOnNextCall(testHasScope)');
+testHasScope();
+
+if (common.isDebug) {
+  const { getV8FastApiCallCount } = internalBinding('debug');
+  // After optimization: testHasScope = 4, testHasResource = 3, testHasInvalid = 1
+  assert.strictEqual(getV8FastApiCallCount('permission.has'), 8);
+}