From 9845d05844288b7d66f4bd2e6835ed9fd04059fc Mon Sep 17 00:00:00 2001
From: Ian Sutherland <ian@iansutherland.ca>
Date: Sat, 3 Oct 2020 20:20:28 -0600
Subject: [PATCH 1/9] fs: add rm method

---
 doc/api/deprecations.md                      |  10 +
 doc/api/errors.md                            |   5 +
 doc/api/fs.md                                |  45 +++
 lib/fs.js                                    |  60 +++-
 lib/internal/errors.js                       |   1 +
 lib/internal/fs/promises.js                  |   9 +
 lib/internal/fs/utils.js                     | 124 ++++++++-
 test/common/tmpdir.js                        |   8 +-
 test/parallel/test-fs-rm.js                  | 273 +++++++++++++++++++
 test/parallel/test-fs-rmdir-recursive.js     |  14 +-
 test/parallel/test-policy-parse-integrity.js |   2 +-
 test/pummel/test-policy-integrity.js         |   4 +-
 12 files changed, 525 insertions(+), 30 deletions(-)
 create mode 100644 test/parallel/test-fs-rm.js

diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 8c4ed95069c346..53d27931b69b24 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -2650,6 +2650,16 @@ Type: Documentation-only
 The [`crypto.Certificate()` constructor][] is deprecated. Use
 [static methods of `crypto.Certificate()`][] instead.
 
