From 975f6c1f7077fd33db95eaeee6ccfa49e4a29348 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Thu, 3 May 2018 14:40:48 -0400
Subject: fs: move fs/promises to fs.promises

PR-URL: https://github.com/nodejs/node/pull/20504
Refs: https://github.com/nodejs/TSC/issues/389
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Myles Borins <myles.borins@gmail.com>
Reviewed-By: Shingo Inoue <leko.noor@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>
---
 benchmark/fs/bench-stat-promise.js                 |   2 +-
 doc/api/fs.md                                      |   4 +-
 lib/fs.js                                          |  18 +-
 lib/fs/promises.js                                 | 520 ---------------------
 lib/internal/fs.js                                 | 408 ----------------
 lib/internal/fs/promises.js                        | 517 ++++++++++++++++++++
 lib/internal/fs/utils.js                           | 408 ++++++++++++++++
 lib/internal/modules/cjs/loader.js                 |   2 +-
 lib/internal/modules/esm/default_resolve.js        |   2 +-
 lib/internal/process/stdio.js                      |   2 +-
 node.gyp                                           |   4 +-
 test/parallel/test-fs-filehandle.js                |   2 +-
 test/parallel/test-fs-open-flags.js                |   2 +-
 .../test-fs-promises-file-handle-append-file.js    |   4 +-
 .../parallel/test-fs-promises-file-handle-chmod.js |   4 +-
 test/parallel/test-fs-promises-file-handle-read.js |   4 +-
 .../test-fs-promises-file-handle-readFile.js       |   4 +-
 test/parallel/test-fs-promises-file-handle-stat.js |   4 +-
 .../parallel/test-fs-promises-file-handle-write.js |   4 +-
 .../test-fs-promises-file-handle-writeFile.js      |   4 +-
 test/parallel/test-fs-promises-readfile.js         |   2 +-
 test/parallel/test-fs-promises-writefile.js        |   2 +-
 test/parallel/test-fs-promises.js                  |   2 +-
 test/parallel/test-fs-syncwritestream.js           |   4 +-
 test/parallel/test-internal-fs-syncwritestream.js  |   2 +-
 test/parallel/test-internal-fs.js                  |   2 +-
 test/sequential/test-async-wrap-getasyncid.js      |   2 +-
 27 files changed, 974 insertions(+), 961 deletions(-)
 delete mode 100644 lib/fs/promises.js
 delete mode 100644 lib/internal/fs.js
 create mode 100644 lib/internal/fs/promises.js
 create mode 100644 lib/internal/fs/utils.js

diff --git a/benchmark/fs/bench-stat-promise.js b/benchmark/fs/bench-stat-promise.js
index b031745572..96c7058fa6 100644
--- a/benchmark/fs/bench-stat-promise.js
+++ b/benchmark/fs/bench-stat-promise.js
@@ -1,7 +1,7 @@
 'use strict';
 
 const common = require('../common');
