nodejs
diff --git a/‎src/permission/fs_permission.cc‎
Lines changed: 9 additions & 12 deletions b/‎src/permission/fs_permission.cc‎
Lines changed: 9 additions & 12 deletions
diff --git a/‎src/permission/fs_permission.h‎
Lines changed: 36 additions & 22 deletions b/‎src/permission/fs_permission.h‎
Lines changed: 36 additions & 22 deletions
diff --git a/‎src/permission/permission.cc‎
Lines changed: 48 additions & 1 deletion b/‎src/permission/permission.cc‎
Lines changed: 48 additions & 1 deletion
@@ -39,10 +39,8 @@ void FreeRecursivelyNode(
     return;
   }
 
-  if (node->children.size()) {
-    for (auto& c : node->children) {
-      FreeRecursivelyNode(c.second);
-    }
+  for (auto& [label, child] : node->children) {
+    FreeRecursivelyNode(child);
   }
 
   delete node->wildcard_child;
@@ -106,7 +104,7 @@ void PrintTree(const node::permission::FSPermission::RadixTree::Node* node,
         node::DebugCategory::PERMISSION_MODEL, "%s%s\n", indent, node->prefix);
   }
 
-  if (node->children.size() > 0) {
+  if (!node->children.empty()) {
     size_t count = 0;
     size_t total = node->children.size();
 
@@ -120,10 +118,10 @@ void PrintTree(const node::permission::FSPermission::RadixTree::Node* node,
       }
     }
 
-    for (const auto& pair : node->children) {
+    for (const auto& [label, child] : node->children) {
       count++;
       bool child_is_last = (count == total);
-      PrintTree(pair.second, depth + 1, next_branch_prefix, child_is_last);
+      PrintTree(child, depth + 1, next_branch_prefix, child_is_last);
     }
   }
 }