+### DEP0147: `Permissive rmdir recursive is deprecated, use rm recursive`
+<!-- YAML
+changes:
+  - version: v15.0.0
+    pr-url: https://github.com/nodejs/node/pull/?
+    description: Runtime deprecation.
+-->
+
+Type: Runtime
+
 [Legacy URL API]: url.md#url_legacy_url_api
 [NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
 [RFC 6066]: https://tools.ietf.org/html/rfc6066#section-3
diff --git a/doc/api/errors.md b/doc/api/errors.md
index 814a6e5b16a8f2..4d51de0bf541a2 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -928,6 +928,11 @@ added: v14.0.0
 Used when a feature that is not available
 to the current platform which is running Node.js is used.
 
+<a id="ERR_FS_EISDIR"></a>
+### `ERR_FS_EISDIR`
+
+Path is a directory.
+
 <a id="ERR_FS_FILE_TOO_LARGE"></a>
 ### `ERR_FS_FILE_TOO_LARGE`
 
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 291e920f0e1b4f..4b12783cd043c9 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3598,6 +3598,51 @@ that represent files will be deleted. The permissive behavior of the
 `recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
 the future.
 
+## `fs.rm(path[, options], callback)`
+<!-- YAML
+added: v15.0.0
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `force` Ignore errors
+  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+    `EPERM` error is encountered, Node.js will retry the operation with a linear
+    backoff wait of `retryDelay` ms longer on each try. This option represents
+    the number of retries. This option is ignored if the `recursive` option is
+    not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive removal. In
+    recursive mode operations are retried on failure. **Default:** `false`.
+  * `retryDelay` {integer} The amount of time in milliseconds to wait between
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
+* `callback` {Function}
+  * `err` {Error}
+
+Asynchronous rm(2). No arguments other than a possible exception are given
+to the completion callback.
+
+## `fs.rmSync(path[, options])`
+<!-- YAML
+added: v15.0.0
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `force` Ignore errors
+  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+    `EPERM` error is encountered, Node.js will retry the operation with a linear
+    backoff wait of `retryDelay` ms longer on each try. This option represents
+    the number of retries. This option is ignored if the `recursive` option is
+    not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
+    recursive mode operations are retried on failure. **Default:** `false`.
+  * `retryDelay` {integer} The amount of time in milliseconds to wait between
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
+
+Synchronous rm(2). Returns `undefined`.
+
 ## `fs.stat(path[, options], callback)`
 <!-- YAML
 added: v0.0.2
diff --git a/lib/fs.js b/lib/fs.js
index 67a050b4e8c480..8f5257d4445f5b 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -93,6 +93,8 @@ const {
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
   validatePath,
+  validateRmOptions,
+  validateRmOptionsSync,
   validateRmdirOptions,
   validateStringAfterArrayBufferView,
   warnOnNonPortableTemplate
@@ -847,30 +849,64 @@ function rmdir(path, options, callback) {
 
   callback = makeCallback(callback);
   path = pathModule.toNamespacedPath(getValidatedPath(path));
-  options = validateRmdirOptions(options);
 
-  if (options.recursive) {
-    lazyLoadRimraf();
-    return rimraf(path, options, callback);
-  }
+  if (options && options.recursive) {
+    options = validateRmOptions(
+      path,
+      { ...options, force: true },
+      true,
+      (err, options) => {
+        if (err) {
+          return callback(err);
+        }
 
-  const req = new FSReqCallback();
-  req.oncomplete = callback;
-  binding.rmdir(path, req);
+        lazyLoadRimraf();
+        return rimraf(path, options, callback);
+      });
+
+  } else {
+    options = validateRmdirOptions(options);
+    const req = new FSReqCallback();
+    req.oncomplete = callback;
+    return binding.rmdir(path, req);
+  }
 }
 
 function rmdirSync(path, options) {
   path = getValidatedPath(path);
-  options = validateRmdirOptions(options);
 
-  if (options.recursive) {
+  if (options && options.recursive) {
+    options = validateRmOptionsSync(path, { ...options, force: true }, true);
     lazyLoadRimraf();
     return rimrafSync(pathModule.toNamespacedPath(path), options);
   }
 
+  options = validateRmdirOptions(options);
   const ctx = { path };
   binding.rmdir(pathModule.toNamespacedPath(path), undefined, ctx);
-  handleErrorFromBinding(ctx);
+  return handleErrorFromBinding(ctx);
+}
+
+function rm(path, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = undefined;
+  }
+
+  validateRmOptions(path, options, false, (err, options) => {
+    if (err) {
+      return callback(err);
+    }
+    lazyLoadRimraf();
+    return rimraf(path, options, callback);
+  });
+}
+
+function rmSync(path, options) {
+  options = validateRmOptionsSync(path, options, false);
+
+  lazyLoadRimraf();
+  return rimrafSync(path, options);
 }
 
 function fdatasync(fd, callback) {
@@ -2022,6 +2058,8 @@ module.exports = fs = {
   realpathSync,
   rename,
   renameSync,
+  rm,
+  rmSync,
   rmdir,
   rmdirSync,
   stat,
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index ff4cea13b61cae..15b75d2b4eab37 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -838,6 +838,7 @@ E('ERR_FEATURE_UNAVAILABLE_ON_PLATFORM',
   'The feature %s is unavailable on the current platform' +
   ', which is being used to run Node.js',
   TypeError);
+E('ERR_FS_EISDIR', 'is a directory', SystemError);
 E('ERR_FS_FILE_TOO_LARGE', 'File size (%s) is greater than 2 GB', RangeError);
 E('ERR_FS_INVALID_SYMLINK_TYPE',
   'Symlink type must be one of "dir", "file", or "junction". Received "%s"',
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index b6af3e48bd5c9f..60f8441f5d3d6e 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -52,6 +52,7 @@ const {
   validateBufferArray,
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
+  validateRmOptionsSync,
   validateRmdirOptions,
   validateStringAfterArrayBufferView,
   warnOnNonPortableTemplate
@@ -417,6 +418,13 @@ async function ftruncate(handle, len = 0) {
   return binding.ftruncate(handle.fd, len, kUsePromises);
 }
 
+async function rm(path, options) {
+  path = pathModule.toNamespacedPath(getValidatedPath(path));
+  options = validateRmOptionsSync(path, options);
+
+  return rimrafPromises(path, options);
+}
+
 async function rmdir(path, options) {
   path = pathModule.toNamespacedPath(getValidatedPath(path));
   options = validateRmdirOptions(options);
@@ -635,6 +643,7 @@ module.exports = {
     opendir: promisify(opendir),
     rename,
     truncate,
+    rm,
     rmdir,
     mkdir,
     readdir,
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 0be3ea6e8f19a8..5f43e862e81157 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -17,6 +17,7 @@ const {
 const { Buffer } = require('buffer');
 const {
   codes: {
+    ERR_FS_EISDIR,
     ERR_FS_INVALID_SYMLINK_TYPE,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
@@ -650,28 +651,127 @@ function warnOnNonPortableTemplate(template) {
   }
 }
 
+const defaultRmOptions = {
+  recursive: false,
+  force: false,
+  retryDelay: 100,
+  maxRetries: 0
+};
+
 const defaultRmdirOptions = {
   retryDelay: 100,
   maxRetries: 0,
   recursive: false,
 };
 
-const validateRmdirOptions = hideStackFrames((options) => {
-  if (options === undefined)
-    return defaultRmdirOptions;
-  if (options === null || typeof options !== 'object')
-    throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
+let permissiveRmdirWarned = false;
 
-  options = { ...defaultRmdirOptions, ...options };
+function emitPermissiveRmdirWarning() {
+  if (!permissiveRmdirWarned) {
+    process.emitWarning(
+      'Permissive rmdir recursive is deprecated, use rm recursive instead',
+      'DEP0147'
+    );
+    permissiveRmdirWarned = true;
+  }
+}
 
-  if (typeof options.recursive !== 'boolean')
-    throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', options.recursive);
+const validateRmOptions = (path, options, warn, callback) => {
+  try {
+    options = validateRmdirOptions(options, defaultRmOptions);
+  } catch (err) {
+    return callback(err);
+  }
 
-  validateInt32(options.retryDelay, 'retryDelay', 0);
-  validateUint32(options.maxRetries, 'maxRetries');
+  if (typeof options.force !== 'boolean')
+    return callback(
+      new ERR_INVALID_ARG_TYPE('force', 'boolean', options.force)
+    );
+
+  lazyLoadFs().stat(path, (err, stats) => {
+    if (err && err.code === 'ENOENT') {
+      if (options.force) {
+        if (warn) {
+          emitPermissiveRmdirWarning();
+        }
+        return callback(null, options);
+      }
+      return callback(err, options);
+    }
+
+    if (err) {
+      return callback(err);
+    }
+
+    if (warn && !stats.isDirectory()) {
+      emitPermissiveRmdirWarning();
+    }
+
+    if (stats.isDirectory() && !options.recursive) {
+      return callback(new ERR_FS_EISDIR({
+        code: 'EISDIR',
+        message: 'is a directory',
+        path,
+        syscall: 'rm',
+        errno: -21
+      }));
+    }
+    return callback(null, options);
+  });
+};
+
+const validateRmOptionsSync = (path, options, warn) => {
+  options = validateRmdirOptions(options, defaultRmOptions);
+
+  if (typeof options.force !== 'boolean')
+    throw new ERR_INVALID_ARG_TYPE('force', 'boolean', options.force);
+
+  try {
+    const stats = lazyLoadFs().statSync(path);
+
+    if (warn && !stats.isDirectory()) {
+      emitPermissiveRmdirWarning();
+    }
+
+    if (stats.isDirectory() && !options.recursive) {
+      throw new ERR_FS_EISDIR({
+        code: 'EISDIR',
+        message: 'is a directory',
+        path,
+        syscall: 'rm',
+        errno: -21
+      });
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      throw err;
+    } else if (err.code === 'ENOENT' && !options.force) {
+      throw err;
+    } else if (warn && err.code === 'ENOENT') {
+      emitPermissiveRmdirWarning();
+    }
+  }
 
   return options;
-});
+};
+
+const validateRmdirOptions = hideStackFrames(
+  (options, defaults = defaultRmdirOptions) => {
+    if (options === undefined)
+      return defaults;
+    if (options === null || typeof options !== 'object')
+      throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
+
+    options = { ...defaults, ...options };
+
+    if (typeof options.recursive !== 'boolean')
+      throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', options.recursive);
+
+    validateInt32(options.retryDelay, 'retryDelay', 0);
+    validateUint32(options.maxRetries, 'maxRetries');
+
+    return options;
+  });
 
 const getValidMode = hideStackFrames((mode, type) => {
   let min = kMinimumAccessMode;
@@ -741,6 +841,8 @@ module.exports = {
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
   validatePath,
+  validateRmOptions,
+  validateRmOptionsSync,
   validateRmdirOptions,
   validateStringAfterArrayBufferView,
   warnOnNonPortableTemplate
diff --git a/test/common/tmpdir.js b/test/common/tmpdir.js
index 5e1e21429fe06b..d911feb460a2f3 100644
--- a/test/common/tmpdir.js
+++ b/test/common/tmpdir.js
@@ -5,8 +5,8 @@ const fs = require('fs');
 const path = require('path');
 const { isMainThread } = require('worker_threads');
 
-function rimrafSync(pathname) {
-  fs.rmdirSync(pathname, { maxRetries: 3, recursive: true });
+function rmSync(pathname) {
+  fs.rmSync(pathname, { maxRetries: 3, recursive: true, force: true });
 }
 
 const testRoot = process.env.NODE_TEST_DIR ?
@@ -20,7 +20,7 @@ const tmpPath = path.join(testRoot, tmpdirName);
 
 let firstRefresh = true;
 function refresh() {
-  rimrafSync(this.path);
+  rmSync(this.path);
   fs.mkdirSync(this.path);
 
   if (firstRefresh) {
@@ -37,7 +37,7 @@ function onexit() {
     process.chdir(testRoot);
 
   try {
-    rimrafSync(tmpPath);
+    rmSync(tmpPath);
   } catch (e) {
     console.error('Can\'t clean tmpdir:', tmpPath);
 
diff --git a/test/parallel/test-fs-rm.js b/test/parallel/test-fs-rm.js
new file mode 100644
index 00000000000000..7a33341f0e99bd
--- /dev/null
+++ b/test/parallel/test-fs-rm.js
@@ -0,0 +1,273 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { validateRmOptionsSync } = require('internal/fs/utils');
+
+tmpdir.refresh();
+
+let count = 0;
+const nextDirPath = (name = 'rm') =>
+  path.join(tmpdir.path, `${name}-${count++}`);
+
+function makeNonEmptyDirectory(depth, files, folders, dirname, createSymLinks) {
+  fs.mkdirSync(dirname, { recursive: true });
+  fs.writeFileSync(path.join(dirname, 'text.txt'), 'hello', 'utf8');
+
+  const options = { flag: 'wx' };
+
+  for (let f = files; f > 0; f--) {
+    fs.writeFileSync(path.join(dirname, `f-${depth}-${f}`), '', options);
+  }
+
+  if (createSymLinks) {
+    // Valid symlink
+    fs.symlinkSync(
+      `f-${depth}-1`,
+      path.join(dirname, `link-${depth}-good`),
+      'file'
+    );
+
+    // Invalid symlink
+    fs.symlinkSync(
+      'does-not-exist',
+      path.join(dirname, `link-${depth}-bad`),
+      'file'
+    );
+  }
+
+  // File with a name that looks like a glob
+  fs.writeFileSync(path.join(dirname, '[a-z0-9].txt'), '', options);
+
+  depth--;
+  if (depth <= 0) {
+    return;
+  }
+
+  for (let f = folders; f > 0; f--) {
+    fs.mkdirSync(
+      path.join(dirname, `folder-${depth}-${f}`),
+      { recursive: true }
+    );
+    makeNonEmptyDirectory(
+      depth,
+      files,
+      folders,
+      path.join(dirname, `d-${depth}-${f}`),
+      createSymLinks
+    );
+  }
+}
+
+function removeAsync(dir) {
+  // Removal should fail without the recursive option.
+  fs.rm(dir, common.mustCall((err) => {
+    assert.strictEqual(err.syscall, 'rm');
+
+    // Removal should fail without the recursive option set to true.
+    fs.rm(dir, { recursive: false }, common.mustCall((err) => {
+      assert.strictEqual(err.syscall, 'rm');
+
+      // Recursive removal should succeed.
+      fs.rm(dir, { recursive: true }, common.mustCall((err) => {
+        assert.ifError(err);
+
+        // Attempted removal should fail now because the directory is gone.
+        fs.rm(dir, common.mustCall((err) => {
+          assert.strictEqual(err.syscall, 'stat');
+        }));
+      }));
+    }));
+  }));
+}
+
+// Test the asynchronous version
+{
+  // Create a 4-level folder hierarchy including symlinks
+  let dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+  removeAsync(dir);
+
+  // Create a 2-level folder hierarchy without symlinks
+  dir = nextDirPath();
+  makeNonEmptyDirectory(2, 10, 2, dir, false);
+  removeAsync(dir);
+
+  // Create a flat folder including symlinks
+  dir = nextDirPath();
+  makeNonEmptyDirectory(1, 10, 2, dir, true);
+  removeAsync(dir);
+
+  // Should fail if target does not exist
+  fs.rm(
+    path.join(tmpdir.path, 'noexist.txt'),
+    { recursive: true },
+    common.mustCall((err) => {
+      assert.strictEqual(err.code, 'ENOENT');
+    })
+  );
+
+  // Should delete a file
+  const filePath = path.join(tmpdir.path, 'rm-async-file.txt');
+  fs.writeFileSync(filePath, '');
+  fs.rm(filePath, { recursive: true }, common.mustCall((err) => {
+    try {
+      assert.strictEqual(err, null);
+      assert.strictEqual(fs.existsSync(filePath), false);
+    } finally {
+      fs.rmSync(filePath, { force: true });
+    }
+  }));
+}
+
+// Test the synchronous version.
+{
+  const dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+
+  // Removal should fail without the recursive option set to true.
+  assert.throws(() => {
+    fs.rmSync(dir);
+  }, { syscall: 'rm' });
+  assert.throws(() => {
+    fs.rmSync(dir, { recursive: false });
+  }, { syscall: 'rm' });
+
+  // Should fail if target does not exist
+  assert.throws(() => {
+    fs.rmSync(path.join(tmpdir.path, 'noexist.txt'), { recursive: true });
+  }, {
+    code: 'ENOENT',
+    name: 'Error',
+    message: /^ENOENT: no such file or directory, stat/
+  });
+
+  // Should delete a file
+  const filePath = path.join(tmpdir.path, 'rm-file.txt');
+  fs.writeFileSync(filePath, '');
+
+  try {
+    fs.rmSync(filePath, { recursive: true });
+  } finally {
+    fs.rmSync(filePath, { force: true });
+  }
+
+  // Recursive removal should succeed.
+  fs.rmSync(dir, { recursive: true });
+
+  // Attempted removal should fail now because the directory is gone.
+  assert.throws(() => fs.rmSync(dir), { syscall: 'stat' });
+}
+
+// Test the Promises based version.
+(async () => {
+  const dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+
+  // Removal should fail without the recursive option set to true.
+  assert.rejects(fs.promises.rm(dir), { syscall: 'rm' });
+  assert.rejects(fs.promises.rm(dir, { recursive: false }), {
+    syscall: 'rm'
+  });
+
+  // Recursive removal should succeed.
+  await fs.promises.rm(dir, { recursive: true });
+
+  // Attempted removal should fail now because the directory is gone.
+  assert.rejects(fs.promises.rm(dir), { syscall: 'stat' });
+
+  // Should fail if target does not exist
+  assert.rejects(fs.promises.rm(
+    path.join(tmpdir.path, 'noexist.txt'),
+    { recursive: true }
+  ), {
+    code: 'ENOENT',
+    name: 'Error',
+    message: /^ENOENT: no such file or directory, stat/
+  });
+
+  // Should not fail if target does not exist and force option is true
+  fs.promises.rm(path.join(tmpdir.path, 'noexist.txt'), { force: true });
+
+  // Should delete file
+  const filePath = path.join(tmpdir.path, 'rm-promises-file.txt');
+  fs.writeFileSync(filePath, '');
+
+  try {
+    await fs.promises.rm(filePath, { recursive: true });
+  } finally {
+    fs.rmSync(filePath, { force: true });
+  }
+})().then(common.mustCall());
+
+// Test input validation.
+{
+  const dir = nextDirPath();
+  makeNonEmptyDirectory(4, 10, 2, dir, true);
+  const filePath = (path.join(tmpdir.path, 'rm-args-file.txt'));
+  fs.writeFileSync(filePath, '');
+
+  const defaults = {
+    retryDelay: 100,
+    maxRetries: 0,
+    recursive: false,
+    force: false
+  };
+  const modified = {
+    retryDelay: 953,
+    maxRetries: 5,
+    recursive: true,
+    force: false
+  };
+
+  assert.deepStrictEqual(validateRmOptionsSync(filePath), defaults);
+  assert.deepStrictEqual(validateRmOptionsSync(filePath, {}), defaults);
+  assert.deepStrictEqual(validateRmOptionsSync(filePath, modified), modified);
+  assert.deepStrictEqual(validateRmOptionsSync(filePath, {
+    maxRetries: 99
+  }), {
+    retryDelay: 100,
+    maxRetries: 99,
+    recursive: false,
+    force: false
+  });
+
+  [null, 'foo', 5, NaN].forEach((bad) => {
+    assert.throws(() => {
+      validateRmOptionsSync(filePath, bad);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: /^The "options" argument must be of type object\./
+    });
+  });
+
+  [undefined, null, 'foo', Infinity, function() {}].forEach((bad) => {
+    assert.throws(() => {
+      validateRmOptionsSync(filePath, { recursive: bad });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: /^The "recursive" argument must be of type boolean\./
+    });
+  });
+
+  assert.throws(() => {
+    validateRmOptionsSync(filePath, { retryDelay: -1 });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: /^The value of "retryDelay" is out of range\./
+  });
+
+  assert.throws(() => {
+    validateRmOptionsSync(filePath, { maxRetries: -1 });
+  }, {
+    code: 'ERR_OUT_OF_RANGE',
+    name: 'RangeError',
+    message: /^The value of "maxRetries" is out of range\./
+  });
+}
diff --git a/test/parallel/test-fs-rmdir-recursive.js b/test/parallel/test-fs-rmdir-recursive.js
index 2793e0ee111f82..774481165ecdaf 100644
--- a/test/parallel/test-fs-rmdir-recursive.js
+++ b/test/parallel/test-fs-rmdir-recursive.js
@@ -7,6 +7,9 @@ const fs = require('fs');
 const path = require('path');
 const { validateRmdirOptions } = require('internal/fs/utils');
 
+const realEmitWarning = process.emitWarning;
+process.emitWarning = () => { throw new Error('deprecated'); };
+
 tmpdir.refresh();
 
 let count = 0;
@@ -124,7 +127,9 @@ function removeAsync(dir) {
   fs.rmdirSync(dir, { recursive: true });
 
   // No error should occur if recursive and the directory does not exist.
-  fs.rmdirSync(dir, { recursive: true });
+  assert.throws(() => {
+    fs.rmdirSync(dir, { recursive: true });
+  }, { message: 'deprecated' });
 
   // Attempted removal should fail now because the directory is gone.
   assert.throws(() => fs.rmdirSync(dir), { syscall: 'rmdir' });
@@ -211,3 +216,10 @@ function removeAsync(dir) {
     message: /^The value of "maxRetries" is out of range\./
   });
 }
+
+// Reset back to default after the test.
+Object.defineProperty(process, 'emitWarning', {
+  value: realEmitWarning,
+  configurable: true,
+  writable: true
+});
diff --git a/test/parallel/test-policy-parse-integrity.js b/test/parallel/test-policy-parse-integrity.js
index 2443d9691c2a51..9241f1e7843b64 100644
--- a/test/parallel/test-policy-parse-integrity.js
+++ b/test/parallel/test-policy-parse-integrity.js
@@ -20,7 +20,7 @@ function hash(algo, body) {
 }
 
 const tmpdirPath = path.join(tmpdir.path, 'test-policy-parse-integrity');
-fs.rmdirSync(tmpdirPath, { maxRetries: 3, recursive: true });
+fs.rmSync(tmpdirPath, { maxRetries: 3, recursive: true, force: true });
 fs.mkdirSync(tmpdirPath, { recursive: true });
 
 const policyFilepath = path.join(tmpdirPath, 'policy');
diff --git a/test/pummel/test-policy-integrity.js b/test/pummel/test-policy-integrity.js
index db1589c5ffe834..57625268fae4d0 100644
--- a/test/pummel/test-policy-integrity.js
+++ b/test/pummel/test-policy-integrity.js
@@ -109,7 +109,7 @@ function drainQueue() {
       `deletable-policy-${testId}.json`
     );
     const cliPolicy = willDeletePolicy ? tmpPolicyPath : policyPath;
-    fs.rmdirSync(configDirPath, { maxRetries: 3, recursive: true });
+    fs.rmSync(configDirPath, { maxRetries: 3, recursive: true, force: true });
     fs.mkdirSync(configDirPath, { recursive: true });
     const manifest = {
       onerror: onError,
@@ -185,7 +185,7 @@ function drainQueue() {
         console.log(`stderr: ${Buffer.concat(stderr)}`);
         throw e;
       }
-      fs.rmdirSync(configDirPath, { maxRetries: 3, recursive: true });
+      fs.rmSync(configDirPath, { maxRetries: 3, recursive: true, force: true });
       drainQueue();
     });
   }

From 6c26d175f9176576b4f2e046e07c4849f8ca2837 Mon Sep 17 00:00:00 2001
From: Ian Sutherland <ian@iansutherland.ca>
Date: Sun, 4 Oct 2020 11:14:07 -0600
Subject: [PATCH 2/9] code review changes

---
 doc/api/deprecations.md     |  6 +++---
 doc/api/fs.md               |  4 ++--
 lib/internal/fs/promises.js | 10 +++++++---
 lib/internal/fs/utils.js    |  9 +++++----
 4 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 53d27931b69b24..a6acc3b412f592 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -2650,11 +2650,11 @@ Type: Documentation-only
 The [`crypto.Certificate()` constructor][] is deprecated. Use
 [static methods of `crypto.Certificate()`][] instead.
 
-### DEP0147: `Permissive rmdir recursive is deprecated, use rm recursive`
+### DEP0147: `Permissive recursive rmdir is deprecated; use recursive rm`
 <!-- YAML
 changes:
-  - version: v15.0.0
-    pr-url: https://github.com/nodejs/node/pull/?
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35494
     description: Runtime deprecation.
 -->
 
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 4b12783cd043c9..73bd230c570f0c 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3600,7 +3600,7 @@ the future.
 
 ## `fs.rm(path[, options], callback)`
 <!-- YAML
-added: v15.0.0
+added: REPLACEME
 -->
 
 * `path` {string|Buffer|URL}
@@ -3624,7 +3624,7 @@ to the completion callback.
 
 ## `fs.rmSync(path[, options])`
 <!-- YAML
-added: v15.0.0
+added: REPLACEME
 -->
 
 * `path` {string|Buffer|URL}
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 60f8441f5d3d6e..62b8b39e993625 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -52,7 +52,7 @@ const {
   validateBufferArray,
   validateOffsetLengthRead,
   validateOffsetLengthWrite,
-  validateRmOptionsSync,
+  validateRmOptions,
   validateRmdirOptions,
   validateStringAfterArrayBufferView,
   warnOnNonPortableTemplate
@@ -420,8 +420,12 @@ async function ftruncate(handle, len = 0) {
 
 async function rm(path, options) {
   path = pathModule.toNamespacedPath(getValidatedPath(path));
-  options = validateRmOptionsSync(path, options);
-
+  options = await new Promise((resolve, reject) => {
+    validateRmOptions(path, options, false, (err, options) => {
+      if (err) return reject(err);
+      return resolve(options);
+    });
+  });
   return rimrafPromises(path, options);
 }
 
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 5f43e862e81157..2e0fc46a578170 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -670,13 +670,14 @@ function emitPermissiveRmdirWarning() {
   if (!permissiveRmdirWarned) {
     process.emitWarning(
       'Permissive rmdir recursive is deprecated, use rm recursive instead',
+      'DeprecationWarning',
       'DEP0147'
     );
     permissiveRmdirWarned = true;
   }
 }
 
-const validateRmOptions = (path, options, warn, callback) => {
+const validateRmOptions = hideStackFrames((path, options, warn, callback) => {
   try {
     options = validateRmdirOptions(options, defaultRmOptions);
   } catch (err) {
@@ -718,9 +719,9 @@ const validateRmOptions = (path, options, warn, callback) => {
     }
     return callback(null, options);
   });
-};
+});
 
-const validateRmOptionsSync = (path, options, warn) => {
+const validateRmOptionsSync = hideStackFrames((path, options, warn) => {
   options = validateRmdirOptions(options, defaultRmOptions);
 
   if (typeof options.force !== 'boolean')
@@ -753,7 +754,7 @@ const validateRmOptionsSync = (path, options, warn) => {
   }
 
   return options;
-};
+});
 
 const validateRmdirOptions = hideStackFrames(
   (options, defaults = defaultRmdirOptions) => {

From f0f37b1fa8ff9d630e0e94ce720fd50d5a617009 Mon Sep 17 00:00:00 2001
From: "Benjamin E. Coe" <bencoe@google.com>
Date: Tue, 6 Oct 2020 19:05:22 -0700
Subject: [PATCH 3/9] Update lib/fs.js

---
 lib/fs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/fs.js b/lib/fs.js
index 8f5257d4445f5b..9d194949f1f832 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -906,7 +906,7 @@ function rmSync(path, options) {
   options = validateRmOptionsSync(path, options, false);
 
   lazyLoadRimraf();
-  return rimrafSync(path, options);
+  return rimrafSync(pathModule.toNamespacedPath(path), options);
 }
 
 function fdatasync(fd, callback) {

From b1fa541547a85ba6b4cbdd32303032ee939e0dc9 Mon Sep 17 00:00:00 2001
From: "Benjamin E. Coe" <bencoe@google.com>
Date: Tue, 6 Oct 2020 19:05:33 -0700
Subject: [PATCH 4/9] Update lib/fs.js

---
 lib/fs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/fs.js b/lib/fs.js
index 9d194949f1f832..f20dad23ef975e 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -898,7 +898,7 @@ function rm(path, options, callback) {
       return callback(err);
     }
     lazyLoadRimraf();
-    return rimraf(path, options, callback);
+    return rimraf(pathModule.toNamespacedPath(path), options, callback);
   });
 }
 

From 641bc3bbdae51da715fc0073c7ce2b5194bc5b7c Mon Sep 17 00:00:00 2001
From: Ian Sutherland <ian@iansutherland.ca>
Date: Wed, 7 Oct 2020 13:10:18 -0600
Subject: [PATCH 5/9] Remove deprecation warning for recursive rmdir

---
 doc/api/deprecations.md                  | 10 --------
 doc/api/fs.md                            | 10 ++++----
 lib/fs.js                                |  7 +++---
 lib/internal/errors.js                   |  2 +-
 lib/internal/fs/promises.js              |  2 +-
 lib/internal/fs/utils.js                 | 30 ++----------------------
 test/parallel/test-fs-rm.js              | 10 ++++++++
 test/parallel/test-fs-rmdir-recursive.js | 14 +----------
 8 files changed, 24 insertions(+), 61 deletions(-)

diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index a6acc3b412f592..8c4ed95069c346 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -2650,16 +2650,6 @@ Type: Documentation-only
 The [`crypto.Certificate()` constructor][] is deprecated. Use
 [static methods of `crypto.Certificate()`][] instead.
 
-### DEP0147: `Permissive recursive rmdir is deprecated; use recursive rm`
-<!-- YAML
-changes:
-  - version: REPLACEME
-    pr-url: https://github.com/nodejs/node/pull/35494
-    description: Runtime deprecation.
--->
-
-Type: Runtime
-
 [Legacy URL API]: url.md#url_legacy_url_api
 [NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
 [RFC 6066]: https://tools.ietf.org/html/rfc6066#section-3
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 73bd230c570f0c..99fe0a3e4aa3ca 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3605,7 +3605,7 @@ added: REPLACEME
 
 * `path` {string|Buffer|URL}
 * `options` {Object}
-  * `force` Ignore errors
+  * `force` don't error on nonexistent path
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
     backoff wait of `retryDelay` ms longer on each try. This option represents
@@ -3619,8 +3619,9 @@ added: REPLACEME
 * `callback` {Function}
   * `err` {Error}
 
-Asynchronous rm(2). No arguments other than a possible exception are given
-to the completion callback.
+Asynchronously removes files and directories (modeled on the standard POSIX `rm`
+utility). No arguments other than a possible exception are given to the
+completion callback.
 
 ## `fs.rmSync(path[, options])`
 <!-- YAML
@@ -3641,7 +3642,8 @@ added: REPLACEME
     retries. This option is ignored if the `recursive` option is not `true`.
     **Default:** `100`.
 
-Synchronous rm(2). Returns `undefined`.
+Syncronously removes files and directories (modeled on the standard POSIX `rm`
+utility). Returns `undefined`.
 
 ## `fs.stat(path[, options], callback)`
 <!-- YAML
diff --git a/lib/fs.js b/lib/fs.js
index f20dad23ef975e..3dfd0ec938a68b 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -854,7 +854,6 @@ function rmdir(path, options, callback) {
     options = validateRmOptions(
       path,
       { ...options, force: true },
-      true,
       (err, options) => {
         if (err) {
           return callback(err);
@@ -876,7 +875,7 @@ function rmdirSync(path, options) {
   path = getValidatedPath(path);
 
   if (options && options.recursive) {
-    options = validateRmOptionsSync(path, { ...options, force: true }, true);
+    options = validateRmOptionsSync(path, { ...options, force: true });
     lazyLoadRimraf();
     return rimrafSync(pathModule.toNamespacedPath(path), options);
   }
@@ -893,7 +892,7 @@ function rm(path, options, callback) {
     options = undefined;
   }
 
-  validateRmOptions(path, options, false, (err, options) => {
+  validateRmOptions(path, options, (err, options) => {
     if (err) {
       return callback(err);
     }
@@ -903,7 +902,7 @@ function rm(path, options, callback) {
 }
 
 function rmSync(path, options) {
-  options = validateRmOptionsSync(path, options, false);
+  options = validateRmOptionsSync(path, options);
 
   lazyLoadRimraf();
   return rimrafSync(pathModule.toNamespacedPath(path), options);
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 15b75d2b4eab37..18327902e91263 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -838,7 +838,7 @@ E('ERR_FEATURE_UNAVAILABLE_ON_PLATFORM',
   'The feature %s is unavailable on the current platform' +
   ', which is being used to run Node.js',
   TypeError);
-E('ERR_FS_EISDIR', 'is a directory', SystemError);
+E('ERR_FS_EISDIR', 'Path is a directory', SystemError);
 E('ERR_FS_FILE_TOO_LARGE', 'File size (%s) is greater than 2 GB', RangeError);
 E('ERR_FS_INVALID_SYMLINK_TYPE',
   'Symlink type must be one of "dir", "file", or "junction". Received "%s"',
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 62b8b39e993625..260c5b158ab0de 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -421,7 +421,7 @@ async function ftruncate(handle, len = 0) {
 async function rm(path, options) {
   path = pathModule.toNamespacedPath(getValidatedPath(path));
   options = await new Promise((resolve, reject) => {
-    validateRmOptions(path, options, false, (err, options) => {
+    validateRmOptions(path, options, (err, options) => {
       if (err) return reject(err);
       return resolve(options);
     });
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
index 2e0fc46a578170..af93867dac778c 100644
--- a/lib/internal/fs/utils.js
+++ b/lib/internal/fs/utils.js
@@ -664,20 +664,7 @@ const defaultRmdirOptions = {
   recursive: false,
 };
 
-let permissiveRmdirWarned = false;
-
-function emitPermissiveRmdirWarning() {
-  if (!permissiveRmdirWarned) {
-    process.emitWarning(
-      'Permissive rmdir recursive is deprecated, use rm recursive instead',
-      'DeprecationWarning',
-      'DEP0147'
-    );
-    permissiveRmdirWarned = true;
-  }
-}
-
-const validateRmOptions = hideStackFrames((path, options, warn, callback) => {
+const validateRmOptions = hideStackFrames((path, options, callback) => {
   try {
     options = validateRmdirOptions(options, defaultRmOptions);
   } catch (err) {
@@ -692,9 +679,6 @@ const validateRmOptions = hideStackFrames((path, options, warn, callback) => {
   lazyLoadFs().stat(path, (err, stats) => {
     if (err && err.code === 'ENOENT') {
       if (options.force) {
-        if (warn) {
-          emitPermissiveRmdirWarning();
-        }
         return callback(null, options);
       }
       return callback(err, options);
@@ -704,10 +688,6 @@ const validateRmOptions = hideStackFrames((path, options, warn, callback) => {
       return callback(err);
     }
 
-    if (warn && !stats.isDirectory()) {
-      emitPermissiveRmdirWarning();
-    }
-
     if (stats.isDirectory() && !options.recursive) {
       return callback(new ERR_FS_EISDIR({
         code: 'EISDIR',
@@ -721,7 +701,7 @@ const validateRmOptions = hideStackFrames((path, options, warn, callback) => {
   });
 });
 
-const validateRmOptionsSync = hideStackFrames((path, options, warn) => {
+const validateRmOptionsSync = hideStackFrames((path, options) => {
   options = validateRmdirOptions(options, defaultRmOptions);
 
   if (typeof options.force !== 'boolean')
@@ -730,10 +710,6 @@ const validateRmOptionsSync = hideStackFrames((path, options, warn) => {
   try {
     const stats = lazyLoadFs().statSync(path);
 
-    if (warn && !stats.isDirectory()) {
-      emitPermissiveRmdirWarning();
-    }
-
     if (stats.isDirectory() && !options.recursive) {
       throw new ERR_FS_EISDIR({
         code: 'EISDIR',
@@ -748,8 +724,6 @@ const validateRmOptionsSync = hideStackFrames((path, options, warn) => {
       throw err;
     } else if (err.code === 'ENOENT' && !options.force) {
       throw err;
-    } else if (warn && err.code === 'ENOENT') {
-      emitPermissiveRmdirWarning();
     }
   }
 
diff --git a/test/parallel/test-fs-rm.js b/test/parallel/test-fs-rm.js
index 7a33341f0e99bd..47567c6e65b75f 100644
--- a/test/parallel/test-fs-rm.js
+++ b/test/parallel/test-fs-rm.js
@@ -255,6 +255,16 @@ function removeAsync(dir) {
     });
   });
 
+  [undefined, null, 'foo', Infinity, function() {}].forEach((bad) => {
+    assert.throws(() => {
+      validateRmOptionsSync(filePath, { force: bad });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message: /^The "force" argument must be of type boolean\./
+    });
+  });
+
   assert.throws(() => {
     validateRmOptionsSync(filePath, { retryDelay: -1 });
   }, {
diff --git a/test/parallel/test-fs-rmdir-recursive.js b/test/parallel/test-fs-rmdir-recursive.js
index 774481165ecdaf..2793e0ee111f82 100644
--- a/test/parallel/test-fs-rmdir-recursive.js
+++ b/test/parallel/test-fs-rmdir-recursive.js
@@ -7,9 +7,6 @@ const fs = require('fs');
 const path = require('path');
 const { validateRmdirOptions } = require('internal/fs/utils');
 
-const realEmitWarning = process.emitWarning;
-process.emitWarning = () => { throw new Error('deprecated'); };
-
 tmpdir.refresh();
 
 let count = 0;
@@ -127,9 +124,7 @@ function removeAsync(dir) {
   fs.rmdirSync(dir, { recursive: true });
 
   // No error should occur if recursive and the directory does not exist.
-  assert.throws(() => {
-    fs.rmdirSync(dir, { recursive: true });
-  }, { message: 'deprecated' });
+  fs.rmdirSync(dir, { recursive: true });
 
   // Attempted removal should fail now because the directory is gone.
   assert.throws(() => fs.rmdirSync(dir), { syscall: 'rmdir' });
@@ -216,10 +211,3 @@ function removeAsync(dir) {
     message: /^The value of "maxRetries" is out of range\./
   });
 }
-
-// Reset back to default after the test.
-Object.defineProperty(process, 'emitWarning', {
-  value: realEmitWarning,
-  configurable: true,
-  writable: true
-});

From adbc955c6b2d6d4643e969290db97cf2bd2821a1 Mon Sep 17 00:00:00 2001
From: Ian Sutherland <ian@iansutherland.ca>
Date: Wed, 7 Oct 2020 13:18:49 -0600
Subject: [PATCH 6/9] Update doc/api/fs.md

Co-authored-by: Jordan Harband <ljharb@gmail.com>
---
 doc/api/fs.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 99fe0a3e4aa3ca..ac86205551fe6a 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3642,7 +3642,7 @@ added: REPLACEME
     retries. This option is ignored if the `recursive` option is not `true`.
     **Default:** `100`.
 
-Syncronously removes files and directories (modeled on the standard POSIX `rm`
+Synchronously removes files and directories (modeled on the standard POSIX `rm`
 utility). Returns `undefined`.
 
 ## `fs.stat(path[, options], callback)`

From 7aca5408352c0eee97516a48a9ee2bf30782edc8 Mon Sep 17 00:00:00 2001
From: Ian Sutherland <ian@iansutherland.ca>
Date: Wed, 7 Oct 2020 16:37:44 -0600
Subject: [PATCH 7/9] Use promisify when validating rm options

---
 doc/api/fs.md               | 10 +++++-----
 lib/internal/fs/promises.js |  8 ++------
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index ac86205551fe6a..9c58b01166fb05 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3526,7 +3526,7 @@ changes:
 * `options` {Object}
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` ms longer on each try. This option represents
+    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
     the number of retries. This option is ignored if the `recursive` option is
     not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
@@ -3577,7 +3577,7 @@ changes:
 * `options` {Object}
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` ms longer on each try. This option represents
+    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
     the number of retries. This option is ignored if the `recursive` option is
     not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
@@ -3608,7 +3608,7 @@ added: REPLACEME
   * `force` don't error on nonexistent path
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` ms longer on each try. This option represents
+    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
     the number of retries. This option is ignored if the `recursive` option is
     not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive removal. In
@@ -3633,7 +3633,7 @@ added: REPLACEME
   * `force` Ignore errors
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` ms longer on each try. This option represents
+    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
     the number of retries. This option is ignored if the `recursive` option is
     not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
@@ -5512,7 +5512,7 @@ changes:
 * `options` {Object}
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` ms longer on each try. This option represents
+    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
     the number of retries. This option is ignored if the `recursive` option is
     not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 260c5b158ab0de..9e1f6857d2cf96 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -80,6 +80,7 @@ const {
 } = require('internal/worker/js_transferable');
 
 const getDirectoryEntriesPromise = promisify(getDirents);
+const validateRmOptionsPromise = promisify(validateRmOptions);
 
 class FileHandle extends JSTransferable {
   constructor(filehandle) {
@@ -420,12 +421,7 @@ async function ftruncate(handle, len = 0) {
 
 async function rm(path, options) {
   path = pathModule.toNamespacedPath(getValidatedPath(path));
-  options = await new Promise((resolve, reject) => {
-    validateRmOptions(path, options, (err, options) => {
-      if (err) return reject(err);
-      return resolve(options);
-    });
-  });
+  options = await validateRmOptionsPromise(path, options);
   return rimrafPromises(path, options);
 }
 

From 384a7e964361560bcf5153da45b934a22bfd1b11 Mon Sep 17 00:00:00 2001
From: Ian Sutherland <ian@iansutherland.ca>
Date: Wed, 7 Oct 2020 16:42:21 -0600
Subject: [PATCH 8/9] Add docs for promise version of rm

---
 doc/api/fs.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 9c58b01166fb05..0a81c28e400ebe 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -5536,6 +5536,28 @@ that represent files will be deleted. The permissive behavior of the
 `recursive` option is deprecated, `ENOTDIR` and `ENOENT` will be thrown in
 the future.
 
+## `fsPromises.rm(path[, options])`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `force` Ignore errors
+  * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+    `EPERM` error is encountered, Node.js will retry the operation with a linear
+    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
+    the number of retries. This option is ignored if the `recursive` option is
+    not `true`. **Default:** `0`.
+  * `recursive` {boolean} If `true`, perform a recursive directory removal. In
+    recursive mode operations are retried on failure. **Default:** `false`.
+  * `retryDelay` {integer} The amount of time in milliseconds to wait between
+    retries. This option is ignored if the `recursive` option is not `true`.
+    **Default:** `100`.
+
+Synchronously removes files and directories (modeled on the standard POSIX `rm`
+utility). Resolves the `Promise` with no arguments on success.
+
 ### `fsPromises.stat(path[, options])`
 <!-- YAML
 added: v10.0.0

From 187668423bbf3835faa00dbf06851dfe8c83779e Mon Sep 17 00:00:00 2001
From: Ian Sutherland <ian@iansutherland.ca>
Date: Wed, 7 Oct 2020 16:47:39 -0600
Subject: [PATCH 9/9] Fix lint errors

---
 doc/api/fs.md | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 0a81c28e400ebe..ea416ff582c901 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -3526,9 +3526,9 @@ changes:
 * `options` {Object}
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
-    the number of retries. This option is ignored if the `recursive` option is
-    not `true`. **Default:** `0`.
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
     recursive mode, errors are not reported if `path` does not exist, and
     operations are retried on failure. **Default:** `false`.
@@ -3577,9 +3577,9 @@ changes:
 * `options` {Object}
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
-    the number of retries. This option is ignored if the `recursive` option is
-    not `true`. **Default:** `0`.
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
     recursive mode, errors are not reported if `path` does not exist, and
     operations are retried on failure. **Default:** `false`.
@@ -3608,9 +3608,9 @@ added: REPLACEME
   * `force` don't error on nonexistent path
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
-    the number of retries. This option is ignored if the `recursive` option is
-    not `true`. **Default:** `0`.
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive removal. In
     recursive mode operations are retried on failure. **Default:** `false`.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between
@@ -3633,9 +3633,9 @@ added: REPLACEME
   * `force` Ignore errors
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
-    the number of retries. This option is ignored if the `recursive` option is
-    not `true`. **Default:** `0`.
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
     recursive mode operations are retried on failure. **Default:** `false`.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between
@@ -5512,9 +5512,9 @@ changes:
 * `options` {Object}
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
-    the number of retries. This option is ignored if the `recursive` option is
-    not `true`. **Default:** `0`.
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
     recursive mode, errors are not reported if `path` does not exist, and
     operations are retried on failure. **Default:** `false`.
@@ -5546,9 +5546,9 @@ added: REPLACEME
   * `force` Ignore errors
   * `maxRetries` {integer} If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
     `EPERM` error is encountered, Node.js will retry the operation with a linear
-    backoff wait of `retryDelay` milliseconds longer on each try. This option represents
-    the number of retries. This option is ignored if the `recursive` option is
-    not `true`. **Default:** `0`.
+    backoff wait of `retryDelay` milliseconds longer on each try. This option
+    represents the number of retries. This option is ignored if the `recursive`
+    option is not `true`. **Default:** `0`.
   * `recursive` {boolean} If `true`, perform a recursive directory removal. In
     recursive mode operations are retried on failure. **Default:** `false`.
   * `retryDelay` {integer} The amount of time in milliseconds to wait between