chrome-devtools-frontend 1.0.1473514 → 1.0.1506453

package/scripts/eslint_rules/lib/no-imperative-dom-api/toolbar.ts

@@ -2,34 +2,33 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview A library to identify and templatize manually constructed Toolbars.
+ * @file A library to identify and templatize manually constructed Toolbars.
  */
 
 import type {TSESTree} from '@typescript-eslint/utils';
 
-import {isIdentifier, isIdentifierChain, isMemberExpression} from './ast.ts';
+import {isIdentifier, isIdentifierChain, isMemberExpression, type RuleCreator} from './ast.ts';
 import {DomFragment} from './dom-fragment.ts';
 
 type Node = TSESTree.Node;
 
-export const toolbar = {
+export const toolbar: RuleCreator = {
   create(context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
     return {
-      getEvent(event: Node): string |
-          null {
-            switch (sourceCode.getText(event)) {
-              case 'UI.Toolbar.ToolbarInput.Event.TEXT_CHANGED':
-                return 'change';
-              case 'UI.Toolbar.ToolbarInput.Event.ENTER_PRESSED':
-                return 'submit';
-              case 'UI.Toolbar.ToolbarButton.Events.CLICK':
-                return 'click';
-              default:
-                return null;
-            }
-          },
-      methodCall(property: Node, firstArg: Node, _secondArg: Node, domFragment: DomFragment, _call: Node): boolean {
+      getEvent(event) {
+        switch (sourceCode.getText(event)) {
+          case 'UI.Toolbar.ToolbarInput.Event.TEXT_CHANGED':
+            return 'change';
+          case 'UI.Toolbar.ToolbarInput.Event.ENTER_PRESSED':
+            return 'submit';
+          case 'UI.Toolbar.ToolbarButton.Events.CLICK':
+            return 'click';
+          default:
+            return null;
+        }
+      },
+      methodCall(property, firstArg, _secondArg, domFragment) {
         if (isIdentifier(property, 'appendToolbarItem')) {
           domFragment.appendChild(firstArg, sourceCode);
           return true;

package/scripts/eslint_rules/lib/no-imperative-dom-api/ui-fragment.ts

@@ -2,22 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview A library to identify and templatize UI.Fragment and related calls.
+ * @file A library to identify and templatize UI.Fragment and related calls.
  */
 
-import type {TSESTree} from '@typescript-eslint/utils';
-
-import {isIdentifier, isIdentifierChain} from './ast.ts';
+import {isIdentifier, isIdentifierChain, type RuleCreator} from './ast.ts';
 import {DomFragment} from './dom-fragment.ts';
 
-type CallExpression = TSESTree.CallExpression;
-type MemberExpression = TSESTree.MemberExpression;
-
-export const uiFragment = {
+export const uiFragment: RuleCreator = {
   create(context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
     return {
-      MemberExpression(node: MemberExpression) {
+      MemberExpression(node) {
         if (isIdentifierChain(node, ['UI', 'Fragment', 'Fragment', 'build']) &&
             node.parent?.type === 'TaggedTemplateExpression') {
           const domFragment = DomFragment.getOrCreate(node.parent, sourceCode);
@@ -25,11 +20,11 @@ export const uiFragment = {
               sourceCode.getText(node.parent.quasi)
                   .replace(
                       /\$=["']([^"']*)["']/g,
-                      (_, id) =>
+                      (_, id: string) =>
                           `\${ref(e => { output.${id.replace(/-[a-z]/g, c => c.substr(1).toUpperCase())} = e; })}`);
         }
       },
-      CallExpression(node: CallExpression) {
+      CallExpression(node) {
         if (node.callee.type !== 'MemberExpression' || !isIdentifier(node.callee.property, ['element', '$'])) {
           return;
         }

package/scripts/eslint_rules/lib/no-imperative-dom-api/ui-utils.ts

@@ -2,22 +2,22 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview A library to identify and templatize UI.UIUtils and related calls.
+ * @file A library to identify and templatize UI.UIUtils and related calls.
  */
 
 import type {TSESTree} from '@typescript-eslint/utils';
 
-import {isIdentifier, isIdentifierChain, isMemberExpression} from './ast.ts';
+import {isIdentifier, isIdentifierChain, isMemberExpression, type RuleCreator} from './ast.ts';
 import {DomFragment} from './dom-fragment.ts';
 
-type CallExpression = TSESTree.CallExpression;
 type Node = TSESTree.Node;
 
-export const uiUtils = {
+export const uiUtils: RuleCreator = {
   create(context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
+
     return {
-      CallExpression(node: CallExpression) {
+      CallExpression(node) {
         let func = isMemberExpression(
             node.callee, n => isIdentifierChain(n, ['UI', 'UIUtils', 'CheckboxLabel']),
             n => isIdentifier(n, ['create', 'createWithStringLiteral']));
@@ -178,7 +178,7 @@ export const uiUtils = {
           }
         }
       },
-      functionCall(call: CallExpression, _firstArg: Node, secondArg: Node, domFragment: DomFragment): boolean {
+      functionCall(call, _firstArg, secondArg, domFragment) {
         if (isIdentifierChain(call.callee, ['UI', 'SettingsUI', 'bindCheckbox'])) {
           let setting = secondArg;
           if (setting.type === 'CallExpression' &&

package/scripts/eslint_rules/lib/no-imperative-dom-api/widget.ts

@@ -2,27 +2,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview Library to identify and templatize manually construction of widgets.
+ * @file Library to identify and templatize manually construction of widgets.
  */
 import type {TSESTree} from '@typescript-eslint/utils';
 
-import {isIdentifier, isIdentifierChain, isMemberExpression} from './ast.ts';
+import {isIdentifier, isIdentifierChain, isMemberExpression, type RuleCreator} from './ast.ts';
 import {ClassMember} from './class-member.ts';
 import {DomFragment} from './dom-fragment.ts';
 
 type Identifier = TSESTree.Identifier;
-type Node = TSESTree.Node;
-type CallExpression = TSESTree.CallExpression;
 type MemberExpression = TSESTree.MemberExpression;
-type AssignmentExpression = TSESTree.AssignmentExpression;
 
-export const widget = {
+export const widget: RuleCreator = {
   create: function(context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
+
     return {
-      methodCall(
-          property: Identifier, firstArg: Node, secondArg: Node|undefined, domFragment: DomFragment,
-          _call: CallExpression) {
+      methodCall(property, firstArg, secondArg, domFragment) {
         if (domFragment.tagName !== 'devtools-widget') {
           return false;
         }
@@ -35,8 +31,7 @@ export const widget = {
         }
         return false;
       },
-      propertyAssignment(
-          property: Identifier, value: Node, domFragment: DomFragment, _assignment: AssignmentExpression) {
+      propertyAssignment(property, value, domFragment) {
         if (domFragment.tagName !== 'devtools-widget') {
           return false;
         }
@@ -48,7 +43,7 @@ export const widget = {
         }
         return false;
       },
-      functionCall(call: CallExpression, _firstArg: Node, _secondArg: Node|undefined, domFragment: DomFragment) {
+      functionCall(call, _firstArg, _secondArg, domFragment) {
         if (isMemberExpression(call.callee, _ => true, n => isIdentifier(n, 'show'))) {
           let widget = (call.callee as MemberExpression).object;
           if (widget.type === 'CallExpression' &&

package/scripts/eslint_rules/lib/no-imperative-dom-api.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview Rule to identify and templatize manually constructed DOM.
+ * @file Rule to identify and templatize manually constructed DOM.
  */
 
 import type {TSESTree} from '@typescript-eslint/utils';
@@ -22,31 +22,12 @@ import {uiFragment} from './no-imperative-dom-api/ui-fragment.ts';
 import {uiUtils} from './no-imperative-dom-api/ui-utils.ts';
 import {widget} from './no-imperative-dom-api/widget.ts';
 import {createRule} from './utils/ruleCreator.ts';
-type CallExpression = TSESTree.CallExpression;
 type Identifier = TSESTree.Identifier;
 type MemberExpression = TSESTree.MemberExpression;
-type NewExpression = TSESTree.NewExpression;
 type CallExpressionArgument = TSESTree.CallExpressionArgument;
 type Node = TSESTree.Node;
 type Range = TSESTree.Range;
 
-type Subrule = Partial<{
-  getEvent(event: Node): string | null,
-  propertyAssignment(property: Identifier, propertyValue: Node, domFragment: DomFragment): boolean,
-  methodCall(property: Identifier, firstArg: Node, secondArg: Node, domFragment: DomFragment, call: CallExpression):
-      boolean,
-  propertyMethodCall(property: Identifier, method: Node, firstArg: Node, domFragment: DomFragment): boolean,
-  subpropertyAssignment(
-      property: Identifier, subproperty: Identifier, subpropertyValue: Node, domFragment: DomFragment): boolean,
-  functionCall(call: CallExpression, firstArg: Node, secondArg: Node, domFragment: DomFragment): boolean,
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  MemberExpression: (node: MemberExpression) => void,
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  NewExpression: (node: NewExpression) => void,
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  CallExpression: (node: CallExpression) => void,
-}>;
-
 export default createRule({
   name: 'no-imperative-dom-api',
   meta: {
@@ -63,9 +44,9 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
 
-    const subrules: Subrule[] = [
+    const subrules = [
       adorner.create(context),
       ariaUtils.create(context),
       button.create(context),

package/scripts/eslint_rules/lib/no-importing-images-from-src.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview Prevent importing SVG urls from the `src` directory, and
+ * @file Prevent importing SVG urls from the `src` directory, and
  * ensure they are read from `Images/foo.svg`.
  * Images in the `src/` directory are minified and put into `Images/` as part
  * of the build process, so we should never import from 'src'.

package/scripts/eslint_rules/lib/no-imports-in-directory.ts

@@ -8,7 +8,10 @@ import {createRule} from './utils/ruleCreator.ts';
 
 // Define the structure of the options object
 interface Options {
-  bannedImportPaths?: string[];
+  bannedImportPaths?: Array<{
+    bannedPath: string,
+    allowTypeImports: boolean,
+  }>;
 }
 
 export default createRule<Options[], 'invalidImport'>({
@@ -30,7 +33,11 @@ export default createRule<Options[], 'invalidImport'>({
           bannedImportPaths: {
             type: 'array',
             items: {
-              type: 'string',
+              type: 'object',
+              properties: {
+                bannedPath: {type: 'string'},
+                allowTypeImports: {type: 'boolean'},
+              }
             },
           },
         },
@@ -60,12 +67,16 @@ export default createRule<Options[], 'invalidImport'>({
             path.dirname(fileNameOfFileBeingChecked),
             node.source.value,
         );
-        for (const banned of bannedPaths) {
-          // Ensure 'banned' is a string before calling includes
-          if (typeof banned === 'string' && importPath.includes(banned)) {
-            context.report({node, messageId: 'invalidImport'});
-            break;
+        for (const {bannedPath, allowTypeImports} of bannedPaths) {
+          if (!importPath.includes(bannedPath)) {
+            continue;
           }
+          if (allowTypeImports && node.importKind === 'type') {
+            continue;
+          }
+
+          context.report({node, messageId: 'invalidImport'});
+          break;
         }
       },
     };

package/scripts/eslint_rules/lib/no-lit-render-outside-of-view.ts

@@ -2,17 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview Rule to identify Lit render calls that are not inside of a
+ * @file Rule to identify Lit render calls that are not inside of a
  * view function.
  */
-import type {Rule} from 'eslint';
-import type {ArrowFunctionExpression, FunctionDeclaration, FunctionExpression} from 'estree';
+import type {TSESTree} from '@typescript-eslint/utils';
+import {isCommaToken} from '@typescript-eslint/utils/ast-utils';
+import {nullThrows, NullThrowsReasons} from '@typescript-eslint/utils/eslint-utils';
+import type {ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, Identifier} from 'estree';
 
-import {isLitHtmlRenderCall} from './utils/lit.ts';
+import {isLitHtmlRenderCall, isViewFunction} from './utils/lit.ts';
 import {createRule} from './utils/ruleCreator.ts';
 
-type Node = Rule.Node;
-
 export default createRule({
   name: 'no-lit-render-outside-of-view',
   meta: {
@@ -23,69 +23,80 @@ export default createRule({
     },
     messages: {
       litRenderShouldBeInsideOfView: 'Lit render calls should be inside of a view function',
+      litRenderInsideOfViewMustUseTarget: 'Lit render calls inside of a view function must use the `target` parameter',
+      litRenderInsideOfViewMustNotUseHost: 'Lit render calls inside of a view function must not use the `host` option',
     },
+    fixable: 'code',
     schema: [],  // no options
   },
   defaultOptions: [],
   create: function(context) {
+    const {sourceCode} = context;
     return {
       CallExpression(node) {
         if (!isLitHtmlRenderCall(node)) {
           return;
         }
-        if (node.arguments.length !== 3) {
-          context.report({
-            node,
-            messageId: 'litRenderShouldBeInsideOfView',
-          });
-          return;
-        }
-        let functionNode = node.parent as Node | undefined;
+        let functionNode: TSESTree.Node|undefined = node.parent;
         while (functionNode &&
                !['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'].includes(functionNode.type)) {
           functionNode = functionNode.parent;
         }
-        if (!functionNode) {
+        if (!functionNode || !isViewFunction(functionNode)) {
           context.report({
             node,
             messageId: 'litRenderShouldBeInsideOfView',
           });
           return;
         }
+
         type FunctionLike = FunctionDeclaration|FunctionExpression|ArrowFunctionExpression;
-        const paramNames =
-            (functionNode as FunctionLike).params.filter(p => p.type === 'Identifier').map(param => param.name);
-        if (paramNames.length !== 3 || !paramNames[0].toLowerCase().endsWith('input') ||
-            !paramNames[1].toLowerCase().endsWith('output') || !paramNames[2].toLowerCase().endsWith('target')) {
+        const targetParameterName = ((functionNode as FunctionLike).params[2] as Identifier).name;
+        const targetArgument = node.arguments[1];
+        if (targetArgument.type !== 'Identifier' || targetArgument.name !== targetParameterName) {
           context.report({
             node,
-            messageId: 'litRenderShouldBeInsideOfView',
+            messageId: 'litRenderInsideOfViewMustUseTarget',
+            fix(fixer) {
+              return fixer.replaceText(targetArgument, targetParameterName);
+            }
           });
           return;
         }
-        const targetArgument = node.arguments[1];
-        if (targetArgument.type !== 'Identifier' || targetArgument.name !== paramNames[2]) {
-          context.report({
-            node,
-            messageId: 'litRenderShouldBeInsideOfView',
-          });
+
+        if (node.arguments.length < 3) {
           return;
         }
-        const optionsArgument = node.arguments[2];
-        if (optionsArgument.type !== 'ObjectExpression') {
+        const renderOptions = node.arguments[2];
+        if (renderOptions.type !== 'ObjectExpression') {
           // Invalid, but TypeScript will catch it.
           return;
         }
 
-        for (const property of optionsArgument.properties) {
-          if (property.type === 'Property' && property.key.type === 'Identifier' && property.key.name === 'host') {
-            if (property.value.type !== 'Identifier' || property.value.name !== paramNames[0]) {
-              context.report({
-                node,
-                messageId: 'litRenderShouldBeInsideOfView',
-              });
-            }
-            return;
+        for (const renderOption of renderOptions.properties) {
+          if (renderOption.type === 'Property' && renderOption.key.type === 'Identifier' &&
+              renderOption.key.name === 'host') {
+            context.report({
+              node,
+              messageId: 'litRenderInsideOfViewMustNotUseHost',
+              fix(fixer) {
+                if (renderOptions.properties.length === 1) {
+                  const commaToken = nullThrows(
+                      sourceCode.getTokenBefore(renderOptions, isCommaToken),
+                      NullThrowsReasons.MissingToken(',', node.type));
+                  return fixer.removeRange([commaToken.range[0], renderOptions.range[1]]);
+                }
+                const prevToken = sourceCode.getTokenBefore(renderOption);
+                if (prevToken && isCommaToken(prevToken)) {
+                  return fixer.removeRange([prevToken.range[0], renderOption.range[1]]);
+                }
+                const nextToken = sourceCode.getTokenAfter(renderOption);
+                if (nextToken && isCommaToken(nextToken)) {
+                  return fixer.removeRange([renderOption.range[0], nextToken.range[1]]);
+                }
+                return [];
+              }
+            });
           }
         }
       },

package/scripts/eslint_rules/lib/no-new-lit-element-components.ts

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import path from 'node:path';
+
 import {createRule} from './utils/ruleCreator.ts';
 
 const allowedPaths = [
@@ -24,7 +26,7 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
-    const filename = context.filename ?? context.getFilename();
+    const filename = context.filename;
     return {
       ClassDeclaration(node) {
         // Use `extends LitElement` as a signal.
@@ -32,7 +34,8 @@ export default createRule({
           return;
         }
         // Existing components are still allowed.
-        if (allowedPaths.some(path => filename.startsWith(path))) {
+        // This needs to use includes if we resolve the full path
+        if (allowedPaths.some(allowedPath => path.normalize(filename).includes(path.normalize(allowedPath)))) {
           return;
         }
         context.report({

package/scripts/eslint_rules/lib/no-underscored-properties.ts

@@ -2,42 +2,27 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import type {TSESTree} from '@typescript-eslint/utils';
+
 import {createRule} from './utils/ruleCreator.ts';
 
-function hasPublicMethodForUnderscoredProperty(node) {
+function hasPublicMethodForUnderscoredProperty(node: TSESTree.PropertyDefinition|TSESTree.MethodDefinition) {
+  if (node.key.type !== 'Identifier') {
+    return false;
+  }
   const nodeName = node.key.name;
   // We allow a property to start with an underscore if the class defines a public getter without an underscore.
-  const methodsDeclared =
-      node.parent.body.filter(item => item.type === 'MethodDefinition' && item.key.type === 'Identifier');
+  const methodsDeclared = node.parent.body.filter(item => item.type === 'MethodDefinition');
   const hasMethodDeclaredWithNonUnderscoredName = methodsDeclared.find(method => {
+    if (method.key.type !== 'Identifier') {
+      return false;
+    }
     const methodName = method.key.name;
-    return (nodeName.slice(1) === methodName);
+    return nodeName.slice(1) === methodName;
   });
   return hasMethodDeclaredWithNonUnderscoredName;
 }
 
-function checkNodeForUnderscoredProperties(context, node, typeOfNode) {
-  if (node.key.type !== 'Identifier') {
-    return;
-  }
-
-  const nodeName = node.key.name;
-  if (!nodeName.startsWith('_')) {
-    return;
-  }
-
-  // We allow a property to start with an underscore if the class defines a public getter without an underscore.
-  if (hasPublicMethodForUnderscoredProperty(node)) {
-    return;
-  }
-
-  context.report({
-    node,
-    data: {propName: nodeName, typeOfNode},
-    messageId: 'underscorePrefix',
-  });
-}
-
 export default createRule({
   name: 'no-underscored-properties',
   meta: {
@@ -54,16 +39,39 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
+    function checkNodeForUnderscoredProperties(
+        node: TSESTree.PropertyDefinition|TSESTree.MethodDefinition, typeOfNode: string) {
+      if (node.key.type !== 'Identifier') {
+        return;
+      }
+
+      const nodeName = node.key.name;
+      if (!nodeName.startsWith('_')) {
+        return;
+      }
+
+      // We allow a property to start with an underscore if the class defines a public getter without an underscore.
+      if (hasPublicMethodForUnderscoredProperty(node)) {
+        return;
+      }
+
+      context.report({
+        node,
+        data: {propName: nodeName, typeOfNode},
+        messageId: 'underscorePrefix',
+      });
+    }
+
     return {
       PropertyDefinition(node) {
-        checkNodeForUnderscoredProperties(context, node, 'property');
+        checkNodeForUnderscoredProperties(node, 'property');
       },
       MethodDefinition(node) {
         if (node.parent.type !== 'ClassBody') {
           // We only want to check method declarations within classes.
           return;
         }
-        checkNodeForUnderscoredProperties(context, node, 'method');
+        checkNodeForUnderscoredProperties(node, 'method');
       }
     };
   }

package/scripts/eslint_rules/lib/prefer-assert-instance-of.ts

@@ -2,11 +2,30 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import type {TSESTree} from '@typescript-eslint/utils';
+
 import {createRule} from './utils/ruleCreator.ts';
 
 const FALSY_ASSERTIONS = new Set(['isFalse', 'isNotOk', 'isNotTrue', 'notOk']);
 const TRUTHY_ASSERTIONS = new Set(['isNotFalse', 'isOk', 'isTrue', 'ok']);
 
+function isTruthyAssertion(node: TSESTree.Expression) {
+  if (node.type === 'Identifier' && node.name === 'assert') {
+    return true;
+  }
+  return node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'assert' &&
+      node.property.type === 'Identifier' && TRUTHY_ASSERTIONS.has(node.property.name);
+}
+
+function isFalsyAssertion(node: TSESTree.Expression) {
+  return node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'assert' &&
+      node.property.type === 'Identifier' && FALSY_ASSERTIONS.has(node.property.name);
+}
+
+function isInstanceofExpression(node: TSESTree.CallExpressionArgument) {
+  return node.type === 'BinaryExpression' && node.operator === 'instanceof';
+}
+
 export default createRule({
   name: 'prefer-assert-instance-of',
   meta: {
@@ -25,26 +44,8 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
-    function isTruthyAssertion(calleeNode) {
-      if (calleeNode.type === 'Identifier' && calleeNode.name === 'assert') {
-        return true;
-      }
-      return calleeNode.type === 'MemberExpression' && calleeNode.object.type === 'Identifier' &&
-          calleeNode.object.name === 'assert' && calleeNode.property.type === 'Identifier' &&
-          TRUTHY_ASSERTIONS.has(calleeNode.property.name);
-    }
-
-    function isFalsyAssertion(calleeNode) {
-      return calleeNode.type === 'MemberExpression' && calleeNode.object.type === 'Identifier' &&
-          calleeNode.object.name === 'assert' && calleeNode.property.type === 'Identifier' &&
-          FALSY_ASSERTIONS.has(calleeNode.property.name);
-    }
-
-    function isInstanceofExpression(argumentNode) {
-      return argumentNode.type === 'BinaryExpression' && argumentNode.operator === 'instanceof';
-    }
-
-    function reportError(node, calleeText, messageId) {
+    function reportError(
+        node: TSESTree.CallExpression, calleeText: string, messageId: 'useAssertInstanceOf'|'useAssertNotInstanceOf') {
       context.report({
         node,
         messageId,
@@ -52,6 +53,9 @@ export default createRule({
           const {sourceCode} = context;
           const calleeNode = node.callee;
           const [argumentNode] = node.arguments;
+          if (!('left' in argumentNode && 'right' in argumentNode)) {
+            return [];
+          }
           const argumentText = `${sourceCode.getText(argumentNode.left)}, ${sourceCode.getText(argumentNode.right)}`;
           return [
             fixer.replaceText(calleeNode, calleeText),