@@ -278,8 +276,8 @@ FSPermission::RadixTree::~RadixTree() {
 }
 
 void FSPermission::RadixTree::Clear() {
-  for (auto& c : root_node_->children) {
-    FreeRecursivelyNode(c.second);
+  for (auto& [label, child] : root_node_->children) {
+    FreeRecursivelyNode(child);
   }
   root_node_->children.clear();
   delete root_node_->wildcard_child;
@@ -294,15 +292,14 @@ bool FSPermission::RadixTree::Lookup(std::string_view s,
     return when_empty_return;
   }
   size_t parent_node_prefix_len = current_node->prefix.length();
-  const std::string path(s);
-  auto path_len = path.length();
+  auto path_len = s.length();
 
   while (true) {
     if (parent_node_prefix_len == path_len && current_node->IsEndNode()) {
       return true;
     }
 
-    auto node = current_node->NextNode(path, parent_node_prefix_len);
+    auto node = current_node->NextNode(s, parent_node_prefix_len);
     if (node == nullptr) {
       return false;
     }
 
@@ -5,7 +5,7 @@
 
 #include "v8.h"
 
-#include <unordered_map>
+#include <vector>
 #include "permission/permission_base.h"
 #include "util.h"
 
@@ -28,16 +28,30 @@ class FSPermission final : public PermissionBase {
   struct RadixTree {
     struct Node {
       std::string prefix;
-      std::unordered_map<char, Node*> children;
-      Node* wildcard_child;
-      bool is_leaf;
+      std::vector<std::pair<char, Node*>> children;
+      Node* wildcard_child = nullptr;
+      bool is_leaf = false;
 
-      explicit Node(const std::string& pre)
-          : prefix(pre), wildcard_child(nullptr), is_leaf(false) {}
+      explicit Node(std::string_view pre)
+          : prefix(pre) {}
 
-      Node() : wildcard_child(nullptr), is_leaf(false) {}
+      Node() = default;
 
-      Node* CreateChild(const std::string& path_prefix) {
+      Node* FindChild(char label) const {
+        for (const auto& [c, node] : children) {
+          if (c == label) return node;
+        }
+        return nullptr;
+      }
+
+      void SetChild(char label, Node* node) {
+        for (auto& [c, n] : children) {
+          if (c == label) { n = node; return; }
+        }
+        children.emplace_back(label, node);
+      }
+
+      Node* CreateChild(std::string_view path_prefix) {
         if (path_prefix.empty() && !is_leaf) {
           is_leaf = true;
           return this;
@@ -46,10 +60,11 @@ class FSPermission final : public PermissionBase {
         CHECK(!path_prefix.empty());
         char label = path_prefix[0];
 
-        Node* child = children[label];
+        Node* child = FindChild(label);
         if (child == nullptr) {
-          children[label] = new Node(path_prefix);
-          return children[label];
+          child = new Node(path_prefix);
+          children.emplace_back(label, child);
+          return child;
         }
         bool child_was_end_node = child->IsEndNode();
 
@@ -58,13 +73,13 @@ class FSPermission final : public PermissionBase {
         size_t prefix_len = path_prefix.length();
         for (; i < child->prefix.length(); ++i) {
           if (i >= prefix_len || path_prefix[i] != child->prefix[i]) {
-            std::string parent_prefix = child->prefix.substr(0, i);
-            std::string child_prefix = child->prefix.substr(i);
+            std::string parent_prefix(child->prefix.substr(0, i));
+            std::string child_prefix(child->prefix.substr(i));
 
             child->prefix = child_prefix;
             Node* split_child = new Node(parent_prefix);
-            split_child->children[child_prefix[0]] = child;
-            children[parent_prefix[0]] = split_child;
+            split_child->children.emplace_back(child_prefix[0], child);
+            SetChild(parent_prefix[0], split_child);
 
             return split_child->CreateChild(path_prefix.substr(i));
           }
@@ -83,24 +98,23 @@ class FSPermission final : public PermissionBase {
         return wildcard_child;
       }
 
-      Node* NextNode(const std::string& path, size_t idx) const {
+      Node* NextNode(std::string_view path, size_t idx) const {
         if (idx >= path.length()) {
           return nullptr;
         }
 
         // wildcard node takes precedence
         if (children.size() > 1) {
-          auto it = children.find('*');
-          if (it != children.end()) {
-            return it->second;
+          Node* wc = FindChild('*');
+          if (wc != nullptr) {
+            return wc;
           }
         }
 
-        auto it = children.find(path[idx]);
-        if (it == children.end()) {
+        Node* child = FindChild(path[idx]);
+        if (child == nullptr) {
           return nullptr;
         }
-        auto child = it->second;
         // match prefix
         size_t prefix_len = child->prefix.length();
         for (size_t i = 0; i < path.length(); ++i) {
 
@@ -3,12 +3,14 @@
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node.h"
+#include "node_debug.h"
 #include "node_diagnostics_channel.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_file.h"
 
 #include "permission/permission_base.h"
+#include "v8-fast-api-calls.h"
 #include "v8-template.h"
 #include "v8.h"
 
@@ -18,13 +20,16 @@
 
 namespace node {
 
+using v8::CFunction;
 using v8::Context;
 using v8::DictionaryTemplate;
+using v8::FastApiCallbackOptions;
 using v8::FunctionCallbackInfo;
 using v8::IntegrityLevel;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Object;
+using v8::String;
 using v8::Undefined;
 using v8::Value;
 
@@ -121,6 +126,47 @@ static void Has(const FunctionCallbackInfo<Value>& args) {
   return args.GetReturnValue().Set(env->permission()->is_granted(env, scope));
 }
 
+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");
+  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;
+  }
+
+  if (resource_arg->IsUndefined()) {
+    return env->permission()->is_granted(env, scope);
+  }
+
+  Local<String> res_str;
+  if (!resource_arg->ToString(context).ToLocal(&res_str)) {
+    return false;
+  }
+  Utf8Value utf8_res(isolate, res_str);
+  if (utf8_res.length() == 0) {
+    return false;
+  }
+
+  return env->permission()->is_granted(env, scope, utf8_res.ToStringView());
+}
+
+static CFunction fast_has_(CFunction::Make(FastHas));
+
 }  // namespace
 
 #define V(Name, label, _, __)                                                  \
@@ -349,14 +395,15 @@ void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context,
                 void* priv) {
-  SetMethodNoSideEffect(context, target, "has", Has);
+  SetFastMethodNoSideEffect(context, target, "has", Has, &fast_has_);
   SetMethod(context, target, "drop", Drop);
 
   target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
 }
 
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(Has);
+  registry->Register(fast_has_);
   registry->Register(Drop);
 }
Original file line number	Diff line number	Diff line change
`@@ -39,10 +39,8 @@ void FreeRecursivelyNode(`
`39`	`39`	`return;`
`40`	`40`	`}`
`41`	`41`
`42`		`- if (node->children.size()) {`
`43`		`- for (auto& c : node->children) {`
`44`		`- FreeRecursivelyNode(c.second);`
`45`		`- }`
	`42`	`+ for (auto& [label, child] : node->children) {`
	`43`	`+ FreeRecursivelyNode(child);`
`46`	`44`	`}`
`47`	`45`
`48`	`46`	`delete node->wildcard_child;`
`@@ -106,7 +104,7 @@ void PrintTree(const node::permission::FSPermission::RadixTree::Node* node,`
`106`	`104`	`node::DebugCategory::PERMISSION_MODEL, "%s%s\n", indent, node->prefix);`
`107`	`105`	`}`
`108`	`106`
`109`		`- if (node->children.size() > 0) {`
	`107`	`+ if (!node->children.empty()) {`
`110`	`108`	`size_t count = 0;`
`111`	`109`	`size_t total = node->children.size();`
`112`	`110`
`@@ -120,10 +118,10 @@ void PrintTree(const node::permission::FSPermission::RadixTree::Node* node,`
`120`	`118`	`}`
`121`	`119`	`}`
`122`	`120`
`123`		`- for (const auto& pair : node->children) {`
	`121`	`+ for (const auto& [label, child] : node->children) {`
`124`	`122`	`count++;`
`125`	`123`	`bool child_is_last = (count == total);`
`126`		`- PrintTree(pair.second, depth + 1, next_branch_prefix, child_is_last);`
	`124`	`+ PrintTree(child, depth + 1, next_branch_prefix, child_is_last);`
`127`	`125`	`}`
`128`	`126`	`}`
`129`	`127`	`}`
`@@ -278,8 +276,8 @@ FSPermission::RadixTree::~RadixTree() {`
`278`	`276`	`}`
`279`	`277`
`280`	`278`	`void FSPermission::RadixTree::Clear() {`
`281`		`- for (auto& c : root_node_->children) {`
`282`		`- FreeRecursivelyNode(c.second);`
	`279`	`+ for (auto& [label, child] : root_node_->children) {`
	`280`	`+ FreeRecursivelyNode(child);`
`283`	`281`	`}`
`284`	`282`	`root_node_->children.clear();`
`285`	`283`	`delete root_node_->wildcard_child;`
`@@ -294,15 +292,14 @@ bool FSPermission::RadixTree::Lookup(std::string_view s,`
`294`	`292`	`return when_empty_return;`
`295`	`293`	`}`
`296`	`294`	`size_t parent_node_prefix_len = current_node->prefix.length();`
`297`		`- const std::string path(s);`
`298`		`- auto path_len = path.length();`
	`295`	`+ auto path_len = s.length();`
`299`	`296`
`300`	`297`	`while (true) {`
`301`	`298`	`if (parent_node_prefix_len == path_len && current_node->IsEndNode()) {`
`302`	`299`	`return true;`
`303`	`300`	`}`
`304`	`301`
`305`		`- auto node = current_node->NextNode(path, parent_node_prefix_len);`
	`302`	`+ auto node = current_node->NextNode(s, parent_node_prefix_len);`
`306`	`303`	`if (node == nullptr) {`
`307`	`304`	`return false;`
`308`	`305`	`}`