eslint-plugin-ts-data-forge 0.6.1 → 0.7.1

package/dist/rules/no-unnecessary-type-guard.mjs

@@ -1,290 +1,401 @@
-import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, ESLintUtils, } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
-import { getTsDataForgeImport, buildCalleeResolver, getImportedLocalName, buildImportFixes } from './import-utils.mjs';
+import { buildCalleeResolver, buildImportFixes, getImportedLocalName, getTsDataForgeImport, } from './import-utils.mjs';
 
-const BRAND_MARKER_PROPERTY = "TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3";
-const MIN_LENGTH_BRAND_KEY = "MinLength";
+
+
+
+
+const BRAND_MARKER_PROPERTY = 'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3';
+
+
+
+
+
+
+const MIN_LENGTH_BRAND_KEY = 'MinLength';
 const NULLISH_REPLACEMENTS_EXCLUDE = {
-  undefined: "isNotUndefined",
-  null: "isNotNull"
+    undefined: 'isNotUndefined',
+    null: 'isNotNull',
 };
 const NULLISH_REPLACEMENTS_NARROW = {
-  undefined: "isUndefined",
-  null: "isNull"
+    undefined: 'isUndefined',
+    null: 'isNull',
 };
 const GUARD_SPECS = {
-  isUndefined: { kind: "narrowTo", atoms: ["undefined"] },
-  isNotUndefined: { kind: "excludeFrom", atoms: ["undefined"] },
-  isNull: { kind: "narrowTo", atoms: ["null"] },
-  isNotNull: { kind: "excludeFrom", atoms: ["null"] },
-  isBoolean: { kind: "narrowTo", atoms: ["boolean"] },
-  isNotBoolean: { kind: "excludeFrom", atoms: ["boolean"] },
-  isNumber: { kind: "narrowTo", atoms: ["number"] },
-  isNotNumber: { kind: "excludeFrom", atoms: ["number"] },
-  isString: { kind: "narrowTo", atoms: ["string"] },
-  isNotString: { kind: "excludeFrom", atoms: ["string"] },
-  isBigint: { kind: "narrowTo", atoms: ["bigint"] },
-  isNotBigint: { kind: "excludeFrom", atoms: ["bigint"] },
-  isSymbol: { kind: "narrowTo", atoms: ["symbol"] },
-  isNotSymbol: { kind: "excludeFrom", atoms: ["symbol"] },
-  isNullish: {
-    kind: "narrowTo",
-    atoms: ["null", "undefined"],
-    replacements: NULLISH_REPLACEMENTS_NARROW
-  },
-  isNonNullish: {
-    kind: "excludeFrom",
-    atoms: ["null", "undefined"],
-    replacements: NULLISH_REPLACEMENTS_EXCLUDE
-  },
-  isNonEmptyString: { kind: "nonEmptyString" },
-  isRecord: { kind: "record" }
-};
-const DEFERRED_OR_OPAQUE_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never | ts.TypeFlags.TypeParameter | ts.TypeFlags.IndexedAccess | ts.TypeFlags.Conditional | ts.TypeFlags.Substitution;
-const noUnnecessaryTypeGuard = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard)."
+    isUndefined: { kind: 'narrowTo', atoms: ['undefined'] },
+    isNotUndefined: { kind: 'excludeFrom', atoms: ['undefined'] },
+    isNull: { kind: 'narrowTo', atoms: ['null'] },
+    isNotNull: { kind: 'excludeFrom', atoms: ['null'] },
+    isBoolean: { kind: 'narrowTo', atoms: ['boolean'] },
+    isNotBoolean: { kind: 'excludeFrom', atoms: ['boolean'] },
+    isNumber: { kind: 'narrowTo', atoms: ['number'] },
+    isNotNumber: { kind: 'excludeFrom', atoms: ['number'] },
+    isString: { kind: 'narrowTo', atoms: ['string'] },
+    isNotString: { kind: 'excludeFrom', atoms: ['string'] },
+    isBigint: { kind: 'narrowTo', atoms: ['bigint'] },
+    isNotBigint: { kind: 'excludeFrom', atoms: ['bigint'] },
+    isSymbol: { kind: 'narrowTo', atoms: ['symbol'] },
+    isNotSymbol: { kind: 'excludeFrom', atoms: ['symbol'] },
+    isNullish: {
+        kind: 'narrowTo',
+        atoms: ['null', 'undefined'],
+        replacements: NULLISH_REPLACEMENTS_NARROW,
     },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          ignore: {
-            type: "array",
-            items: { type: "string" },
-            description: "Names of ts-data-forge guard functions to skip checking."
-          }
+    isNonNullish: {
+        kind: 'excludeFrom',
+        atoms: ['null', 'undefined'],
+        replacements: NULLISH_REPLACEMENTS_EXCLUDE,
+    },
+    isNonEmptyString: { kind: 'nonEmptyString' },
+    isRecord: { kind: 'record' },
+};
+const DEFERRED_OR_OPAQUE_FLAGS = ts.TypeFlags.Any |
+    ts.TypeFlags.Unknown |
+    ts.TypeFlags.Never |
+    ts.TypeFlags.TypeParameter |
+    ts.TypeFlags.IndexedAccess |
+    ts.TypeFlags.Conditional |
+    ts.TypeFlags.Substitution;
+export const noUnnecessaryTypeGuard = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard).',
         },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      alwaysTrue: "Unnecessary `{{name}}` call: the argument type guarantees it always returns `true`. Replace the call with `true`.",
