chrome-devtools-frontend 1.0.1380117 → 1.0.1402249

package/scripts/component_server/server.js

@@ -8,11 +8,22 @@ const path = require('path');
 const parseURL = require('url').parse;
 const {argv} = require('yargs');
 
-const {getTestRunnerConfigSetting} = require('../test/test_config_helpers.js');
-
 const tracesMode = argv.traces || false;
 const serverPort = parseInt(process.env.PORT, 10) || (tracesMode ? 11010 : 8090);
 
+function getTestRunnerConfig() {
+  try {
+    return JSON.parse(process.env.TEST_RUNNER_JSON_CONFIG);
+  } catch {
+    // Return an empty object so any lookups return undefined
+    return {};
+  }
+}
+function getTestRunnerConfigSetting(settingKey, fallbackValue) {
+  const config = getTestRunnerConfig();
+  return config[settingKey] === undefined ? fallbackValue : config[settingKey];
+}
+
 /**
  * When you run npm run components-server we run the script as is from scripts/,
  * but when this server is run as part of a test suite it's run from
@@ -60,19 +71,34 @@ while (isRunningInGen && !pathToOutTargetDir.endsWith(`out${path.sep}${target}`)
 const pathToBuiltOutTargetDirectory =
     isRunningInGen ? pathToOutTargetDir : path.resolve(path.join(process.cwd(), 'out', target));
 
-let devtoolsRootFolder = path.resolve(path.join(pathToBuiltOutTargetDirectory, 'gen'));
-const fullCheckoutDevtoolsRootFolder = path.join(devtoolsRootFolder, 'third_party', 'devtools-frontend', 'src');
+let devtoolsRootFolder = path.resolve(
+    path.join(pathToBuiltOutTargetDirectory, 'gen'),
+);
+const fullCheckoutDevtoolsRootFolder = path.join(
+    devtoolsRootFolder,
+    'third_party',
+    'devtools-frontend',
+    'src',
+);
 if (__dirname.startsWith(fullCheckoutDevtoolsRootFolder)) {
   devtoolsRootFolder = fullCheckoutDevtoolsRootFolder;
 }
 
-const componentDocsBaseFolder = path.join(devtoolsRootFolder, componentDocsBaseArg);
+const componentDocsBaseFolder = path.join(
+    devtoolsRootFolder,
+    componentDocsBaseArg,
+);
 
 if (!fs.existsSync(devtoolsRootFolder)) {
-  console.error(`ERROR: Generated front_end folder (${devtoolsRootFolder}) does not exist.`);
+  console.error(
+      `ERROR: Generated front_end folder (${devtoolsRootFolder}) does not exist.`,
+  );
+  console.log(
+      'The components server works from the built Ninja output; you may need to run Ninja to update your built DevTools.',
+  );
   console.log(
-      'The components server works from the built Ninja output; you may need to run Ninja to update your built DevTools.');
-  console.log('If you build to a target other than default, you need to pass --target=X as an argument');
+      'If you build to a target other than default, you need to pass --target=X as an argument',
+  );
   process.exit(1);
 }
 
@@ -83,15 +109,28 @@ process.on('unhandledRejection', error => {
   console.error('unhandledRejection', error);
 });
 
-const server = http.createServer((req, res) => requestHandler(req, res).catch(err => send500(res, err)));
+const server = http.createServer(
+    (req, res) => requestHandler(req, res).catch(err => send500(res, err)),
+);
 server.listen(serverPort, 'localhost');
 server.once('listening', () => {
   if (process.send) {
     process.send(serverPort);
   }
   console.log(`Started components server at http://localhost:${serverPort}\n`);
-  console.log(`ui/components/docs location: ${
-      path.relative(process.cwd(), path.join(componentDocsBaseFolder, 'front_end', 'ui', 'components', 'docs'))}`);
+  console.log(
+      `ui/components/docs location: ${
+          path.relative(
+              process.cwd(),
+              path.join(
+                  componentDocsBaseFolder,
+                  'front_end',
+                  'ui',
+                  'components',
+                  'docs',
+                  ),
+              )}`,
+  );
 });
 
 server.once('error', error => {
@@ -158,23 +197,31 @@ function createComponentIndexFile(componentPath, componentExamples) {
         ${componentName}
         <a class="back-link" href="/">Back to index</a>
       </h1>
-      ${componentExamples.map(example => {
-        const fullPath = path.join(componentPath, example);
-        return `<details class="example">
-          <summary><a href="${fullPath}">${example.replace('.html', '').replace(/-|_/g, ' ')}</a></summary>
+      ${componentExamples
+        .map(example => {
+          const fullPath = path.join(componentPath, example);
+          return `<details class="example">
+          <summary><a href="${fullPath}">${example
+            .replace('.html', '')
+            .replace(/-|_/g, ' ')}</a></summary>
           <iframe src="${fullPath}"></iframe>
         </details>`;
-      }).join('\n')}
+        })
+        .join('\n')}
     </body>
   </html>`;
   // clang-format on
 }
 
 function createServerIndexFile(componentNames) {
-  const linksToStyleSheets =
-      styleSheetPaths
-          .map(link => `<link rel="stylesheet" href="${sharedResourcesBase}${path.join(...link.split('/'))}" />`)
-          .join('\n');
+  const linksToStyleSheets = styleSheetPaths
+                                 .map(
+                                     link => `<link rel="stylesheet" href="${sharedResourcesBase}${
+                                         path.join(
+                                             ...link.split('/'),
+                                             )}" />`,
+                                     )
+                                 .join('\n');
 
   // clang-format off
   return `<!DOCTYPE html>
@@ -188,10 +235,12 @@ function createServerIndexFile(componentNames) {
     <body id="index-page">
       <h1>DevTools components</h1>
       <ul class="components-list">
-        ${componentNames.map(name => {
-          const niceName = name.replace(/_/g, ' ');
-          return `<li><a href='/front_end/ui/components/docs/${name}'>${niceName}</a></li>`;
-        }).join('\n')}
+        ${componentNames
+          .map(name => {
+            const niceName = name.replace(/_/g, ' ');
+            return `<li><a href='/front_end/ui/components/docs/${name}'>${niceName}</a></li>`;
+          })
+          .join('\n')}
       </ul>
     </body>
   </html>`;
@@ -200,7 +249,7 @@ function createServerIndexFile(componentNames) {
 
 async function getExamplesForPath(filePath) {
   const componentDirectory = path.join(componentDocsBaseFolder, filePath);
-  if (!await checkFileExists(componentDirectory)) {
+  if (!(await checkFileExists(componentDirectory))) {
     return null;
   }
   const allFiles = await fs.promises.readdir(componentDirectory);
@@ -232,7 +281,10 @@ function send500(response, error) {
 
 async function checkFileExists(filePath) {
   try {
-    const errorsAccessingFile = await fs.promises.access(filePath, fs.constants.R_OK);
+    const errorsAccessingFile = await fs.promises.access(
+        filePath,
+        fs.constants.R_OK,
+    );
     return !errorsAccessingFile;
   } catch (e) {
     return false;
@@ -250,13 +302,31 @@ async function requestHandler(request, response) {
     return;
   }
   if (['/', '/index.html'].includes(filePath) && tracesMode === false) {
-    const components =
-        await fs.promises.readdir(path.join(componentDocsBaseFolder, 'front_end', 'ui', 'components', 'docs'));
-    const html = createServerIndexFile(components.filter(filePath => {
-      const stats = fs.lstatSync(path.join(componentDocsBaseFolder, 'front_end', 'ui', 'components', 'docs', filePath));
-      // Filter out some build config files (tsconfig, d.ts, etc), and just list the directories.
-      return stats.isDirectory();
-    }));
+    const components = await fs.promises.readdir(
+        path.join(
+            componentDocsBaseFolder,
+            'front_end',
+            'ui',
+            'components',
+            'docs',
+            ),
+    );
+    const html = createServerIndexFile(
+        components.filter(filePath => {
+          const stats = fs.lstatSync(
+              path.join(
+                  componentDocsBaseFolder,
+                  'front_end',
+                  'ui',
+                  'components',
+                  'docs',
+                  filePath,
+                  ),
+          );
+          // Filter out some build config files (tsconfig, d.ts, etc), and just list the directories.
+          return stats.isDirectory();
+        }),
+    );
     respondWithHtml(response, html);
   } else if (filePath.startsWith('/front_end/ui/components/docs') && path.extname(filePath) === '') {
     // This means it's a component path like /breadcrumbs.
@@ -293,21 +363,32 @@ async function requestHandler(request, response) {
       send404(response, '404, File not found');
       return;
     }
-    const fileContents = await fs.promises.readFile(fullPath, {encoding: 'utf8'});
+    const fileContents = await fs.promises.readFile(fullPath, {
+      encoding: 'utf8',
+    });
 
-    const linksToStyleSheets =
-        styleSheetPaths
-            .map(
-                link => `<link rel="stylesheet" href="${
-                    path.join(baseUrlForSharedResource, ...link.split('/'))}" type="text/css" />`)
-            .join('\n');
+    const linksToStyleSheets = styleSheetPaths
+                                   .map(
+                                       link => `<link rel="stylesheet" href="${
+                                           path.join(
+                                               baseUrlForSharedResource,
+                                               ...link.split('/'),
+                                               )}" type="text/css" />`,
+                                       )
+                                   .join('\n');
 
     const toggleDarkModeScript = `<script type="module" src="${
-        path.join(baseUrlForSharedResource, 'front_end', 'ui', 'components', 'docs', 'component_docs.js')}"></script>`;
+        path.join(
+            baseUrlForSharedResource,
+            'front_end',
+            'ui',
+            'components',
+            'docs',
+            'component_docs.js',
+            )}"></script>`;
     const newFileContents = fileContents.replace('</head>', `${linksToStyleSheets}</head>`)
                                 .replace('</body>', toggleDarkModeScript + '\n</body>');
     respondWithHtml(response, newFileContents);
-
   } else {
     // This means it's an asset like a JS file or an image.
     let fullPath = path.join(componentDocsBaseFolder, filePath);
@@ -325,10 +406,19 @@ async function requestHandler(request, response) {
       if (sharedResourcesBase && !componentDocsBaseFolder.includes(sharedResourcesBase)) {
         prefix = path.join(componentDocsBaseFolder, sharedResourcesBase);
       }
-      fullPath = path.join(prefix, 'front_end', 'core', 'i18n', 'locales', 'en-US.json');
+      fullPath = path.join(
+          prefix,
+          'front_end',
+          'core',
+          'i18n',
+          'locales',
+          'en-US.json',
+      );
     }
     if (!fullPath.startsWith(devtoolsRootFolder) && !fileIsInTestFolder) {
-      console.error(`Path ${fullPath} is outside the DevTools Frontend root dir.`);
+      console.error(
+          `Path ${fullPath} is outside the DevTools Frontend root dir.`,
+      );
       process.exit(1);
     }
 
@@ -444,9 +534,11 @@ function createTracesIndexFile(traceFilenames) {
       <h1>Load OPP with fixture traces:</h1>
 
       <form>
-        ${traceFilenames.map(filename => {
-          return `<button type=button>${filename}</button>`;
-        }).join('\n')}
+        ${traceFilenames
+          .map(filename => {
+            return `<button type=button>${filename}</button>`;
+          })
+          .join('\n')}
       </form>
 
       <script>
@@ -463,7 +555,9 @@ function createTracesIndexFile(traceFilenames) {
  * @param {string|null} filePath
  */
 async function handleTracesModeRequest(request, response, filePath) {
-  const traceFolder = path.resolve(path.join(process.cwd(), 'front_end/panels/timeline/fixtures/traces/'));
+  const traceFolder = path.resolve(
+      path.join(process.cwd(), 'front_end/panels/timeline/fixtures/traces/'),
+  );
   if (filePath === '/') {
     const traceFilenames = fs.readdirSync(traceFolder).filter(f => f.includes('json'));
     const html = createTracesIndexFile(traceFilenames);

package/scripts/devtools_paths.js

@@ -27,16 +27,14 @@ const os = require('os');
  * the scripts directory, at which point we've found this file and can use it
  * for all subsequent logic.
  *
- * e.g. the user executes a script: scripts/test/run_lint_check.js
+ * e.g. the user executes a script: scripts/test/run_lint_check.mjs
  *
  * process.argv[1] =
- * /full/path/devtools-frontend/src/scripts/test/run_lint_check.js
+ * /full/path/devtools-frontend/src/scripts/test/run_lint_check.mjs
  */
 const PATH_TO_EXECUTED_FILE = process.argv[1];
 
-const _lookUpCaches = new Map(
-    [['chromium', null]],
-);
+const _lookUpCaches = new Map([['chromium', null]]);
 /**
  * This function figures out if we're within a chromium directory, and therefore
  * we are in the integrated workflow mode, rather than working in a standalone
@@ -51,7 +49,10 @@ function isInChromiumDirectory() {
   const normalizedPath = PATH_TO_EXECUTED_FILE.split(path.sep).join('/');
   const devtoolsPath = 'src/third_party/devtools-frontend';
   const isInChromium = normalizedPath.includes(devtoolsPath);
-  const potentialChromiumDir = PATH_TO_EXECUTED_FILE.substring(0, normalizedPath.indexOf(devtoolsPath));
+  const potentialChromiumDir = PATH_TO_EXECUTED_FILE.substring(
+      0,
+      normalizedPath.indexOf(devtoolsPath),
+  );
   const result = {isInChromium, chromiumDirectory: potentialChromiumDir};
   _lookUpCaches.set('chromium', result);
   return result;
@@ -94,7 +95,13 @@ function thirdPartyPath() {
 function devToolsThirdPartyPath() {
   const {isInChromium} = isInChromiumDirectory();
   if (isInChromium) {
-    return path.join(rootPath(), 'third_party', 'devtools-frontend', 'src', 'third_party');
+    return path.join(
+        rootPath(),
+        'third_party',
+        'devtools-frontend',
+        'src',
+        'third_party',
+    );
   }
   return thirdPartyPath();
 }
@@ -103,7 +110,10 @@ function nodePath() {
   const paths = {
     darwin: path.join(
         process.arch === 'arm64' ? 'mac_arm64' : 'mac',
-        process.arch === 'arm64' ? 'node-darwin-arm64' : 'node-darwin-x64', 'bin', 'node'),
+        process.arch === 'arm64' ? 'node-darwin-arm64' : 'node-darwin-x64',
+        'bin',
+        'node',
+        ),
     linux: path.join('linux', 'node-linux-x64', 'bin', 'node'),
     win32: path.join('win', 'node.exe'),
   };
@@ -141,7 +151,13 @@ function tsconfigJsonPath() {
 function downloadedChromeBinaryPath() {
   const paths = {
     linux: path.join('chrome-linux', 'chrome'),
-    darwin: path.join('chrome-mac', 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing'),
+    darwin: path.join(
+        'chrome-mac',
+        'Google Chrome for Testing.app',
+        'Contents',
+        'MacOS',
+        'Google Chrome for Testing',
+        ),
     win32: path.join('chrome-win', 'chrome.exe'),
   };
   return path.join(devToolsThirdPartyPath(), 'chrome', paths[os.platform()]);

package/scripts/eslint_rules/README.md

@@ -7,10 +7,14 @@ npm run lint
 ```
 command and implicitly via the [Presubmit checks](../../test/README.md#Presubmit-checks).
 
+We follow the ESLint [Rule Naming Conventions](https://eslint.org/docs/latest/contribute/core-rules#rule-naming-conventions)
+and consistently use dashes to separate words (instead of underscores), and prefix
+all rules that disallow something with `no-`.
+
 ## Testing the rules
 
 When writing a custom ESLint rule, place the logic into a file `lib/foo.js` and
-add a corresponding test for the logic to `tests/foo_test.js`.
+add a corresponding test for the logic to `tests/foo.test.js`.
 
 You can use
 ```

package/scripts/eslint_rules/lib/{l10n_no_locked_or_placeholder_only_phrase.js → l10n-no-locked-or-placeholder-only-phrase.js}

@@ -4,7 +4,7 @@
 
 'use strict';
 
-const l10nHelper = require('./l10n_helper.js');
+const l10nHelper = require('./l10n-helper.js');
 
 const FULLY_LOCKED_PHRASE_REGEX = /^`[^`]*`$/;
 const SINGLE_PLACEHOLDER_REGEX = /^\{\w+\}$/;  // Matches the PH regex in `collect-strings.js`.

package/scripts/eslint_rules/lib/{l10n_no_uistrings_export.js → l10n-no-uistrings-export.js}

@@ -4,7 +4,7 @@
 
 'use strict';
 
-const l10nHelper = require('./l10n_helper.js');
+const l10nHelper = require('./l10n-helper.js');
 
 const MODULE_UI_STRINGS_FILENAME_REGEX = /ModuleUIStrings\.(js|ts)$/;
 

package/scripts/eslint_rules/lib/{l10n_no_unused_message.js → l10n-no-unused-message.js}

@@ -4,7 +4,7 @@
 
 'use strict';
 
-const l10nHelper = require('./l10n_helper.js');
+const l10nHelper = require('./l10n-helper.js');
 
 const MODULE_UI_STRINGS_FILENAME_REGEX = /ModuleUIStrings\.(js|ts)$/;
 

package/scripts/eslint_rules/lib/{ban_a_tags_in_lit_html.js → no-a-tags-in-lit-html.js}

@@ -12,7 +12,6 @@ module.exports = {
       description: 'Check for <a> and </a> in Lit templates instead of using x-link.',
       category: 'Possible Errors',
     },
-    fixable: 'code',
     schema: []  // no options
   },
   create: function(context) {

package/scripts/eslint_rules/lib/no-assert-deep-strict-equal.js

@@ -0,0 +1,61 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+/**
+ * @fileoverview Disallow usage of `assert.deepStrictEqual`.
+ *
+ * In chai, `deepStrictEqual` is an alias for `deepEqual`, and we want to
+ * consistently use the latter to not leave developers wondering what's
+ * the difference between these two. Also the `strict` part in the name might
+ * lead to the wrong conclusion that this is about strict equality.
+ */
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+
+    docs: {
+      description: 'Disallow usage of `assert.deepStrictEqual` in favor of `assert.deepEqual`.',
+      category: 'Best Practices',
+    },
+    messages: {
+      unexpectedAssertDeepStrictEqual: 'Unexpected assert.deepStrictEqual. Use assert.deepEqual instead.',
+    },
+    fixable: 'code',
+    schema: [], // no options
+  },
+  create: function (context) {
+    function isAssertDeepStrictEqual(calleeNode) {
+      return calleeNode.type === 'MemberExpression' &&
+             calleeNode.object.type === 'Identifier' &&
+             calleeNode.object.name === 'assert' &&
+             calleeNode.property.type === 'Identifier' &&
+             calleeNode.property.name === 'deepStrictEqual';
+    }
+
+    function reportError(node) {
+      context.report({
+        node,
+        messageId: 'unexpectedAssertDeepStrictEqual',
+        fix(fixer) {
+          return fixer.replaceText(node.callee.property, 'deepEqual');
+        }
+      });
+    }
+
+    return {
+      CallExpression(node) {
+        if (isAssertDeepStrictEqual(node.callee)) {
+          reportError(node);
+        }
+      }
+    };
+  },
+};