-const fsPromises = require('fs/promises');
+const fsPromises = require('fs').promises;
 
 const bench = common.createBenchmark(main, {
   n: [20e4],
diff --git a/doc/api/fs.md b/doc/api/fs.md
index bace6d9483..30d6729d48 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3382,9 +3382,9 @@ Synchronous versions of [`fs.write()`][]. Returns the number of bytes written.
 
 > Stability: 1 - Experimental
 
-The `fs/promises` API provides an alternative set of asynchronous file system
+The `fs.promises` API provides an alternative set of asynchronous file system
 methods that return `Promise` objects rather than using callbacks. The
-API is accessible via `require('fs/promises')`.
+API is accessible via `require('fs').promises`.
 
 ### class: FileHandle
 <!-- YAML
diff --git a/lib/fs.js b/lib/fs.js
index 07bc060f35..48d2f7c7ff 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -45,7 +45,8 @@ const { Readable, Writable } = require('stream');
 const EventEmitter = require('events');
 const { FSReqWrap, statValues, kFsStatsFieldsLength } = binding;
 const { FSEvent } = process.binding('fs_event_wrap');
-const internalFS = require('internal/fs');
+const promises = require('internal/fs/promises');
+const internalFS = require('internal/fs/utils');
 const { getPathFromURL } = require('internal/url');
 const internalUtil = require('internal/util');
 const {
@@ -74,6 +75,21 @@ const {
   validateUint32
 } = require('internal/validators');
 
+let warn = true;
+
+Object.defineProperty(fs, 'promises', {
+  configurable: true,
+  enumerable: true,
+  get() {
+    if (warn) {
+      warn = false;
+      process.emitWarning('The fs.promises API is experimental',
+                          'ExperimentalWarning');
+    }
+    return promises;
+  }
+});
+
 Object.defineProperty(exports, 'constants', {
   configurable: false,
   enumerable: true,
diff --git a/lib/fs/promises.js b/lib/fs/promises.js
deleted file mode 100644
index 6ccff6933b..0000000000
--- a/lib/fs/promises.js
+++ /dev/null
@@ -1,520 +0,0 @@
-'use strict';
-
-process.emitWarning('The fs/promises API is experimental',
-                    'ExperimentalWarning');
-
-const {
-  F_OK,
-  O_SYMLINK,
-  O_WRONLY,
-  S_IFMT,
-  S_IFREG
-} = process.binding('constants').fs;
-const binding = process.binding('fs');
-const { Buffer, kMaxLength } = require('buffer');
-const {
-  ERR_FS_FILE_TOO_LARGE,
-  ERR_INVALID_ARG_TYPE,
-  ERR_METHOD_NOT_IMPLEMENTED,
-  ERR_OUT_OF_RANGE
-} = require('internal/errors').codes;
-const { getPathFromURL } = require('internal/url');
-const { isUint8Array } = require('internal/util/types');
-const {
-  copyObject,
-  getOptions,
-  getStatsFromBinding,
-  modeNum,
-  nullCheck,
-  preprocessSymlinkDestination,
-  stringToFlags,
-  stringToSymlinkType,
-  toUnixTimestamp,
-  validateBuffer,
-  validateOffsetLengthRead,
-  validateOffsetLengthWrite,
-  validatePath
-} = require('internal/fs');
-const {
-  isUint32,
-  validateInt32,
-  validateUint32
-} = require('internal/validators');
-const pathModule = require('path');
-
-const kHandle = Symbol('handle');
-const { kUsePromises } = binding;
-
-class FileHandle {
-  constructor(filehandle) {
-    this[kHandle] = filehandle;
-  }
-
-  getAsyncId() {
-    return this[kHandle].getAsyncId();
-  }
-
-  get fd() {
-    return this[kHandle].fd;
-  }
-
-  appendFile(data, options) {
-    return appendFile(this, data, options);
-  }
-
-  chmod(mode) {
-    return fchmod(this, mode);
-  }
-
-  chown(uid, gid) {
-    return fchown(this, uid, gid);
-  }
-
-  datasync() {
-    return fdatasync(this);
-  }
-
-  sync() {
-    return fsync(this);
-  }
-
-  read(buffer, offset, length, position) {
-    return read(this, buffer, offset, length, position);
-  }
-
-  readFile(options) {
-    return readFile(this, options);
-  }
-
-  stat() {
-    return fstat(this);
-  }
-
-  truncate(len = 0) {
-    return ftruncate(this, len);
-  }
-
-  utimes(atime, mtime) {
-    return futimes(this, atime, mtime);
-  }
-
-  write(buffer, offset, length, position) {
-    return write(this, buffer, offset, length, position);
-  }
-
-  writeFile(data, options) {
-    return writeFile(this, data, options);
-  }
-
-  close() {
-    return this[kHandle].close();
-  }
-}
-
-
-function validateFileHandle(handle) {
-  if (!(handle instanceof FileHandle))
-    throw new ERR_INVALID_ARG_TYPE('filehandle', 'FileHandle', handle);
-}
-
-async function writeFileHandle(filehandle, data, options) {
-  let buffer = isUint8Array(data) ?
-    data : Buffer.from('' + data, options.encoding || 'utf8');
-  let remaining = buffer.length;
-  if (remaining === 0) return;
-  do {
-    const { bytesWritten } =
-      await write(filehandle, buffer, 0,
-                  Math.min(16384, buffer.length));
-    remaining -= bytesWritten;
-    buffer = buffer.slice(bytesWritten);
-  } while (remaining > 0);
-}
-
-async function readFileHandle(filehandle, options) {
-  const statFields = await binding.fstat(filehandle.fd, kUsePromises);
-
-  let size;
-  if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {
-    size = statFields[8/* size */];
-  } else {
-    size = 0;
-  }
-
-  if (size === 0)
-    return Buffer.alloc(0);
-
-  if (size > kMaxLength)
-    throw new ERR_FS_FILE_TOO_LARGE(size);
-
-  const chunks = [];
-  const chunkSize = Math.min(size, 16384);
-  let totalRead = 0;
-  let endOfFile = false;
-  do {
-    const buf = Buffer.alloc(chunkSize);
-    const { bytesRead, buffer } =
-      await read(filehandle, buf, 0, chunkSize, totalRead);
-    totalRead += bytesRead;
-    endOfFile = bytesRead !== chunkSize;
-    if (bytesRead > 0)
-      chunks.push(buffer.slice(0, bytesRead));
-  } while (!endOfFile);
-
-  const result = Buffer.concat(chunks);
-  if (options.encoding) {
-    return result.toString(options.encoding);
-  } else {
-    return result;
-  }
-}
-
-// All of the functions are defined as async in order to ensure that errors
-// thrown cause promise rejections rather than being thrown synchronously.
-async function access(path, mode = F_OK) {
-  path = getPathFromURL(path);
-  validatePath(path);
-
-  mode = mode | 0;
-  return binding.access(pathModule.toNamespacedPath(path), mode,
-                        kUsePromises);
-}
-
-async function copyFile(src, dest, flags) {
-  src = getPathFromURL(src);
-  dest = getPathFromURL(dest);
-  validatePath(src, 'src');
-  validatePath(dest, 'dest');
-  flags = flags | 0;
-  return binding.copyFile(pathModule.toNamespacedPath(src),
-                          pathModule.toNamespacedPath(dest),
-                          flags, kUsePromises);
-}
-
-// Note that unlike fs.open() which uses numeric file descriptors,
-// fsPromises.open() uses the fs.FileHandle class.
-async function open(path, flags, mode) {
-  mode = modeNum(mode, 0o666);
-  path = getPathFromURL(path);
-  validatePath(path);
-  validateUint32(mode, 'mode');
-  return new FileHandle(
-    await binding.openFileHandle(pathModule.toNamespacedPath(path),
-                                 stringToFlags(flags),
-                                 mode, kUsePromises));
-}
-
-async function read(handle, buffer, offset, length, position) {
-  validateFileHandle(handle);
-  validateBuffer(buffer);
-
-  offset |= 0;
-  length |= 0;
-
-  if (length === 0)
-    return { bytesRead: length, buffer };
-
-  validateOffsetLengthRead(offset, length, buffer.length);
-
-  if (!isUint32(position))
-    position = -1;
-
-  const bytesRead = (await binding.read(handle.fd, buffer, offset, length,
-                                        position, kUsePromises)) || 0;
-
-  return { bytesRead, buffer };
-}
-
-async function write(handle, buffer, offset, length, position) {
-  validateFileHandle(handle);
-
-  if (buffer.length === 0)
-    return { bytesWritten: 0, buffer };
-
-  if (isUint8Array(buffer)) {
-    if (typeof offset !== 'number')
-      offset = 0;
-    if (typeof length !== 'number')
-      length = buffer.length - offset;
-    if (typeof position !== 'number')
-      position = null;
-    validateOffsetLengthWrite(offset, length, buffer.byteLength);
-    const bytesWritten =
-      (await binding.writeBuffer(handle.fd, buffer, offset,
-                                 length, position, kUsePromises)) || 0;
-    return { bytesWritten, buffer };
-  }
-
-  if (typeof buffer !== 'string')
-    buffer += '';
-  if (typeof position !== 'function') {
-    if (typeof offset === 'function') {
-      position = offset;
-      offset = null;
-    } else {
-      position = length;
-    }
-    length = 'utf8';
-  }
-  const bytesWritten = (await binding.writeString(handle.fd, buffer, offset,
-                                                  length, kUsePromises)) || 0;
-  return { bytesWritten, buffer };
-}
-
-async function rename(oldPath, newPath) {
-  oldPath = getPathFromURL(oldPath);
-  newPath = getPathFromURL(newPath);
-  validatePath(oldPath, 'oldPath');
-  validatePath(newPath, 'newPath');
-  return binding.rename(pathModule.toNamespacedPath(oldPath),
-                        pathModule.toNamespacedPath(newPath),
-                        kUsePromises);
-}
-
-async function truncate(path, len = 0) {
-  return ftruncate(await open(path, 'r+'), len);
-}
-
-async function ftruncate(handle, len = 0) {
-  validateFileHandle(handle);
-  validateInt32(len, 'len');
-  len = Math.max(0, len);
-  return binding.ftruncate(handle.fd, len, kUsePromises);
-}
-
-async function rmdir(path) {
-  path = getPathFromURL(path);
-  validatePath(path);
-  return binding.rmdir(pathModule.toNamespacedPath(path), kUsePromises);
-}
-
-async function fdatasync(handle) {
-  validateFileHandle(handle);
-  return binding.fdatasync(handle.fd, kUsePromises);
-}
-
-async function fsync(handle) {
-  validateFileHandle(handle);
-  return binding.fsync(handle.fd, kUsePromises);
-}
-
-async function mkdir(path, mode) {
-  mode = modeNum(mode, 0o777);
-  path = getPathFromURL(path);
-  validatePath(path);
-  validateUint32(mode, 'mode');
-  return binding.mkdir(pathModule.toNamespacedPath(path), mode, kUsePromises);
-}
-
-async function readdir(path, options) {
-  options = getOptions(options, {});
-  path = getPathFromURL(path);
-  validatePath(path);
-  return binding.readdir(pathModule.toNamespacedPath(path),
-                         options.encoding, kUsePromises);
-}
-
-async function readlink(path, options) {
-  options = getOptions(options, {});
-  path = getPathFromURL(path);
-  validatePath(path, 'oldPath');
-  return binding.readlink(pathModule.toNamespacedPath(path),
-                          options.encoding, kUsePromises);
-}
-
-async function symlink(target, path, type_) {
-  const type = (typeof type_ === 'string' ? type_ : null);
-  target = getPathFromURL(target);
-  path = getPathFromURL(path);
-  validatePath(target, 'target');
-  validatePath(path);
-  return binding.symlink(preprocessSymlinkDestination(target, type, path),
-                         pathModule.toNamespacedPath(path),
-                         stringToSymlinkType(type),
-                         kUsePromises);
-}
-
-async function fstat(handle) {
-  validateFileHandle(handle);
-  const result = await binding.fstat(handle.fd, kUsePromises);
-  return getStatsFromBinding(result);
-}
-
-async function lstat(path) {
-  path = getPathFromURL(path);
-  validatePath(path);
-  const result = await binding.lstat(pathModule.toNamespacedPath(path),
-                                     kUsePromises);
-  return getStatsFromBinding(result);
-}
-
-async function stat(path) {
-  path = getPathFromURL(path);
-  validatePath(path);
-  const result = await binding.stat(pathModule.toNamespacedPath(path),
-                                    kUsePromises);
-  return getStatsFromBinding(result);
-}
-
-async function link(existingPath, newPath) {
-  existingPath = getPathFromURL(existingPath);
-  newPath = getPathFromURL(newPath);
-  validatePath(existingPath, 'existingPath');
-  validatePath(newPath, 'newPath');
-  return binding.link(pathModule.toNamespacedPath(existingPath),
-                      pathModule.toNamespacedPath(newPath),
-                      kUsePromises);
-}
-
-async function unlink(path) {
-  path = getPathFromURL(path);
-  validatePath(path);
-  return binding.unlink(pathModule.toNamespacedPath(path), kUsePromises);
-}
-
-async function fchmod(handle, mode) {
-  mode = modeNum(mode);
-  validateFileHandle(handle);
-  validateUint32(mode, 'mode');
-  if (mode > 0o777)
-    throw new ERR_OUT_OF_RANGE('mode', undefined, mode);
-  return binding.fchmod(handle.fd, mode, kUsePromises);
-}
-
-async function chmod(path, mode) {
-  path = getPathFromURL(path);
-  validatePath(path);
-  mode = modeNum(mode);
-  validateUint32(mode, 'mode');
-  return binding.chmod(pathModule.toNamespacedPath(path), mode, kUsePromises);
-}
-
-async function lchmod(path, mode) {
-  if (O_SYMLINK !== undefined) {
-    const fd = await open(path,
-                          O_WRONLY | O_SYMLINK);
-    return fchmod(fd, mode).finally(fd.close.bind(fd));
-  }
-  throw new ERR_METHOD_NOT_IMPLEMENTED();
-}
-
-async function lchown(path, uid, gid) {
-  if (O_SYMLINK !== undefined) {
-    const fd = await open(path,
-                          O_WRONLY | O_SYMLINK);
-    return fchmod(fd, uid, gid).finally(fd.close.bind(fd));
-  }
-  throw new ERR_METHOD_NOT_IMPLEMENTED();
-}
-
-async function fchown(handle, uid, gid) {
-  validateFileHandle(handle);
-  validateUint32(uid, 'uid');
-  validateUint32(gid, 'gid');
-  return binding.fchown(handle.fd, uid, gid, kUsePromises);
-}
-
-async function chown(path, uid, gid) {
-  path = getPathFromURL(path);
-  validatePath(path);
-  validateUint32(uid, 'uid');
-  validateUint32(gid, 'gid');
-  return binding.chown(pathModule.toNamespacedPath(path),
-                       uid, gid, kUsePromises);
-}
-
-async function utimes(path, atime, mtime) {
-  path = getPathFromURL(path);
-  validatePath(path);
-  return binding.utimes(pathModule.toNamespacedPath(path),
-                        toUnixTimestamp(atime),
-                        toUnixTimestamp(mtime),
-                        kUsePromises);
-}
-
-async function futimes(handle, atime, mtime) {
-  validateFileHandle(handle);
-  atime = toUnixTimestamp(atime, 'atime');
-  mtime = toUnixTimestamp(mtime, 'mtime');
-  return binding.futimes(handle.fd, atime, mtime, kUsePromises);
-}
-
-async function realpath(path, options) {
-  options = getOptions(options, {});
-  path = getPathFromURL(path);
-  validatePath(path);
-  return binding.realpath(path, options.encoding, kUsePromises);
-}
-
-async function mkdtemp(prefix, options) {
-  options = getOptions(options, {});
-  if (!prefix || typeof prefix !== 'string') {
-    throw new ERR_INVALID_ARG_TYPE('prefix', 'string', prefix);
-  }
-  nullCheck(prefix);
-  return binding.mkdtemp(`${prefix}XXXXXX`, options.encoding, kUsePromises);
-}
-
-async function writeFile(path, data, options) {
-  options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
-  const flag = options.flag || 'w';
-
-  if (path instanceof FileHandle)
-    return writeFileHandle(path, data, options);
-
-  const fd = await open(path, flag, options.mode);
-  return writeFileHandle(fd, data, options).finally(fd.close.bind(fd));
-}
-
-async function appendFile(path, data, options) {
-  options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'a' });
-  options = copyObject(options);
-  options.flag = options.flag || 'a';
-  return writeFile(path, data, options);
-}
-
-async function readFile(path, options) {
-  options = getOptions(options, { flag: 'r' });
-
-  if (path instanceof FileHandle)
-    return readFileHandle(path, options);
-
-  const fd = await open(path, options.flag, 0o666);
-  return readFileHandle(fd, options).finally(fd.close.bind(fd));
-}
-
-module.exports = {
-  access,
-  copyFile,
-  open,
-  read,
-  write,
-  rename,
-  truncate,
-  ftruncate,
-  rmdir,
-  fdatasync,
-  fsync,
-  mkdir,
-  readdir,
-  readlink,
-  symlink,
-  fstat,
-  lstat,
-  stat,
-  link,
-  unlink,
-  fchmod,
-  chmod,
-  lchmod,
-  lchown,
-  fchown,
-  chown,
-  utimes,
-  futimes,
-  realpath,
-  mkdtemp,
-  writeFile,
-  appendFile,
-  readFile
-};
diff --git a/lib/internal/fs.js b/lib/internal/fs.js
deleted file mode 100644
index 2f7a8d8ced..0000000000
--- a/lib/internal/fs.js
+++ /dev/null
@@ -1,408 +0,0 @@
-'use strict';
-
-const { Buffer, kMaxLength } = require('buffer');
-const { Writable } = require('stream');
-const {
-  ERR_FS_INVALID_SYMLINK_TYPE,
-  ERR_INVALID_ARG_TYPE,
-  ERR_INVALID_ARG_VALUE,
-  ERR_INVALID_OPT_VALUE,
-  ERR_INVALID_OPT_VALUE_ENCODING,
-  ERR_OUT_OF_RANGE
-} = require('internal/errors').codes;
-const { isUint8Array } = require('internal/util/types');
-const fs = require('fs');
-const pathModule = require('path');
-const util = require('util');
-
-const {
-  O_APPEND,
-  O_CREAT,
-  O_EXCL,
-  O_RDONLY,
-  O_RDWR,
-  O_SYNC,
-  O_TRUNC,
-  O_WRONLY,
-  S_IFBLK,
-  S_IFCHR,
-  S_IFDIR,
-  S_IFIFO,
-  S_IFLNK,
-  S_IFMT,
-  S_IFREG,
-  S_IFSOCK,
-  UV_FS_SYMLINK_DIR,
-  UV_FS_SYMLINK_JUNCTION
-} = process.binding('constants').fs;
-
-const isWindows = process.platform === 'win32';
-
-function assertEncoding(encoding) {
-  if (encoding && !Buffer.isEncoding(encoding)) {
-    throw new ERR_INVALID_OPT_VALUE_ENCODING(encoding);
-  }
-}
-
-function copyObject(source) {
-  var target = {};
-  for (var key in source)
-    target[key] = source[key];
-  return target;
-}
-
-function getOptions(options, defaultOptions) {
-  if (options === null || options === undefined ||
-      typeof options === 'function') {
-    return defaultOptions;
-  }
-
-  if (typeof options === 'string') {
-    defaultOptions = util._extend({}, defaultOptions);
-    defaultOptions.encoding = options;
-    options = defaultOptions;
-  } else if (typeof options !== 'object') {
-    throw new ERR_INVALID_ARG_TYPE('options', ['string', 'Object'], options);
-  }
-
-  if (options.encoding !== 'buffer')
-    assertEncoding(options.encoding);
-  return options;
-}
-
-function modeNum(m, def) {
-  if (typeof m === 'number')
-    return m;
-  if (typeof m === 'string') {
-    const parsed = parseInt(m, 8);
-    if (Number.isNaN(parsed))
-      return m;
-    return parsed;
-  }
-  // TODO(BridgeAR): Only return `def` in case `m == null`
-  if (def !== undefined)
-    return def;
-  return m;
-}
-
-// Check if the path contains null types if it is a string nor Uint8Array,
-// otherwise return silently.
-function nullCheck(path, propName, throwError = true) {
-  const pathIsString = typeof path === 'string';
-  const pathIsUint8Array = isUint8Array(path);
-
-  // We can only perform meaningful checks on strings and Uint8Arrays.
-  if (!pathIsString && !pathIsUint8Array) {
-    return;
-  }
-
-  if (pathIsString && path.indexOf('\u0000') === -1) {
-    return;
-  } else if (pathIsUint8Array && path.indexOf(0) === -1) {
-    return;
-  }
-
-  const err = new ERR_INVALID_ARG_VALUE(
-    propName,
-    path,
-    'must be a string or Uint8Array without null bytes'
-  );
-
-  if (throwError) {
-    Error.captureStackTrace(err, nullCheck);
-    throw err;
-  }
-  return err;
-}
-
-function preprocessSymlinkDestination(path, type, linkPath) {
-  if (!isWindows) {
-    // No preprocessing is needed on Unix.
-    return path;
-  } else if (type === 'junction') {
-    // Junctions paths need to be absolute and \\?\-prefixed.
-    // A relative target is relative to the link's parent directory.
-    path = pathModule.resolve(linkPath, '..', path);
-    return pathModule.toNamespacedPath(path);
-  } else {
-    // Windows symlinks don't tolerate forward slashes.
-    return ('' + path).replace(/\//g, '\\');
-  }
-}
-
-function dateFromNumeric(num) {
-  return new Date(num + 0.5);
-}
-
-// Constructor for file stats.
-function Stats(
-  dev,
-  mode,
-  nlink,
-  uid,
-  gid,
-  rdev,
-  blksize,
-  ino,
-  size,
-  blocks,
-  atim_msec,
-  mtim_msec,
-  ctim_msec,
-  birthtim_msec
-) {
-  this.dev = dev;
-  this.mode = mode;
-  this.nlink = nlink;
-  this.uid = uid;
-  this.gid = gid;
-  this.rdev = rdev;
-  this.blksize = blksize;
-  this.ino = ino;
-  this.size = size;
-  this.blocks = blocks;
-  this.atimeMs = atim_msec;
-  this.mtimeMs = mtim_msec;
-  this.ctimeMs = ctim_msec;
-  this.birthtimeMs = birthtim_msec;
-  this.atime = dateFromNumeric(atim_msec);
-  this.mtime = dateFromNumeric(mtim_msec);
-  this.ctime = dateFromNumeric(ctim_msec);
-  this.birthtime = dateFromNumeric(birthtim_msec);
-}
-
-Stats.prototype._checkModeProperty = function(property) {
-  return ((this.mode & S_IFMT) === property);
-};
-
-Stats.prototype.isDirectory = function() {
-  return this._checkModeProperty(S_IFDIR);
-};
-
-Stats.prototype.isFile = function() {
-  return this._checkModeProperty(S_IFREG);
-};
-
-Stats.prototype.isBlockDevice = function() {
-  return this._checkModeProperty(S_IFBLK);
-};
-
-Stats.prototype.isCharacterDevice = function() {
-  return this._checkModeProperty(S_IFCHR);
-};
-
-Stats.prototype.isSymbolicLink = function() {
-  return this._checkModeProperty(S_IFLNK);
-};
-
-Stats.prototype.isFIFO = function() {
-  return this._checkModeProperty(S_IFIFO);
-};
-
-Stats.prototype.isSocket = function() {
-  return this._checkModeProperty(S_IFSOCK);
-};
-
-function getStatsFromBinding(stats, offset = 0) {
-  return new Stats(stats[0 + offset], stats[1 + offset], stats[2 + offset],
-                   stats[3 + offset], stats[4 + offset], stats[5 + offset],
-                   stats[6 + offset] < 0 ? undefined : stats[6 + offset],
-                   stats[7 + offset], stats[8 + offset],
-                   stats[9 + offset] < 0 ? undefined : stats[9 + offset],
-                   stats[10 + offset], stats[11 + offset],
-                   stats[12 + offset], stats[13 + offset]);
-}
-
-function stringToFlags(flags) {
-  if (typeof flags === 'number') {
-    return flags;
-  }
-
-  switch (flags) {
-    case 'r' : return O_RDONLY;
-    case 'rs' : // Fall through.
-    case 'sr' : return O_RDONLY | O_SYNC;
-    case 'r+' : return O_RDWR;
-    case 'rs+' : // Fall through.
-    case 'sr+' : return O_RDWR | O_SYNC;
-
-    case 'w' : return O_TRUNC | O_CREAT | O_WRONLY;
-    case 'wx' : // Fall through.
-    case 'xw' : return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
-
-    case 'w+' : return O_TRUNC | O_CREAT | O_RDWR;
-    case 'wx+': // Fall through.
-    case 'xw+': return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
-
-    case 'a' : return O_APPEND | O_CREAT | O_WRONLY;
-    case 'ax' : // Fall through.
-    case 'xa' : return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;
-    case 'as' : // Fall through.
-    case 'sa' : return O_APPEND | O_CREAT | O_WRONLY | O_SYNC;
-
-    case 'a+' : return O_APPEND | O_CREAT | O_RDWR;
-    case 'ax+': // Fall through.
-    case 'xa+': return O_APPEND | O_CREAT | O_RDWR | O_EXCL;
-    case 'as+': // Fall through.
-    case 'sa+': return O_APPEND | O_CREAT | O_RDWR | O_SYNC;
-  }
-
-  throw new ERR_INVALID_OPT_VALUE('flags', flags);
-}
-
-function stringToSymlinkType(type) {
-  let flags = 0;
-  if (typeof type === 'string') {
-    switch (type) {
-      case 'dir':
-        flags |= UV_FS_SYMLINK_DIR;
-        break;
-      case 'junction':
-        flags |= UV_FS_SYMLINK_JUNCTION;
-        break;
-      case 'file':
-        break;
-      default:
-        const err = new ERR_FS_INVALID_SYMLINK_TYPE(type);
-        Error.captureStackTrace(err, stringToSymlinkType);
-        throw err;
-    }
-  }
-  return flags;
-}
-
-// Temporary hack for process.stdout and process.stderr when piped to files.
-function SyncWriteStream(fd, options) {
-  Writable.call(this);
-
-  options = options || {};
-
-  this.fd = fd;
-  this.readable = false;
-  this.autoClose = options.autoClose === undefined ? true : options.autoClose;
-
-  this.on('end', () => this._destroy());
-}
-
-util.inherits(SyncWriteStream, Writable);
-
-SyncWriteStream.prototype._write = function(chunk, encoding, cb) {
-  fs.writeSync(this.fd, chunk, 0, chunk.length);
-  cb();
-  return true;
-};
-
-SyncWriteStream.prototype._destroy = function() {
-  if (this.fd === null) // already destroy()ed
-    return;
-
-  if (this.autoClose)
-    fs.closeSync(this.fd);
-
-  this.fd = null;
-  return true;
-};
-
-SyncWriteStream.prototype.destroySoon =
-SyncWriteStream.prototype.destroy = function() {
-  this._destroy();
-  this.emit('close');
-  return true;
-};
-
-// converts Date or number to a fractional UNIX timestamp
-function toUnixTimestamp(time, name = 'time') {
-  // eslint-disable-next-line eqeqeq
-  if (typeof time === 'string' && +time == time) {
-    return +time;
-  }
-  if (Number.isFinite(time)) {
-    if (time < 0) {
-      return Date.now() / 1000;
-    }
-    return time;
-  }
-  if (util.isDate(time)) {
-    // convert to 123.456 UNIX timestamp
-    return time.getTime() / 1000;
-  }
-  throw new ERR_INVALID_ARG_TYPE(name, ['Date', 'Time in seconds'], time);
-}
-
-function validateBuffer(buffer) {
-  if (!isUint8Array(buffer)) {
-    const err = new ERR_INVALID_ARG_TYPE('buffer',
-                                         ['Buffer', 'Uint8Array'], buffer);
-    Error.captureStackTrace(err, validateBuffer);
-    throw err;
-  }
-}
-
-function validateOffsetLengthRead(offset, length, bufferLength) {
-  let err;
-
-  if (offset < 0 || offset >= bufferLength) {
-    err = new ERR_OUT_OF_RANGE('offset', `>= 0 && <= ${bufferLength}`, offset);
-  } else if (length < 0 || offset + length > bufferLength) {
-    err = new ERR_OUT_OF_RANGE('length',
-                               `>= 0 && <= ${bufferLength - offset}`, length);
-  }
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validateOffsetLengthRead);
-    throw err;
-  }
-}
-
-function validateOffsetLengthWrite(offset, length, byteLength) {
-  let err;
-
-  if (offset > byteLength) {
-    err = new ERR_OUT_OF_RANGE('offset', `<= ${byteLength}`, offset);
-  } else {
-    const max = byteLength > kMaxLength ? kMaxLength : byteLength;
-    if (length > max - offset) {
-      err = new ERR_OUT_OF_RANGE('length', `<= ${max - offset}`, length);
-    }
-  }
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validateOffsetLengthWrite);
-    throw err;
-  }
-}
-
-function validatePath(path, propName = 'path') {
-  let err;
-
-  if (typeof path !== 'string' && !isUint8Array(path)) {
-    err = new ERR_INVALID_ARG_TYPE(propName, ['string', 'Buffer', 'URL'], path);
-  } else {
-    err = nullCheck(path, propName, false);
-  }
-
-  if (err !== undefined) {
-    Error.captureStackTrace(err, validatePath);
-    throw err;
-  }
-}
-
-module.exports = {
-  assertEncoding,
-  copyObject,
-  getOptions,
-  modeNum,
-  nullCheck,
-  preprocessSymlinkDestination,
-  realpathCacheKey: Symbol('realpathCacheKey'),
-  getStatsFromBinding,
-  stringToFlags,
-  stringToSymlinkType,
-  Stats,
-  SyncWriteStream,
-  toUnixTimestamp,
-  validateBuffer,
-  validateOffsetLengthRead,
-  validateOffsetLengthWrite,
-  validatePath
-};
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
new file mode 100644
index 0000000000..6b523473e4
--- /dev/null
+++ b/lib/internal/fs/promises.js
@@ -0,0 +1,517 @@
+'use strict';
+
+const {
+  F_OK,
+  O_SYMLINK,
+  O_WRONLY,
+  S_IFMT,
+  S_IFREG
+} = process.binding('constants').fs;
+const binding = process.binding('fs');
+const { Buffer, kMaxLength } = require('buffer');
+const {
+  ERR_FS_FILE_TOO_LARGE,
+  ERR_INVALID_ARG_TYPE,
+  ERR_METHOD_NOT_IMPLEMENTED,
+  ERR_OUT_OF_RANGE
+} = require('internal/errors').codes;
+const { getPathFromURL } = require('internal/url');
+const { isUint8Array } = require('internal/util/types');
+const {
+  copyObject,
+  getOptions,
+  getStatsFromBinding,
+  modeNum,
+  nullCheck,
+  preprocessSymlinkDestination,
+  stringToFlags,
+  stringToSymlinkType,
+  toUnixTimestamp,
+  validateBuffer,
+  validateOffsetLengthRead,
+  validateOffsetLengthWrite,
+  validatePath
+} = require('internal/fs/utils');
+const {
+  isUint32,
+  validateInt32,
+  validateUint32
+} = require('internal/validators');
+const pathModule = require('path');
+
+const kHandle = Symbol('handle');
+const { kUsePromises } = binding;
+
+class FileHandle {
+  constructor(filehandle) {
+    this[kHandle] = filehandle;
+  }
+
+  getAsyncId() {
+    return this[kHandle].getAsyncId();
+  }
+
+  get fd() {
+    return this[kHandle].fd;
+  }
+
+  appendFile(data, options) {
+    return appendFile(this, data, options);
+  }
+
+  chmod(mode) {
+    return fchmod(this, mode);
+  }
+
+  chown(uid, gid) {
+    return fchown(this, uid, gid);
+  }
+
+  datasync() {
+    return fdatasync(this);
+  }
+
+  sync() {
+    return fsync(this);
+  }
+
+  read(buffer, offset, length, position) {
+    return read(this, buffer, offset, length, position);
+  }
+
+  readFile(options) {
+    return readFile(this, options);
+  }
+
+  stat() {
+    return fstat(this);
+  }
+
+  truncate(len = 0) {
+    return ftruncate(this, len);
+  }
+
+  utimes(atime, mtime) {
+    return futimes(this, atime, mtime);
+  }
+
+  write(buffer, offset, length, position) {
+    return write(this, buffer, offset, length, position);
+  }
+
+  writeFile(data, options) {
+    return writeFile(this, data, options);
+  }
+
+  close() {
+    return this[kHandle].close();
+  }
+}
+
+
+function validateFileHandle(handle) {
+  if (!(handle instanceof FileHandle))
+    throw new ERR_INVALID_ARG_TYPE('filehandle', 'FileHandle', handle);
+}
+
+async function writeFileHandle(filehandle, data, options) {
+  let buffer = isUint8Array(data) ?
+    data : Buffer.from('' + data, options.encoding || 'utf8');
+  let remaining = buffer.length;
+  if (remaining === 0) return;
+  do {
+    const { bytesWritten } =
+      await write(filehandle, buffer, 0,
+                  Math.min(16384, buffer.length));
+    remaining -= bytesWritten;
+    buffer = buffer.slice(bytesWritten);
+  } while (remaining > 0);
+}
+
+async function readFileHandle(filehandle, options) {
+  const statFields = await binding.fstat(filehandle.fd, kUsePromises);
+
+  let size;
+  if ((statFields[1/* mode */] & S_IFMT) === S_IFREG) {
+    size = statFields[8/* size */];
+  } else {
+    size = 0;
+  }
+
+  if (size === 0)
+    return Buffer.alloc(0);
+
+  if (size > kMaxLength)
+    throw new ERR_FS_FILE_TOO_LARGE(size);
+
+  const chunks = [];
+  const chunkSize = Math.min(size, 16384);
+  let totalRead = 0;
+  let endOfFile = false;
+  do {
+    const buf = Buffer.alloc(chunkSize);
+    const { bytesRead, buffer } =
+      await read(filehandle, buf, 0, chunkSize, totalRead);
+    totalRead += bytesRead;
+    endOfFile = bytesRead !== chunkSize;
+    if (bytesRead > 0)
+      chunks.push(buffer.slice(0, bytesRead));
+  } while (!endOfFile);
+
+  const result = Buffer.concat(chunks);
+  if (options.encoding) {
+    return result.toString(options.encoding);
+  } else {
+    return result;
+  }
+}
+
+// All of the functions are defined as async in order to ensure that errors
+// thrown cause promise rejections rather than being thrown synchronously.
+async function access(path, mode = F_OK) {
+  path = getPathFromURL(path);
+  validatePath(path);
+
+  mode = mode | 0;
+  return binding.access(pathModule.toNamespacedPath(path), mode,
+                        kUsePromises);
+}
+
+async function copyFile(src, dest, flags) {
+  src = getPathFromURL(src);
+  dest = getPathFromURL(dest);
+  validatePath(src, 'src');
+  validatePath(dest, 'dest');
+  flags = flags | 0;
+  return binding.copyFile(pathModule.toNamespacedPath(src),
+                          pathModule.toNamespacedPath(dest),
+                          flags, kUsePromises);
+}
+
+// Note that unlike fs.open() which uses numeric file descriptors,
+// fsPromises.open() uses the fs.FileHandle class.
+async function open(path, flags, mode) {
+  mode = modeNum(mode, 0o666);
+  path = getPathFromURL(path);
+  validatePath(path);
+  validateUint32(mode, 'mode');
+  return new FileHandle(
+    await binding.openFileHandle(pathModule.toNamespacedPath(path),
+                                 stringToFlags(flags),
+                                 mode, kUsePromises));
+}
+
+async function read(handle, buffer, offset, length, position) {
+  validateFileHandle(handle);
+  validateBuffer(buffer);
+
+  offset |= 0;
+  length |= 0;
+
+  if (length === 0)
+    return { bytesRead: length, buffer };
+
+  validateOffsetLengthRead(offset, length, buffer.length);
+
+  if (!isUint32(position))
+    position = -1;
+
+  const bytesRead = (await binding.read(handle.fd, buffer, offset, length,
+                                        position, kUsePromises)) || 0;
+
+  return { bytesRead, buffer };
+}
+
+async function write(handle, buffer, offset, length, position) {
+  validateFileHandle(handle);
+
+  if (buffer.length === 0)
+    return { bytesWritten: 0, buffer };
+
+  if (isUint8Array(buffer)) {
+    if (typeof offset !== 'number')
+      offset = 0;
+    if (typeof length !== 'number')
+      length = buffer.length - offset;
+    if (typeof position !== 'number')
+      position = null;
+    validateOffsetLengthWrite(offset, length, buffer.byteLength);
+    const bytesWritten =
+      (await binding.writeBuffer(handle.fd, buffer, offset,
+                                 length, position, kUsePromises)) || 0;
+    return { bytesWritten, buffer };
+  }
+
+  if (typeof buffer !== 'string')
+    buffer += '';
+  if (typeof position !== 'function') {
+    if (typeof offset === 'function') {
+      position = offset;
+      offset = null;
+    } else {
+      position = length;
+    }
+    length = 'utf8';
+  }
+  const bytesWritten = (await binding.writeString(handle.fd, buffer, offset,
+                                                  length, kUsePromises)) || 0;
+  return { bytesWritten, buffer };
+}
+
+async function rename(oldPath, newPath) {
+  oldPath = getPathFromURL(oldPath);
+  newPath = getPathFromURL(newPath);
+  validatePath(oldPath, 'oldPath');
+  validatePath(newPath, 'newPath');
+  return binding.rename(pathModule.toNamespacedPath(oldPath),
+                        pathModule.toNamespacedPath(newPath),
+                        kUsePromises);
+}
+
+async function truncate(path, len = 0) {
+  return ftruncate(await open(path, 'r+'), len);
+}
+
+async function ftruncate(handle, len = 0) {
+  validateFileHandle(handle);
+  validateInt32(len, 'len');
+  len = Math.max(0, len);
+  return binding.ftruncate(handle.fd, len, kUsePromises);
+}
+
+async function rmdir(path) {
+  path = getPathFromURL(path);
+  validatePath(path);
+  return binding.rmdir(pathModule.toNamespacedPath(path), kUsePromises);
+}
+
+async function fdatasync(handle) {
+  validateFileHandle(handle);
+  return binding.fdatasync(handle.fd, kUsePromises);
+}
+
+async function fsync(handle) {
+  validateFileHandle(handle);
+  return binding.fsync(handle.fd, kUsePromises);
+}
+
+async function mkdir(path, mode) {
+  mode = modeNum(mode, 0o777);
+  path = getPathFromURL(path);
+  validatePath(path);
+  validateUint32(mode, 'mode');
+  return binding.mkdir(pathModule.toNamespacedPath(path), mode, kUsePromises);
+}
+
+async function readdir(path, options) {
+  options = getOptions(options, {});
+  path = getPathFromURL(path);
+  validatePath(path);
+  return binding.readdir(pathModule.toNamespacedPath(path),
+                         options.encoding, kUsePromises);
+}
+
+async function readlink(path, options) {
+  options = getOptions(options, {});
+  path = getPathFromURL(path);
+  validatePath(path, 'oldPath');
+  return binding.readlink(pathModule.toNamespacedPath(path),
+                          options.encoding, kUsePromises);
+}
+
+async function symlink(target, path, type_) {
+  const type = (typeof type_ === 'string' ? type_ : null);
+  target = getPathFromURL(target);
+  path = getPathFromURL(path);
+  validatePath(target, 'target');
+  validatePath(path);
+  return binding.symlink(preprocessSymlinkDestination(target, type, path),
+                         pathModule.toNamespacedPath(path),
+                         stringToSymlinkType(type),
+                         kUsePromises);
+}
+
+async function fstat(handle) {
+  validateFileHandle(handle);
+  const result = await binding.fstat(handle.fd, kUsePromises);
+  return getStatsFromBinding(result);
+}
+
+async function lstat(path) {
+  path = getPathFromURL(path);
+  validatePath(path);
+  const result = await binding.lstat(pathModule.toNamespacedPath(path),
+                                     kUsePromises);
+  return getStatsFromBinding(result);
+}
+
+async function stat(path) {
+  path = getPathFromURL(path);
+  validatePath(path);
+  const result = await binding.stat(pathModule.toNamespacedPath(path),
+                                    kUsePromises);
+  return getStatsFromBinding(result);
+}
+
+async function link(existingPath, newPath) {
+  existingPath = getPathFromURL(existingPath);
+  newPath = getPathFromURL(newPath);
+  validatePath(existingPath, 'existingPath');
+  validatePath(newPath, 'newPath');
+  return binding.link(pathModule.toNamespacedPath(existingPath),
+                      pathModule.toNamespacedPath(newPath),
+                      kUsePromises);
+}
+
+async function unlink(path) {
+  path = getPathFromURL(path);
+  validatePath(path);
+  return binding.unlink(pathModule.toNamespacedPath(path), kUsePromises);
+}
+
+async function fchmod(handle, mode) {
+  mode = modeNum(mode);
+  validateFileHandle(handle);
+  validateUint32(mode, 'mode');
+  if (mode > 0o777)
+    throw new ERR_OUT_OF_RANGE('mode', undefined, mode);
+  return binding.fchmod(handle.fd, mode, kUsePromises);
+}
+
+async function chmod(path, mode) {
+  path = getPathFromURL(path);
+  validatePath(path);
+  mode = modeNum(mode);
+  validateUint32(mode, 'mode');
+  return binding.chmod(pathModule.toNamespacedPath(path), mode, kUsePromises);
+}
+
+async function lchmod(path, mode) {
+  if (O_SYMLINK !== undefined) {
+    const fd = await open(path,
+                          O_WRONLY | O_SYMLINK);
+    return fchmod(fd, mode).finally(fd.close.bind(fd));
+  }
+  throw new ERR_METHOD_NOT_IMPLEMENTED();
+}
+
+async function lchown(path, uid, gid) {
+  if (O_SYMLINK !== undefined) {
+    const fd = await open(path,
+                          O_WRONLY | O_SYMLINK);
+    return fchmod(fd, uid, gid).finally(fd.close.bind(fd));
+  }
+  throw new ERR_METHOD_NOT_IMPLEMENTED();
+}
+
+async function fchown(handle, uid, gid) {
+  validateFileHandle(handle);
+  validateUint32(uid, 'uid');
+  validateUint32(gid, 'gid');
+  return binding.fchown(handle.fd, uid, gid, kUsePromises);
+}
+
+async function chown(path, uid, gid) {
+  path = getPathFromURL(path);
+  validatePath(path);
+  validateUint32(uid, 'uid');
+  validateUint32(gid, 'gid');
+  return binding.chown(pathModule.toNamespacedPath(path),
+                       uid, gid, kUsePromises);
+}
+
+async function utimes(path, atime, mtime) {
+  path = getPathFromURL(path);
+  validatePath(path);
+  return binding.utimes(pathModule.toNamespacedPath(path),
+                        toUnixTimestamp(atime),
+                        toUnixTimestamp(mtime),
+                        kUsePromises);
+}
+
+async function futimes(handle, atime, mtime) {
+  validateFileHandle(handle);
+  atime = toUnixTimestamp(atime, 'atime');
+  mtime = toUnixTimestamp(mtime, 'mtime');
+  return binding.futimes(handle.fd, atime, mtime, kUsePromises);
+}
+
+async function realpath(path, options) {
+  options = getOptions(options, {});
+  path = getPathFromURL(path);
+  validatePath(path);
+  return binding.realpath(path, options.encoding, kUsePromises);
+}
+
+async function mkdtemp(prefix, options) {
+  options = getOptions(options, {});
+  if (!prefix || typeof prefix !== 'string') {
+    throw new ERR_INVALID_ARG_TYPE('prefix', 'string', prefix);
+  }
+  nullCheck(prefix);
+  return binding.mkdtemp(`${prefix}XXXXXX`, options.encoding, kUsePromises);
+}
+
+async function writeFile(path, data, options) {
+  options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
+  const flag = options.flag || 'w';
+
+  if (path instanceof FileHandle)
+    return writeFileHandle(path, data, options);
+
+  const fd = await open(path, flag, options.mode);
+  return writeFileHandle(fd, data, options).finally(fd.close.bind(fd));
+}
+
+async function appendFile(path, data, options) {
+  options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'a' });
+  options = copyObject(options);
+  options.flag = options.flag || 'a';
+  return writeFile(path, data, options);
+}
+
+async function readFile(path, options) {
+  options = getOptions(options, { flag: 'r' });
+
+  if (path instanceof FileHandle)
+    return readFileHandle(path, options);
+
+  const fd = await open(path, options.flag, 0o666);
+  return readFileHandle(fd, options).finally(fd.close.bind(fd));
+}
+
+module.exports = {
+  access,
+  copyFile,
+  open,
+  read,
+  write,
+  rename,
+  truncate,
+  ftruncate,
+  rmdir,
+  fdatasync,
+  fsync,
+  mkdir,
+  readdir,
+  readlink,
+  symlink,
+  fstat,
+  lstat,
+  stat,
+  link,
+  unlink,
+  fchmod,
+  chmod,
+  lchmod,
+  lchown,
+  fchown,
+  chown,
+  utimes,
+  futimes,
+  realpath,
+  mkdtemp,
+  writeFile,
+  appendFile,
+  readFile
+};
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
new file mode 100644
index 0000000000..2f7a8d8ced
--- /dev/null
+++ b/lib/internal/fs/utils.js
@@ -0,0 +1,408 @@
+'use strict';
+
+const { Buffer, kMaxLength } = require('buffer');
+const { Writable } = require('stream');
+const {
+  ERR_FS_INVALID_SYMLINK_TYPE,
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_ARG_VALUE,
+  ERR_INVALID_OPT_VALUE,
+  ERR_INVALID_OPT_VALUE_ENCODING,
+  ERR_OUT_OF_RANGE
+} = require('internal/errors').codes;
+const { isUint8Array } = require('internal/util/types');
+const fs = require('fs');
+const pathModule = require('path');
+const util = require('util');
+
+const {
+  O_APPEND,
+  O_CREAT,
+  O_EXCL,
+  O_RDONLY,
+  O_RDWR,
+  O_SYNC,
+  O_TRUNC,
+  O_WRONLY,
+  S_IFBLK,
+  S_IFCHR,
+  S_IFDIR,
+  S_IFIFO,
+  S_IFLNK,
+  S_IFMT,
+  S_IFREG,
+  S_IFSOCK,
+  UV_FS_SYMLINK_DIR,
+  UV_FS_SYMLINK_JUNCTION
+} = process.binding('constants').fs;
+
+const isWindows = process.platform === 'win32';
+
+function assertEncoding(encoding) {
+  if (encoding && !Buffer.isEncoding(encoding)) {
+    throw new ERR_INVALID_OPT_VALUE_ENCODING(encoding);
+  }
+}
+
+function copyObject(source) {
+  var target = {};
+  for (var key in source)
+    target[key] = source[key];
+  return target;
+}
+
+function getOptions(options, defaultOptions) {
+  if (options === null || options === undefined ||
+      typeof options === 'function') {
+    return defaultOptions;
+  }
+
+  if (typeof options === 'string') {
+    defaultOptions = util._extend({}, defaultOptions);
+    defaultOptions.encoding = options;
+    options = defaultOptions;
+  } else if (typeof options !== 'object') {
+    throw new ERR_INVALID_ARG_TYPE('options', ['string', 'Object'], options);
+  }
+
+  if (options.encoding !== 'buffer')
+    assertEncoding(options.encoding);
+  return options;
+}
+
+function modeNum(m, def) {
+  if (typeof m === 'number')
+    return m;
+  if (typeof m === 'string') {
+    const parsed = parseInt(m, 8);
+    if (Number.isNaN(parsed))
+      return m;
+    return parsed;
+  }
+  // TODO(BridgeAR): Only return `def` in case `m == null`
+  if (def !== undefined)
+    return def;
+  return m;
+}
+
+// Check if the path contains null types if it is a string nor Uint8Array,
+// otherwise return silently.
+function nullCheck(path, propName, throwError = true) {
+  const pathIsString = typeof path === 'string';
+  const pathIsUint8Array = isUint8Array(path);
+
+  // We can only perform meaningful checks on strings and Uint8Arrays.
+  if (!pathIsString && !pathIsUint8Array) {
+    return;
+  }
+
+  if (pathIsString && path.indexOf('\u0000') === -1) {
+    return;
+  } else if (pathIsUint8Array && path.indexOf(0) === -1) {
+    return;
+  }
+
+  const err = new ERR_INVALID_ARG_VALUE(
+    propName,
+    path,
+    'must be a string or Uint8Array without null bytes'
+  );
+
+  if (throwError) {
+    Error.captureStackTrace(err, nullCheck);
+    throw err;
+  }
+  return err;
+}
+
+function preprocessSymlinkDestination(path, type, linkPath) {
+  if (!isWindows) {
+    // No preprocessing is needed on Unix.
+    return path;
+  } else if (type === 'junction') {
+    // Junctions paths need to be absolute and \\?\-prefixed.
+    // A relative target is relative to the link's parent directory.
+    path = pathModule.resolve(linkPath, '..', path);
+    return pathModule.toNamespacedPath(path);
+  } else {
+    // Windows symlinks don't tolerate forward slashes.
+    return ('' + path).replace(/\//g, '\\');
+  }
+}
+
+function dateFromNumeric(num) {
+  return new Date(num + 0.5);
+}
+
+// Constructor for file stats.
+function Stats(
+  dev,
+  mode,
+  nlink,
+  uid,
+  gid,
+  rdev,
+  blksize,
+  ino,
+  size,
+  blocks,
+  atim_msec,
+  mtim_msec,
+  ctim_msec,
+  birthtim_msec
+) {
+  this.dev = dev;
+  this.mode = mode;
+  this.nlink = nlink;
+  this.uid = uid;
+  this.gid = gid;
+  this.rdev = rdev;
+  this.blksize = blksize;
+  this.ino = ino;
+  this.size = size;
+  this.blocks = blocks;
+  this.atimeMs = atim_msec;
+  this.mtimeMs = mtim_msec;
+  this.ctimeMs = ctim_msec;
+  this.birthtimeMs = birthtim_msec;
+  this.atime = dateFromNumeric(atim_msec);
+  this.mtime = dateFromNumeric(mtim_msec);
+  this.ctime = dateFromNumeric(ctim_msec);
+  this.birthtime = dateFromNumeric(birthtim_msec);
+}
+
+Stats.prototype._checkModeProperty = function(property) {
+  return ((this.mode & S_IFMT) === property);
+};
+
+Stats.prototype.isDirectory = function() {
+  return this._checkModeProperty(S_IFDIR);
+};
+
+Stats.prototype.isFile = function() {
+  return this._checkModeProperty(S_IFREG);
+};
+
+Stats.prototype.isBlockDevice = function() {
+  return this._checkModeProperty(S_IFBLK);
+};
+
+Stats.prototype.isCharacterDevice = function() {
+  return this._checkModeProperty(S_IFCHR);
+};
+
+Stats.prototype.isSymbolicLink = function() {
+  return this._checkModeProperty(S_IFLNK);
+};
+
+Stats.prototype.isFIFO = function() {
+  return this._checkModeProperty(S_IFIFO);
+};
+
+Stats.prototype.isSocket = function() {
+  return this._checkModeProperty(S_IFSOCK);
+};
+
+function getStatsFromBinding(stats, offset = 0) {
+  return new Stats(stats[0 + offset], stats[1 + offset], stats[2 + offset],
+                   stats[3 + offset], stats[4 + offset], stats[5 + offset],
+                   stats[6 + offset] < 0 ? undefined : stats[6 + offset],
+                   stats[7 + offset], stats[8 + offset],
+                   stats[9 + offset] < 0 ? undefined : stats[9 + offset],
+                   stats[10 + offset], stats[11 + offset],
+                   stats[12 + offset], stats[13 + offset]);
+}
+
+function stringToFlags(flags) {
+  if (typeof flags === 'number') {
+    return flags;
+  }
+
+  switch (flags) {
+    case 'r' : return O_RDONLY;
+    case 'rs' : // Fall through.
+    case 'sr' : return O_RDONLY | O_SYNC;
+    case 'r+' : return O_RDWR;
+    case 'rs+' : // Fall through.
+    case 'sr+' : return O_RDWR | O_SYNC;
+
+    case 'w' : return O_TRUNC | O_CREAT | O_WRONLY;
+    case 'wx' : // Fall through.
+    case 'xw' : return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
+
+    case 'w+' : return O_TRUNC | O_CREAT | O_RDWR;
+    case 'wx+': // Fall through.
+    case 'xw+': return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
+
+    case 'a' : return O_APPEND | O_CREAT | O_WRONLY;
+    case 'ax' : // Fall through.
+    case 'xa' : return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;
+    case 'as' : // Fall through.
+    case 'sa' : return O_APPEND | O_CREAT | O_WRONLY | O_SYNC;
+
+    case 'a+' : return O_APPEND | O_CREAT | O_RDWR;
+    case 'ax+': // Fall through.
+    case 'xa+': return O_APPEND | O_CREAT | O_RDWR | O_EXCL;
+    case 'as+': // Fall through.
+    case 'sa+': return O_APPEND | O_CREAT | O_RDWR | O_SYNC;
+  }
+
+  throw new ERR_INVALID_OPT_VALUE('flags', flags);
+}
+
+function stringToSymlinkType(type) {
+  let flags = 0;
+  if (typeof type === 'string') {
+    switch (type) {
+      case 'dir':
+        flags |= UV_FS_SYMLINK_DIR;
+        break;
+      case 'junction':
+        flags |= UV_FS_SYMLINK_JUNCTION;
+        break;
+      case 'file':
+        break;
+      default:
+        const err = new ERR_FS_INVALID_SYMLINK_TYPE(type);
+        Error.captureStackTrace(err, stringToSymlinkType);
+        throw err;
+    }
+  }
+  return flags;
+}
+
+// Temporary hack for process.stdout and process.stderr when piped to files.
+function SyncWriteStream(fd, options) {
+  Writable.call(this);
+
+  options = options || {};
+
+  this.fd = fd;
+  this.readable = false;
+  this.autoClose = options.autoClose === undefined ? true : options.autoClose;
+
+  this.on('end', () => this._destroy());
+}
+
+util.inherits(SyncWriteStream, Writable);
+
+SyncWriteStream.prototype._write = function(chunk, encoding, cb) {
+  fs.writeSync(this.fd, chunk, 0, chunk.length);
+  cb();
+  return true;
+};
+
+SyncWriteStream.prototype._destroy = function() {
+  if (this.fd === null) // already destroy()ed
+    return;
+
+  if (this.autoClose)
+    fs.closeSync(this.fd);
+
+  this.fd = null;
+  return true;
+};
+
+SyncWriteStream.prototype.destroySoon =
+SyncWriteStream.prototype.destroy = function() {
+  this._destroy();
+  this.emit('close');
+  return true;
+};
+
+// converts Date or number to a fractional UNIX timestamp
+function toUnixTimestamp(time, name = 'time') {
+  // eslint-disable-next-line eqeqeq
+  if (typeof time === 'string' && +time == time) {
+    return +time;
+  }
+  if (Number.isFinite(time)) {
+    if (time < 0) {
+      return Date.now() / 1000;
+    }
+    return time;
+  }
+  if (util.isDate(time)) {
+    // convert to 123.456 UNIX timestamp
+    return time.getTime() / 1000;
+  }
+  throw new ERR_INVALID_ARG_TYPE(name, ['Date', 'Time in seconds'], time);
+}
+
+function validateBuffer(buffer) {
+  if (!isUint8Array(buffer)) {
+    const err = new ERR_INVALID_ARG_TYPE('buffer',
+                                         ['Buffer', 'Uint8Array'], buffer);
+    Error.captureStackTrace(err, validateBuffer);
+    throw err;
+  }
+}
+
+function validateOffsetLengthRead(offset, length, bufferLength) {
+  let err;
+
+  if (offset < 0 || offset >= bufferLength) {
+    err = new ERR_OUT_OF_RANGE('offset', `>= 0 && <= ${bufferLength}`, offset);
+  } else if (length < 0 || offset + length > bufferLength) {
+    err = new ERR_OUT_OF_RANGE('length',
+                               `>= 0 && <= ${bufferLength - offset}`, length);
+  }
+
+  if (err !== undefined) {
+    Error.captureStackTrace(err, validateOffsetLengthRead);
+    throw err;
+  }
+}
+
+function validateOffsetLengthWrite(offset, length, byteLength) {
+  let err;
+
+  if (offset > byteLength) {
+    err = new ERR_OUT_OF_RANGE('offset', `<= ${byteLength}`, offset);
+  } else {
+    const max = byteLength > kMaxLength ? kMaxLength : byteLength;
+    if (length > max - offset) {
+      err = new ERR_OUT_OF_RANGE('length', `<= ${max - offset}`, length);
+    }
+  }
+
+  if (err !== undefined) {
+    Error.captureStackTrace(err, validateOffsetLengthWrite);
+    throw err;
+  }
+}
+
+function validatePath(path, propName = 'path') {
+  let err;
+
+  if (typeof path !== 'string' && !isUint8Array(path)) {
+    err = new ERR_INVALID_ARG_TYPE(propName, ['string', 'Buffer', 'URL'], path);
+  } else {
+    err = nullCheck(path, propName, false);
+  }
+
+  if (err !== undefined) {
+    Error.captureStackTrace(err, validatePath);
+    throw err;
+  }
+}
+
+module.exports = {
+  assertEncoding,
+  copyObject,
+  getOptions,
+  modeNum,
+  nullCheck,
+  preprocessSymlinkDestination,
+  realpathCacheKey: Symbol('realpathCacheKey'),
+  getStatsFromBinding,
+  stringToFlags,
+  stringToSymlinkType,
+  Stats,
+  SyncWriteStream,
+  toUnixTimestamp,
+  validateBuffer,
+  validateOffsetLengthRead,
+  validateOffsetLengthWrite,
+  validatePath
+};
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 652378ad57..85ab3ab144 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -28,7 +28,7 @@ const { getURLFromFilePath } = require('internal/url');
 const vm = require('vm');
 const assert = require('assert').ok;
 const fs = require('fs');
-const internalFS = require('internal/fs');
+const internalFS = require('internal/fs/utils');
 const path = require('path');
 const {
   internalModuleReadJSON,
diff --git a/lib/internal/modules/esm/default_resolve.js b/lib/internal/modules/esm/default_resolve.js
index 60516535e9..48d3ef73fd 100644
--- a/lib/internal/modules/esm/default_resolve.js
+++ b/lib/internal/modules/esm/default_resolve.js
@@ -2,7 +2,7 @@
 
 const { URL } = require('url');
 const CJSmodule = require('internal/modules/cjs/loader');
-const internalFS = require('internal/fs');
+const internalFS = require('internal/fs/utils');
 const { NativeModule, internalBinding } = require('internal/bootstrap/loaders');
 const { extname } = require('path');
 const { realpathSync } = require('fs');
diff --git a/lib/internal/process/stdio.js b/lib/internal/process/stdio.js
index 29aee7d09b..75ede6a8e7 100644
--- a/lib/internal/process/stdio.js
+++ b/lib/internal/process/stdio.js
@@ -158,7 +158,7 @@ function createWritableStdioStream(fd) {
       break;
 
     case 'FILE':
-      var fs = require('internal/fs');
+      var fs = require('internal/fs/utils');
       stream = new fs.SyncWriteStream(fd, { autoClose: false });
       stream._type = 'fs';
       break;
diff --git a/node.gyp b/node.gyp
index 3e513a4a71..774a36f160 100644
--- a/node.gyp
+++ b/node.gyp
@@ -39,7 +39,6 @@
       'lib/domain.js',
       'lib/events.js',
       'lib/fs.js',
-      'lib/fs/promises.js',
       'lib/http.js',
       'lib/http2.js',
       'lib/_http_agent.js',
@@ -103,7 +102,8 @@
       'lib/internal/errors.js',
       'lib/internal/fixed_queue.js',
       'lib/internal/freelist.js',
-      'lib/internal/fs.js',
+      'lib/internal/fs/promises.js',
+      'lib/internal/fs/utils.js',
       'lib/internal/http.js',
       'lib/internal/inspector_async_hook.js',
       'lib/internal/linkedlist.js',
diff --git a/test/parallel/test-fs-filehandle.js b/test/parallel/test-fs-filehandle.js
index 8ddc11ec3e..84b462aa90 100644
--- a/test/parallel/test-fs-filehandle.js
+++ b/test/parallel/test-fs-filehandle.js
@@ -5,7 +5,7 @@ const common = require('../common');
 const assert = require('assert');
 const path = require('path');
 const fs = process.binding('fs');
-const { stringToFlags } = require('internal/fs');
+const { stringToFlags } = require('internal/fs/utils');
 
 // Verifies that the FileHandle object is garbage collected and that a
 // warning is emitted if it is not closed.
diff --git a/test/parallel/test-fs-open-flags.js b/test/parallel/test-fs-open-flags.js
index 7f70885861..546d68e312 100644
--- a/test/parallel/test-fs-open-flags.js
+++ b/test/parallel/test-fs-open-flags.js
@@ -39,7 +39,7 @@ const O_DSYNC = fs.constants.O_DSYNC || 0;
 const O_TRUNC = fs.constants.O_TRUNC || 0;
 const O_WRONLY = fs.constants.O_WRONLY || 0;
 
-const { stringToFlags } = require('internal/fs');
+const { stringToFlags } = require('internal/fs/utils');
 
 assert.strictEqual(stringToFlags('r'), O_RDONLY);
 assert.strictEqual(stringToFlags('r+'), O_RDWR);
diff --git a/test/parallel/test-fs-promises-file-handle-append-file.js b/test/parallel/test-fs-promises-file-handle-append-file.js
index 38336a2b43..7766ac4c90 100644
--- a/test/parallel/test-fs-promises-file-handle-append-file.js
+++ b/test/parallel/test-fs-promises-file-handle-append-file.js
@@ -2,11 +2,11 @@
 
 const common = require('../common');
 
-// The following tests validate base functionality for the fs/promises
+// The following tests validate base functionality for the fs.promises
 // FileHandle.appendFile method.
 
 const fs = require('fs');
-const { open } = require('fs/promises');
+const { open } = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises-file-handle-chmod.js b/test/parallel/test-fs-promises-file-handle-chmod.js
index c2a44fba7b..8b9d8b1c0d 100644
--- a/test/parallel/test-fs-promises-file-handle-chmod.js
+++ b/test/parallel/test-fs-promises-file-handle-chmod.js
@@ -2,11 +2,11 @@
 
 const common = require('../common');
 
-// The following tests validate base functionality for the fs/promises
+// The following tests validate base functionality for the fs.promises
 // FileHandle.chmod method.
 
 const fs = require('fs');
-const { open } = require('fs/promises');
+const { open } = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises-file-handle-read.js b/test/parallel/test-fs-promises-file-handle-read.js
index 5a9bc4558c..a397b0e260 100644
--- a/test/parallel/test-fs-promises-file-handle-read.js
+++ b/test/parallel/test-fs-promises-file-handle-read.js
@@ -2,11 +2,11 @@
 
 const common = require('../common');
 
-// The following tests validate base functionality for the fs/promises
+// The following tests validate base functionality for the fs.promises
 // FileHandle.read method.
 
 const fs = require('fs');
-const { open } = require('fs/promises');
+const { open } = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises-file-handle-readFile.js b/test/parallel/test-fs-promises-file-handle-readFile.js
index 9308c29909..316fd6581f 100644
--- a/test/parallel/test-fs-promises-file-handle-readFile.js
+++ b/test/parallel/test-fs-promises-file-handle-readFile.js
@@ -2,11 +2,11 @@
 
 const common = require('../common');
 
-// The following tests validate base functionality for the fs/promises
+// The following tests validate base functionality for the fs.promises
 // FileHandle.readFile method.
 
 const fs = require('fs');
-const { open } = require('fs/promises');
+const { open } = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises-file-handle-stat.js b/test/parallel/test-fs-promises-file-handle-stat.js
index 22b9c6476a..7d44b8e3da 100644
--- a/test/parallel/test-fs-promises-file-handle-stat.js
+++ b/test/parallel/test-fs-promises-file-handle-stat.js
@@ -2,10 +2,10 @@
 
 const common = require('../common');
 
-// The following tests validate base functionality for the fs/promises
+// The following tests validate base functionality for the fs.promises
 // FileHandle.stat method.
 
-const { open } = require('fs/promises');
+const { open } = require('fs').promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises-file-handle-write.js b/test/parallel/test-fs-promises-file-handle-write.js
index b5c83a1690..d7812745c5 100644
--- a/test/parallel/test-fs-promises-file-handle-write.js
+++ b/test/parallel/test-fs-promises-file-handle-write.js
@@ -2,11 +2,11 @@
 
 const common = require('../common');
 
-// The following tests validate base functionality for the fs/promises
+// The following tests validate base functionality for the fs.promises
 // FileHandle.read method.
 
 const fs = require('fs');
-const { open } = require('fs/promises');
+const { open } = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises-file-handle-writeFile.js b/test/parallel/test-fs-promises-file-handle-writeFile.js
index 196b6f8db8..a53384cc22 100644
--- a/test/parallel/test-fs-promises-file-handle-writeFile.js
+++ b/test/parallel/test-fs-promises-file-handle-writeFile.js
@@ -2,11 +2,11 @@
 
 const common = require('../common');
 
-// The following tests validate base functionality for the fs/promises
+// The following tests validate base functionality for the fs.promises
 // FileHandle.readFile method.
 
 const fs = require('fs');
-const { open } = require('fs/promises');
+const { open } = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises-readfile.js b/test/parallel/test-fs-promises-readfile.js
index 1bf49503c3..4334673c30 100644
--- a/test/parallel/test-fs-promises-readfile.js
+++ b/test/parallel/test-fs-promises-readfile.js
@@ -4,7 +4,7 @@ const common = require('../common');
 
 const assert = require('assert');
 const path = require('path');
-const { writeFile, readFile } = require('fs/promises');
+const { writeFile, readFile } = require('fs').promises;
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
 
diff --git a/test/parallel/test-fs-promises-writefile.js b/test/parallel/test-fs-promises-writefile.js
index 280bce8642..1bb6945c67 100644
--- a/test/parallel/test-fs-promises-writefile.js
+++ b/test/parallel/test-fs-promises-writefile.js
@@ -2,7 +2,7 @@
 
 const common = require('../common');
 const fs = require('fs');
-const fsPromises = require('fs/promises');
+const fsPromises = fs.promises;
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
diff --git a/test/parallel/test-fs-promises.js b/test/parallel/test-fs-promises.js
index ba3a91d5b3..43b5da7004 100644
--- a/test/parallel/test-fs-promises.js
+++ b/test/parallel/test-fs-promises.js
@@ -5,7 +5,7 @@ const assert = require('assert');
 const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
 const path = require('path');
-const fsPromises = require('fs/promises');
+const fsPromises = require('fs').promises;
 const {
   access,
   chmod,
diff --git a/test/parallel/test-fs-syncwritestream.js b/test/parallel/test-fs-syncwritestream.js
index a014277a6b..8fbe665a40 100644
--- a/test/parallel/test-fs-syncwritestream.js
+++ b/test/parallel/test-fs-syncwritestream.js
@@ -6,8 +6,8 @@ const stream = require('stream');
 const fs = require('fs');
 const path = require('path');
 
-// require('internal/fs').SyncWriteStream is used as a stdio implementation
-// when stdout/stderr point to files.
+// require('internal/fs/utils').SyncWriteStream is used as a stdio
+// implementation when stdout/stderr point to files.
 
 if (process.argv[2] === 'child') {
   // Note: Calling console.log() is part of this test as it exercises the
diff --git a/test/parallel/test-internal-fs-syncwritestream.js b/test/parallel/test-internal-fs-syncwritestream.js
index c474d21cb4..c751baf555 100644
--- a/test/parallel/test-internal-fs-syncwritestream.js
+++ b/test/parallel/test-internal-fs-syncwritestream.js
@@ -5,7 +5,7 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
-const SyncWriteStream = require('internal/fs').SyncWriteStream;
+const SyncWriteStream = require('internal/fs/utils').SyncWriteStream;
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
diff --git a/test/parallel/test-internal-fs.js b/test/parallel/test-internal-fs.js
index 9bc0a98b09..2e47e2a382 100644
--- a/test/parallel/test-internal-fs.js
+++ b/test/parallel/test-internal-fs.js
@@ -2,7 +2,7 @@
 'use strict';
 
 const common = require('../common');
-const fs = require('internal/fs');
+const fs = require('internal/fs/utils');
 
 // Valid encodings and no args should not throw.
 fs.assertEncoding();
diff --git a/test/sequential/test-async-wrap-getasyncid.js b/test/sequential/test-async-wrap-getasyncid.js
index 64c4fd5cd8..971296915c 100644
--- a/test/sequential/test-async-wrap-getasyncid.js
+++ b/test/sequential/test-async-wrap-getasyncid.js
@@ -3,7 +3,7 @@
 const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
-const fsPromises = require('fs/promises');
+const fsPromises = fs.promises;
 const net = require('net');
 const providers = Object.assign({}, process.binding('async_wrap').Providers);
 const fixtures = require('../common/fixtures');
-- 
cgit v1.2.1