-      alwaysFalse: "Unnecessary `{{name}}` call: the argument type guarantees it always returns `false`. Replace the call with `false`.",
-      replaceTypeGuard: "Unnecessary `{{from}}` call: the argument can only be narrowed by `{{to}}`. Use `{{to}}` instead."
-    }
-  },
-  create: (context) => {
-    const options = context.options[0];
-    const parserServices = ESLintUtils.getParserServices(context);
-    const compilerOptions = parserServices.program.getCompilerOptions();
-    const strictNullChecks = compilerOptions.strictNullChecks ?? compilerOptions.strict ?? false;
-    if (!strictNullChecks) return {};
-    const checker = parserServices.program.getTypeChecker();
-    const sourceCode = context.sourceCode;
-    const program = sourceCode.ast;
-    const ignored = new Set(options?.ignore);
-    const tsDataForgeImport = getTsDataForgeImport(program);
-    const resolveGuard = buildCalleeResolver(tsDataForgeImport);
-    const buildReplaceFix = (isNamespace, propertyNode, replacement) => (fixer) => {
-      if (isNamespace) {
-        return [fixer.replaceText(propertyNode, replacement)];
-      }
-      const localName = getImportedLocalName(
-        tsDataForgeImport,
-        replacement
-      );
-      if (localName !== void 0) {
-        return [fixer.replaceText(propertyNode, localName)];
-      }
-      return [
-        ...buildImportFixes(fixer, program, tsDataForgeImport, [
-          replacement
-        ]),
-        fixer.replaceText(propertyNode, replacement)
-      ];
-    };
-    const reportConstant = (node, name, value, argument) => {
-      const canFix = isSideEffectFreeArg(argument);
-      context.report({
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        node,
-        messageId: value ? "alwaysTrue" : "alwaysFalse",
-        data: { name },
-        fix: canFix ? (fixer) => fixer.replaceText(
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          node,
-          value ? "true" : "false"
-        ) : void 0
-      });
-    };
-    const reportReplace = (node, from, to, isNamespace, propertyNode) => {
-      context.report({
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        node,
-        messageId: "replaceTypeGuard",
-        data: { from, to },
-        fix: buildReplaceFix(isNamespace, propertyNode, to)
-      });
-    };
-    return {
-      CallExpression: (node) => {
-        if (node.arguments.length !== 1) return;
-        const argument = node.arguments[0];
-        if (argument === void 0 || argument.type === AST_NODE_TYPES.SpreadElement) {
-          return;
-        }
-        const resolved = resolveGuard(node.callee);
-        if (resolved === void 0) return;
-        const { canonicalName, propertyNode, isNamespace } = resolved;
-        if (ignored.has(canonicalName)) return;
-        const spec = GUARD_SPECS[canonicalName];
-        if (spec === void 0) return;
-        const argTsNode = parserServices.esTreeNodeToTSNodeMap.get(argument);
-        const argType = checker.getTypeAtLocation(argTsNode);
-        const parts = collectUnionParts(argType);
-        if (parts === void 0) return;
-        const inputAtoms = new Set(parts.map(classifyAtom));
-        const hasMemberOutsideTarget = (atoms) => {
-          const targetSet = new Set(atoms);
-          return parts.some((p) => !targetSet.has(classifyAtom(p)));
-        };
-        switch (spec.kind) {
-          case "excludeFrom": {
-            const removable = spec.atoms.filter((a) => inputAtoms.has(a));
-            if (removable.length === 0) {
-              reportConstant(node, canonicalName, true, argument);
-            } else if (!hasMemberOutsideTarget(spec.atoms)) {
-              reportConstant(node, canonicalName, false, argument);
-            } else if (removable.length < spec.atoms.length) {
-              const replacement = spec.replacements?.[joinAtoms(removable)];
-              if (replacement !== void 0) {
-                reportReplace(
-                  node,
-                  canonicalName,
-                  replacement,
-                  isNamespace,
-                  propertyNode
-                );
-              }
-            }
-            break;
-          }
-          case "narrowTo": {
-            const present = spec.atoms.filter((a) => inputAtoms.has(a));
-            if (present.length === 0) {
-              reportConstant(node, canonicalName, false, argument);
-            } else if (!hasMemberOutsideTarget(spec.atoms)) {
-              reportConstant(node, canonicalName, true, argument);
-            } else if (present.length < spec.atoms.length) {
-              const replacement = spec.replacements?.[joinAtoms(present)];
-              if (replacement !== void 0) {
-                reportReplace(
-                  node,
-                  canonicalName,
-                  replacement,
-                  isNamespace,
-                  propertyNode
-                );
-              }
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignore: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Names of ts-data-forge guard functions to skip checking.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            alwaysTrue: 'Unnecessary `{{name}}` call: the argument type guarantees it always returns `true`. Replace the call with `true`.',
+            alwaysFalse: 'Unnecessary `{{name}}` call: the argument type guarantees it always returns `false`. Replace the call with `false`.',
+            replaceTypeGuard: 'Unnecessary `{{from}}` call: the argument can only be narrowed by `{{to}}`. Use `{{to}}` instead.',
+        },
+    },
+    create: (context) => {
+        const options = context.options[0];
+        const parserServices = ESLintUtils.getParserServices(context);
+        const compilerOptions = parserServices.program.getCompilerOptions();
+
+
+        const strictNullChecks = compilerOptions.strictNullChecks ?? compilerOptions.strict ?? false;
+        if (!strictNullChecks)
+            return {};
+        const checker = parserServices.program.getTypeChecker();
+        const sourceCode = context.sourceCode;
+        const program = sourceCode.ast;
+        const ignored = new Set(options?.ignore);
+        const tsDataForgeImport = getTsDataForgeImport(program);
+        const resolveGuard = buildCalleeResolver(tsDataForgeImport);
+        const buildReplaceFix = (isNamespace, 
+
+        propertyNode, replacement) => (fixer) => {
+
+
+            if (isNamespace) {
+                return [fixer.replaceText(propertyNode, replacement)];
             }
-            break;
-          }
-          case "record": {
-            if (parts.every((p) => isGuaranteedRecord(p, checker))) {
-              reportConstant(node, canonicalName, true, argument);
-            } else if (parts.every((p) => isGuaranteedNotRecord(p, checker))) {
-              reportConstant(node, canonicalName, false, argument);
+
+
+
+            const localName = getImportedLocalName(tsDataForgeImport, replacement);
+            if (localName !== undefined) {
+                return [fixer.replaceText(propertyNode, localName)];
             }
-            break;
-          }
-          case "nonEmptyString": {
-            const hasNullish = inputAtoms.has("undefined") || inputAtoms.has("null");
-            const nonNullishParts = parts.filter((p) => {
-              const atom = classifyAtom(p);
-              return atom !== "undefined" && atom !== "null";
+            return [
+                ...buildImportFixes(fixer, program, tsDataForgeImport, [
+                    replacement,
+                ]),
+                fixer.replaceText(propertyNode, replacement),
+            ];
+        };
+        const reportConstant = (node, name, value, argument) => {
+
+
+            const canFix = isSideEffectFreeArg(argument);
+            context.report({
+
+                node: node,
+                messageId: value ? 'alwaysTrue' : 'alwaysFalse',
+                data: { name },
+                fix: canFix
+                    ? (fixer) => fixer.replaceText(
+
+                    node, value ? 'true' : 'false')
+                    : undefined,
             });
-            if (!nonNullishParts.some(couldBeNonEmptyString)) {
-              reportConstant(node, canonicalName, false, argument);
-              break;
-            }
-            if (nonNullishParts.some(
-              (p) => !isGuaranteedNonEmptyString(p, checker)
-            )) {
-              break;
-            }
-            if (hasNullish) {
-              reportReplace(
-                node,
-                canonicalName,
-                "isNonNullish",
-                isNamespace,
-                propertyNode
-              );
-            } else {
-              reportConstant(node, canonicalName, true, argument);
-            }
-            break;
-          }
-        }
-      }
-    };
-  },
-  defaultOptions: [{}]
+        };
+        const reportReplace = (node, from, to, isNamespace, 
+
+        propertyNode) => {
+            context.report({
+
+                node: node,
+                messageId: 'replaceTypeGuard',
+                data: { from, to },
+                fix: buildReplaceFix(isNamespace, propertyNode, to),
+            });
+        };
+        return {
+            CallExpression: (node) => {
+                if (node.arguments.length !== 1)
+                    return;
+                const argument = node.arguments[0];
+                if (argument === undefined ||
+                    argument.type === AST_NODE_TYPES.SpreadElement) {
+                    return;
+                }
+                const resolved = resolveGuard(node.callee);
+                if (resolved === undefined)
+                    return;
+                const { canonicalName, propertyNode, isNamespace } = resolved;
+                if (ignored.has(canonicalName))
+                    return;
+                const spec = GUARD_SPECS[canonicalName];
+                if (spec === undefined)
+                    return;
+                const argTsNode = parserServices.esTreeNodeToTSNodeMap.get(argument);
+                const argType = checker.getTypeAtLocation(argTsNode);
+                const parts = collectUnionParts(argType);
+                if (parts === undefined)
+                    return;
+                const inputAtoms = new Set(parts.map(classifyAtom));
+                const hasMemberOutsideTarget = (atoms) => {
+                    const targetSet = new Set(atoms);
+                    return parts.some((p) => !targetSet.has(classifyAtom(p)));
+                };
+                switch (spec.kind) {
+                    case 'excludeFrom': {
+                        const removable = spec.atoms.filter((a) => inputAtoms.has(a));
+                        if (removable.length === 0) {
+
+                            reportConstant(node, canonicalName, true, argument);
+                        }
+                        else if (!hasMemberOutsideTarget(spec.atoms)) {
+
+                            reportConstant(node, canonicalName, false, argument);
+                        }
+                        else if (removable.length < spec.atoms.length) {
+                            const replacement = spec.replacements?.[joinAtoms(removable)];
+                            if (replacement !== undefined) {
+                                reportReplace(node, canonicalName, replacement, isNamespace, propertyNode);
+                            }
+                        }
+                        break;
+                    }
+                    case 'narrowTo': {
+                        const present = spec.atoms.filter((a) => inputAtoms.has(a));
+                        if (present.length === 0) {
+
+                            reportConstant(node, canonicalName, false, argument);
+                        }
+                        else if (!hasMemberOutsideTarget(spec.atoms)) {
+
+                            reportConstant(node, canonicalName, true, argument);
+                        }
+                        else if (present.length < spec.atoms.length) {
+                            const replacement = spec.replacements?.[joinAtoms(present)];
+                            if (replacement !== undefined) {
+                                reportReplace(node, canonicalName, replacement, isNamespace, propertyNode);
+                            }
+                        }
+                        break;
+                    }
+                    case 'record': {
+                        if (parts.every((p) => isGuaranteedRecord(p, checker))) {
+
+                            reportConstant(node, canonicalName, true, argument);
+                        }
+                        else if (parts.every((p) => isGuaranteedNotRecord(p, checker))) {
+
+                            reportConstant(node, canonicalName, false, argument);
+                        }
+                        break;
+                    }
+                    case 'nonEmptyString': {
+                        const hasNullish = inputAtoms.has('undefined') || inputAtoms.has('null');
+                        const nonNullishParts = parts.filter((p) => {
+                            const atom = classifyAtom(p);
+                            return atom !== 'undefined' && atom !== 'null';
+                        });
+                        if (!nonNullishParts.some(couldBeNonEmptyString)) {
+
+                            reportConstant(node, canonicalName, false, argument);
+                            break;
+                        }
+                        if (nonNullishParts.some((p) => !isGuaranteedNonEmptyString(p, checker))) {
+                            break;
+                        }
+                        if (hasNullish) {
+                            reportReplace(node, canonicalName, 'isNonNullish', isNamespace, propertyNode);
+                        }
+                        else {
+                            reportConstant(node, canonicalName, true, argument);
+                        }
+                        break;
+                    }
+                }
+            },
+        };
+    },
+    defaultOptions: [{}],
 };
+
+
+
+
+
+
 const collectUnionParts = (type) => {
-  const parts = type.isUnion() ? type.types : [type];
-  for (const part of parts) {
-    if ((part.flags & DEFERRED_OR_OPAQUE_FLAGS) !== 0) return void 0;
-  }
-  return parts;
+    const parts = type.isUnion() ? type.types : [type];
+    for (const part of parts) {
+        if ((part.flags & DEFERRED_OR_OPAQUE_FLAGS) !== 0)
+            return undefined;
+    }
+    return parts;
 };
-const isGuaranteedRecord = (type, checker) => checker.getIndexInfoOfType(type, ts.IndexKind.String) !== void 0 && !isCallableType(type, checker) && !checker.isArrayType(type) && !checker.isTupleType(type);
-const isGuaranteedNotRecord = (type, checker) => classifyAtom(type) !== "other" || checker.isArrayType(type) || checker.isTupleType(type) || isCallableType(type, checker);
-const isCallableType = (type, checker) => checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0 || checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length > 0;
+
+
+
+
+
+
+
+
+
+
+
+
+
+const isGuaranteedRecord = (
+
+type, 
+
+checker) => checker.getIndexInfoOfType(type, ts.IndexKind.String) !== undefined &&
+    !isCallableType(type, checker) &&
+    !checker.isArrayType(type) &&
+    !checker.isTupleType(type);
+
+
+
+
+
+const isGuaranteedNotRecord = (
+
+type, 
+
+checker) => classifyAtom(type) !== 'other' ||
+    checker.isArrayType(type) ||
+    checker.isTupleType(type) ||
+    isCallableType(type, checker);
+const isCallableType = (
+
+type, 
+
+checker) => checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0 ||
+    checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length > 0;
+
+
 const classifyAtom = (type) => {
-  const { flags } = type;
-  if ((flags & ts.TypeFlags.Undefined) !== 0) return "undefined";
-  if ((flags & ts.TypeFlags.Null) !== 0) return "null";
-  if ((flags & ts.TypeFlags.BooleanLike) !== 0) return "boolean";
-  if ((flags & ts.TypeFlags.NumberLike) !== 0) return "number";
-  if ((flags & ts.TypeFlags.StringLike) !== 0) return "string";
-  if ((flags & ts.TypeFlags.BigIntLike) !== 0) return "bigint";
-  if ((flags & ts.TypeFlags.ESSymbolLike) !== 0) return "symbol";
-  if (type.isIntersection()) {
-    for (const constituent of type.types) {
-      const atom = classifyAtom(constituent);
-      if (atom !== "other") return atom;
+    const { flags } = type;
+    if ((flags & ts.TypeFlags.Undefined) !== 0)
+        return 'undefined';
+    if ((flags & ts.TypeFlags.Null) !== 0)
+        return 'null';
+    if ((flags & ts.TypeFlags.BooleanLike) !== 0)
+        return 'boolean';
+    if ((flags & ts.TypeFlags.NumberLike) !== 0)
+        return 'number';
+    if ((flags & ts.TypeFlags.StringLike) !== 0)
+        return 'string';
+    if ((flags & ts.TypeFlags.BigIntLike) !== 0)
+        return 'bigint';
+    if ((flags & ts.TypeFlags.ESSymbolLike) !== 0)
+        return 'symbol';
+
+
+    if (type.isIntersection()) {
+        for (const constituent of type.types) {
+            const atom = classifyAtom(constituent);
+            if (atom !== 'other')
+                return atom;
+        }
     }
-  }
-  return "other";
+    return 'other';
 };
 const ATOM_ORDER = [
-  "undefined",
-  "null",
-  "boolean",
-  "number",
-  "string",
-  "bigint",
-  "symbol"
+    'undefined',
+    'null',
+    'boolean',
+    'number',
+    'string',
+    'bigint',
+    'symbol',
 ];
-const joinAtoms = (atoms) => ATOM_ORDER.filter((atom) => atoms.includes(atom)).join("|");
-const isGuaranteedNonEmptyString = (type, checker) => {
-  if (type.isStringLiteral()) return type.value !== "";
-  if (type.getProperty(BRAND_MARKER_PROPERTY) === void 0) return false;
-  const minLengthSymbol = type.getProperty(MIN_LENGTH_BRAND_KEY);
-  if (minLengthSymbol === void 0) return false;
-  return checker.getTypeOfSymbol(minLengthSymbol).getProperty("0") !== void 0;
+
+const joinAtoms = (atoms) => ATOM_ORDER.filter((atom) => atoms.includes(atom)).join('|');
+
+
+
+
+
+const isGuaranteedNonEmptyString = (
+
+type, 
+
+checker) => {
+    if (type.isStringLiteral())
+        return type.value !== '';
+    if (type.getProperty(BRAND_MARKER_PROPERTY) === undefined)
+        return false;
+    const minLengthSymbol = type.getProperty(MIN_LENGTH_BRAND_KEY);
+    if (minLengthSymbol === undefined)
+        return false;
+
+
+
+    return (checker.getTypeOfSymbol(minLengthSymbol).getProperty('0') !== undefined);
 };
+
+
+
+
+
+
 const couldBeNonEmptyString = (type) => {
-  if (type.isStringLiteral()) return type.value !== "";
-  return classifyAtom(type) === "string";
+    if (type.isStringLiteral())
+        return type.value !== '';
+    return classifyAtom(type) === 'string';
 };
+
+
+
+
+
 const isSideEffectFreeArg = (node) => {
-  switch (node.type) {
-    case AST_NODE_TYPES.Identifier:
-    case AST_NODE_TYPES.ThisExpression:
-    case AST_NODE_TYPES.Literal:
-      return true;
-    case AST_NODE_TYPES.MemberExpression:
-      return isSideEffectFreeArg(node.object) && (!node.computed || isSideEffectFreeArg(node.property));
-    default:
-      return false;
-  }
-};
 
-export { noUnnecessaryTypeGuard };
-//# sourceMappingURL=no-unnecessary-type-guard.mjs.map
+
+    switch (node.type) {
+        case AST_NODE_TYPES.Identifier:
+        case AST_NODE_TYPES.ThisExpression:
+        case AST_NODE_TYPES.Literal:
+            return true;
+        case AST_NODE_TYPES.MemberExpression:
+            return (isSideEffectFreeArg(node.object) &&
+                (!node.computed || isSideEffectFreeArg(node.property)));
+        default:
+            return false;
+    }
+};
+//# sourceMappingURL=no-unnecessary-type-guard.mjs.map