fs: move ToNamespacedPath to c++

Co-Authored-By: Daniel Lemire <daniel@lemire.me>
PR-URL: #52135
Reviewed-By: Geoffrey Booth <webadmin@geoffreybooth.com>
Reviewed-By: Vinícius Lourenço Claro Cardoso <contact@viniciusl.com.br>
Reviewed-By: Daniel Lemire <daniel@lemire.me>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: 2 people

lib/fs.js

@@ -603,30 +603,28 @@ async function readFileHandle(filehandle, options) {
 // All of the functions are defined as async in order to ensure that errors
 // thrown cause promise rejections rather than being thrown synchronously.
 asyncfunctionaccess(path,mode=F_OK){
-path=getValidatedPath(path);
-
 returnawaitPromisePrototypeThen(
-binding.access(pathModule.toNamespacedPath(path),mode,kUsePromises),
+binding.access(getValidatedPath(path),mode,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
 }
 
 asyncfunctioncp(src,dest,options){
 options=validateCpOptions(options);
-src=pathModule.toNamespacedPath(getValidatedPath(src,'src'));
-dest=pathModule.toNamespacedPath(getValidatedPath(dest,'dest'));
+src=getValidatedPath(src,'src');
+dest=getValidatedPath(dest,'dest');
 returnlazyLoadCpPromises()(src,dest,options);
 }
 
 asyncfunctioncopyFile(src,dest,mode){
-src=getValidatedPath(src,'src');
-dest=getValidatedPath(dest,'dest');
 returnawaitPromisePrototypeThen(
-binding.copyFile(pathModule.toNamespacedPath(src),
-pathModule.toNamespacedPath(dest),
-mode,
-kUsePromises),
+binding.copyFile(
+getValidatedPath(src,'src'),
+getValidatedPath(dest,'dest'),
+mode,
+kUsePromises,
+),
 undefined,
 handleErrorFromBinding,
 );
@@ -639,8 +637,7 @@ async function open(path, flags, mode) {
 constflagsNumber=stringToFlags(flags);
 mode=parseFileMode(mode,'mode',0o666);
 returnnewFileHandle(awaitPromisePrototypeThen(
-binding.openFileHandle(pathModule.toNamespacedPath(path),
-flagsNumber,mode,kUsePromises),
+binding.openFileHandle(path,flagsNumber,mode,kUsePromises),
 undefined,
 handleErrorFromBinding,
 ));
@@ -785,9 +782,7 @@ async function rename(oldPath, newPath) {
 oldPath=getValidatedPath(oldPath,'oldPath');
 newPath=getValidatedPath(newPath,'newPath');
 returnawaitPromisePrototypeThen(
-binding.rename(pathModule.toNamespacedPath(oldPath),
-pathModule.toNamespacedPath(newPath),
-kUsePromises),
+binding.rename(oldPath,newPath,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
@@ -809,13 +804,13 @@ async function ftruncate(handle, len = 0) {
 }
 
 asyncfunctionrm(path,options){
-path=pathModule.toNamespacedPath(getValidatedPath(path));
+path=getValidatedPath(path);
 options=awaitvalidateRmOptionsPromise(path,options,false);
 returnlazyRimRaf()(path,options);
 }
 
 asyncfunctionrmdir(path,options){
-path=pathModule.toNamespacedPath(getValidatedPath(path));
+path=getValidatedPath(path);
 options=validateRmdirOptions(options);
 
 if(options.recursive){
@@ -861,9 +856,12 @@ async function mkdir(path, options) {
 validateBoolean(recursive,'options.recursive');
 
 returnawaitPromisePrototypeThen(
-binding.mkdir(pathModule.toNamespacedPath(path),
-parseFileMode(mode,'mode',0o777),recursive,
-kUsePromises),
+binding.mkdir(
+path,
+parseFileMode(mode,'mode',0o777),
+recursive,
+kUsePromises,
+),
 undefined,
 handleErrorFromBinding,
 );
@@ -876,7 +874,7 @@ async function readdirRecursive(originalPath, options) {
 originalPath,
 awaitPromisePrototypeThen(
 binding.readdir(
-pathModule.toNamespacedPath(originalPath),
+originalPath,
 options.encoding,
 !!options.withFileTypes,
 kUsePromises,
@@ -927,7 +925,7 @@ async function readdirRecursive(originalPath, options) {
 direntPath,
 awaitPromisePrototypeThen(
 binding.readdir(
-pathModule.toNamespacedPath(direntPath),
+direntPath,
 options.encoding,
 false,
 kUsePromises,
@@ -952,7 +950,7 @@ async function readdir(path, options) {
 }
 constresult=awaitPromisePrototypeThen(
 binding.readdir(
-pathModule.toNamespacedPath(path),
+path,
 options.encoding,
 !!options.withFileTypes,
 kUsePromises,
@@ -969,8 +967,7 @@ async function readlink(path, options) {
 options=getOptions(options);
 path=getValidatedPath(path,'oldPath');
 returnawaitPromisePrototypeThen(
-binding.readlink(pathModule.toNamespacedPath(path),
-options.encoding,kUsePromises),
+binding.readlink(path,options.encoding,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
@@ -1003,10 +1000,12 @@ async function symlink(target, path, type_) {
 target=getValidatedPath(target,'target');
 path=getValidatedPath(path);
 returnawaitPromisePrototypeThen(
-binding.symlink(preprocessSymlinkDestination(target,type,path),
-pathModule.toNamespacedPath(path),
-stringToSymlinkType(type),
-kUsePromises),
+binding.symlink(
+preprocessSymlinkDestination(target,type,path),
+path,
+stringToSymlinkType(type),
+kUsePromises,
+),
 undefined,
 handleErrorFromBinding,
 );
@@ -1022,32 +1021,26 @@ async function fstat(handle, options = { bigint: false }) {
 }
 
 asyncfunctionlstat(path,options={bigint: false}){
-path=getValidatedPath(path);
 constresult=awaitPromisePrototypeThen(
-binding.lstat(pathModule.toNamespacedPath(path),
-options.bigint,kUsePromises),
+binding.lstat(getValidatedPath(path),options.bigint,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
 returngetStatsFromBinding(result);
 }
 
 asyncfunctionstat(path,options={bigint: false}){
-path=getValidatedPath(path);
 constresult=awaitPromisePrototypeThen(
-binding.stat(pathModule.toNamespacedPath(path),
-options.bigint,kUsePromises),
+binding.stat(getValidatedPath(path),options.bigint,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
 returngetStatsFromBinding(result);
 }
 
 asyncfunctionstatfs(path,options={bigint: false}){
-path=getValidatedPath(path);
 constresult=awaitPromisePrototypeThen(
-binding.statfs(pathModule.toNamespacedPath(path),
-options.bigint,kUsePromises),
+binding.statfs(path,options.bigint,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
@@ -1058,18 +1051,15 @@ async function link(existingPath, newPath) {
 existingPath=getValidatedPath(existingPath,'existingPath');
 newPath=getValidatedPath(newPath,'newPath');
 returnawaitPromisePrototypeThen(
-binding.link(pathModule.toNamespacedPath(existingPath),
-pathModule.toNamespacedPath(newPath),
-kUsePromises),
+binding.link(existingPath,newPath,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
 }
 
 asyncfunctionunlink(path){
-path=getValidatedPath(path);
 returnawaitPromisePrototypeThen(
-binding.unlink(pathModule.toNamespacedPath(path),kUsePromises),
+binding.unlink(getValidatedPath(path),kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
@@ -1088,7 +1078,7 @@ async function chmod(path, mode) {
 path=getValidatedPath(path);
 mode=parseFileMode(mode,'mode');
 returnawaitPromisePrototypeThen(
-binding.chmod(pathModule.toNamespacedPath(path),mode,kUsePromises),
+binding.chmod(path,mode,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
@@ -1107,7 +1097,7 @@ async function lchown(path, uid, gid) {
 validateInteger(uid,'uid',-1,kMaxUserId);
 validateInteger(gid,'gid',-1,kMaxUserId);
 returnawaitPromisePrototypeThen(
-binding.lchown(pathModule.toNamespacedPath(path),uid,gid,kUsePromises),
+binding.lchown(path,uid,gid,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
@@ -1128,7 +1118,7 @@ async function chown(path, uid, gid) {
 validateInteger(uid,'uid',-1,kMaxUserId);
 validateInteger(gid,'gid',-1,kMaxUserId);
 returnawaitPromisePrototypeThen(
-binding.chown(pathModule.toNamespacedPath(path),uid,gid,kUsePromises),
+binding.chown(path,uid,gid,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );
@@ -1137,10 +1127,12 @@ async function chown(path, uid, gid) {
 asyncfunctionutimes(path,atime,mtime){
 path=getValidatedPath(path);
 returnawaitPromisePrototypeThen(
-binding.utimes(pathModule.toNamespacedPath(path),
-toUnixTimestamp(atime),
-toUnixTimestamp(mtime),
-kUsePromises),
+binding.utimes(
+path,
+toUnixTimestamp(atime),
+toUnixTimestamp(mtime),
+kUsePromises,
+),
 undefined,
 handleErrorFromBinding,
 );
@@ -1157,22 +1149,22 @@ async function futimes(handle, atime, mtime) {
 }
 
 asyncfunctionlutimes(path,atime,mtime){
-path=getValidatedPath(path);
 returnawaitPromisePrototypeThen(
-binding.lutimes(pathModule.toNamespacedPath(path),
-toUnixTimestamp(atime),
-toUnixTimestamp(mtime),
-kUsePromises),
+binding.lutimes(
+getValidatedPath(path),
+toUnixTimestamp(atime),
+toUnixTimestamp(mtime),
+kUsePromises,
+),
 undefined,
 handleErrorFromBinding,
 );
 }
 
 asyncfunctionrealpath(path,options){
 options=getOptions(options);
-path=getValidatedPath(path);
 returnawaitPromisePrototypeThen(
-binding.realpath(pathModule.toNamespacedPath(path),options.encoding,kUsePromises),
+binding.realpath(getValidatedPath(path),options.encoding,kUsePromises),
 undefined,
 handleErrorFromBinding,
 );

lib/internal/fs/promises.js

@@ -8,6 +8,7 @@
 #include"node_errors.h"
 #include"node_external_reference.h"
 #include"node_file.h"
+#include"path.h"
 #include"permission/permission.h"
 #include"util.h"
 #include"v8.h"
@@ -96,6 +97,7 @@ void BlobFromFilePath(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  BufferValue path(env->isolate(), args[0]);
 CHECK_NOT_NULL(*path);
+ToNamespacedPath(env, &path);
 THROW_IF_INSUFFICIENT_PERMISSIONS(
  env, permission::PermissionScope::kFileSystemRead, path.ToStringView());
 auto entry = DataQueue::CreateFdEntry(env, args[0]);