package/scripts/eslint_rules/lib/no-assert-equal-boolean-null-undefined.js

@@ -0,0 +1,125 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+/**
+ * @fileoverview Don't use assert equality on `boolean`, `null` or `undefined`.
+ *
+ * Prefer the more specific `assert.isTrue`, `assert.notIsTrue`, `assert.isFalse`,
+ * `assert.isNotFalse`, `assert.isNull`, `assert.isNotNull`, `assert.isDefined`,
+ * and `assert.isUndefined` methods.
+ */
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+const EQUALITY_ASSERTIONS = new Set(['deepEqual', 'strictEqual']);
+const INEQUALITY_ASSERTIONS = new Set(['notDeepEqual', 'notStrictEqual']);
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+
+    docs: {
+      description: 'Don\'t use equality assertions on `boolean`, `null` or `undefined`.',
+      category: 'Best Practices',
+    },
+    messages: {
+      useAssertIsDefined: 'Use `assert.isDefined` instead of `assert.{{ methodName }}` to check that a value is not `undefined`',
+      useAssertIsFalse: 'Use `assert.isFalse` instead of `assert.{{ methodName }}` to check that a value is `false`',
+      useAssertIsNotFalse: 'Use `assert.isNotFalse` instead of `assert.{{ methodName }}` to check that a value is not `undefined`',
+      useAssertIsNotNull: 'Use `assert.isNotNull` instead of `assert.{{ methodName }}` to check that a value is not `null`',
+      useAssertIsNotTrue: 'Use `assert.isNotTrue` instead of `assert.{{ methodName }}` to check that a value is not `true`',
+      useAssertIsNull: 'Use `assert.isNull` instead of `assert.{{ methodName }}` to check that a value is `null`',
+      useAssertIsTrue: 'Use `assert.isTrue` instead of `assert.{{ methodName }}` to check that a value is `true`',
+      useAssertIsUndefined: 'Use `assert.isUndefined` instead of `assert.{{ methodName }}` to check that a value is `undefined`',
+    },
+    fixable: 'code',
+    schema: [], // no options
+  },
+  create: function (context) {
+    function isAssertEquality(calleeNode) {
+      return calleeNode.type === 'MemberExpression' && calleeNode.object.type === 'Identifier' &&
+          calleeNode.object.name === 'assert' && calleeNode.property.type === 'Identifier' &&
+          EQUALITY_ASSERTIONS.has(calleeNode.property.name);
+    }
+
+    function isAssertInequality(calleeNode) {
+      return calleeNode.type === 'MemberExpression' && calleeNode.object.type === 'Identifier' &&
+          calleeNode.object.name === 'assert' && calleeNode.property.type === 'Identifier' &&
+          INEQUALITY_ASSERTIONS.has(calleeNode.property.name);
+    }
+
+    function isLiteral(argumentNode, value) {
+      return argumentNode.type === 'Literal' && argumentNode.value === value;
+    }
+
+    function isUndefinedLiteral(argumentNode) {
+      return argumentNode.type === 'Identifier' && argumentNode.name === 'undefined';
+    }
+
+    function reportError(node, calleeText, argumentIndex, messageId) {
+      const methodName = node.callee.property.name;
+      context.report({
+        node,
+        messageId,
+        data: {methodName},
+        fix(fixer) {
+          const {sourceCode} = context;
+          const args = [node.arguments[argumentIndex]].concat(node.arguments.slice(2));
+          const argsText = args.map(node => sourceCode.getText(node)).join(', ');
+          return fixer.replaceText(node, `${calleeText}(${argsText})`);
+        }
+      });
+    }
+
+    return {
+      CallExpression(node) {
+        if (node.arguments.length < 2) {
+          return;
+        }
+
+        if (isAssertEquality(node.callee)) {
+          if (isLiteral(node.arguments[1], false)) {
+            reportError(node, 'assert.isFalse', 0, 'useAssertIsFalse');
+          } else if (isLiteral(node.arguments[0], false)) {
+            reportError(node, 'assert.isFalse', 1, 'useAssertIsFalse');
+          } else if (isLiteral(node.arguments[1], null)) {
+            reportError(node, 'assert.isNull', 0, 'useAssertIsNull');
+          } else if (isLiteral(node.arguments[0], null)) {
+            reportError(node, 'assert.isNull', 1, 'useAssertIsNull');
+          } else if (isLiteral(node.arguments[0], true)) {
+            reportError(node, 'assert.isTrue', 1, 'useAssertIsTrue');
+          } else if (isLiteral(node.arguments[1], true)) {
+            reportError(node, 'assert.isTrue', 0, 'useAssertIsTrue');
+          } else if (isUndefinedLiteral(node.arguments[1])) {
+            reportError(node, 'assert.isUndefined', 0, 'useAssertIsUndefined');
+          } else if (isUndefinedLiteral(node.arguments[0])) {
+            reportError(node, 'assert.isUndefined', 1, 'useAssertIsUndefined');
+          }
+        } else if (isAssertInequality(node.callee)) {
+          if (isLiteral(node.arguments[1], false)) {
+            reportError(node, 'assert.isNotFalse', 0, 'useAssertIsNotFalse');
+          } else if (isLiteral(node.arguments[0], false)) {
+            reportError(node, 'assert.isNotFalse', 1, 'useAssertIsNotFalse');
+          } else if (isLiteral(node.arguments[1], null)) {
+            reportError(node, 'assert.isNotNull', 0, 'useAssertIsNotNull');
+          } else if (isLiteral(node.arguments[0], null)) {
+            reportError(node, 'assert.isNotNull', 1, 'useAssertIsNotNull');
+          } else if (isLiteral(node.arguments[0], true)) {
+            reportError(node, 'assert.isNotTrue', 1, 'useAssertIsNotTrue');
+          } else if (isLiteral(node.arguments[1], true)) {
+            reportError(node, 'assert.isNotTrue', 0, 'useAssertIsNotTrue');
+          } else if (isUndefinedLiteral(node.arguments[1])) {
+            reportError(node, 'assert.isDefined', 0, 'useAssertIsDefined');
+          } else if (isUndefinedLiteral(node.arguments[0])) {
+            reportError(node, 'assert.isDefined', 1, 'useAssertIsDefined');
+          }
+        }
+      }
+    };
+  },
+};