eslint-plugin-sonarjs 4.0.2 → 4.1.0

package/cjs/helpers/type.js

@@ -17,6 +17,8 @@ exports.isUndefinedOrNull = isUndefinedOrNull;
 exports.isThenable = isThenable;
 exports.isThenableOrVoidUnion = isThenableOrVoidUnion;
 exports.isAny = isAny;
+exports.areMutuallyAssignableTypes = areMutuallyAssignableTypes;
+exports.areSameTypeDeclarations = areSameTypeDeclarations;
 exports.isGenericType = isGenericType;
 exports.getTypeFromTreeNode = getTypeFromTreeNode;
 exports.getTypeAsString = getTypeAsString;
@@ -26,6 +28,7 @@ exports.isArrayLikeType = isArrayLikeType;
 exports.isStringArray = isStringArray;
 exports.isNumberArray = isNumberArray;
 exports.isBigIntArray = isBigIntArray;
+exports.isBooleanArray = isBooleanArray;
 exports.isTypeAlias = isTypeAlias;
 exports.isBooleanTrueType = isBooleanTrueType;
 exports.isBooleanType = isBooleanType;
@@ -36,6 +39,9 @@ exports.isIterable = isIterable;
 exports.getFunctionParameterCount = getFunctionParameterCount;
 const typescript_1 = __importDefault(require("typescript"));
 const ast_js_1 = require("./ast.js");
+/**
+ * Returns true when `node` resolves to the built-in `Array` type.
+ */
 function isArray(node, services) {
     const type = getTypeFromTreeNode(node, services);
     return type.symbol?.name === 'Array';
@@ -95,30 +101,51 @@ function isTypedArray(node, services) {
     const type = getTypeFromTreeNode(node, services);
     return TYPED_ARRAY_TYPES.has(type.symbol?.name);
 }
+/**
+ * Returns true when `node` resolves to a string-like type.
+ */
 function isString(node, services) {
     const checker = services.program.getTypeChecker();
     const typ = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return (typ.getFlags() & typescript_1.default.TypeFlags.StringLike) !== 0;
 }
+/**
+ * Returns true when `node` resolves to a number-like type.
+ */
 function isNumber(node, services) {
     const checker = services.program.getTypeChecker();
     const typ = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return (typ.getFlags() & typescript_1.default.TypeFlags.NumberLike) !== 0;
 }
+/**
+ * Returns true when `type` is bigint-like.
+ */
 function isBigIntType(type) {
     return (type.getFlags() & typescript_1.default.TypeFlags.BigIntLike) !== 0;
 }
+/**
+ * Returns true when `type` is number-like.
+ */
 function isNumberType(type) {
     return (type.getFlags() & typescript_1.default.TypeFlags.NumberLike) !== 0;
 }
+/**
+ * Returns true when `type` is string-like.
+ */
 function isStringType(type) {
     return (type.flags & typescript_1.default.TypeFlags.StringLike) > 0 || type.symbol?.name === 'String';
 }
+/**
+ * Returns true when `node` resolves to a function type.
+ */
 function isFunction(node, services) {
     const checker = services.program.getTypeChecker();
     const type = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return type.symbol && (type.symbol.flags & typescript_1.default.SymbolFlags.Function) !== 0;
 }
+/**
+ * Returns true when `node` resolves to a union type.
+ */
 function isUnion(node, services) {
     const checker = services.program.getTypeChecker();
     const type = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
@@ -133,11 +160,17 @@ function isUnion(node, services) {
 function getUnionTypes(type) {
     return type.isUnion() ? type.types : [type];
 }
+/**
+ * Returns true when `node` resolves to `undefined`, `null`, or a union containing either.
+ */
 function isUndefinedOrNull(node, services) {
     const checker = services.program.getTypeChecker();
     const typ = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return ((typ.getFlags() & typescript_1.default.TypeFlags.Undefined) !== 0 || (typ.getFlags() & typescript_1.default.TypeFlags.Null) !== 0);
 }
+/**
+ * Returns true when `node` resolves to a thenable type.
+ */
 function isThenable(node, services) {
     const mapped = services.esTreeNodeToTSNodeMap.get(node);
     const checker = services.program.getTypeChecker();
@@ -174,9 +207,102 @@ function hasThenMethod(type, checker) {
     const thenType = checker.getTypeOfSymbol(thenProperty);
     return thenType.getCallSignatures().length > 0;
 }
+/**
+ * Returns true when `type` is exactly `any`.
+ */
 function isAny(type) {
     return type.flags === typescript_1.default.TypeFlags.Any;
 }
+/**
+ * Returns true when both types are specific enough to compare (neither `any`
+ * nor `unknown`) and are mutually assignable.
+ *
+ * Mutual assignability is stricter than symbol equality for generic aliases:
+ * `Props<User>` and `Props<Product>` share the same alias symbol, but they are
+ * not mutually assignable and therefore do not represent the same effective type.
+ */
+function areMutuallyAssignableTypes(checker, left, right) {
+    if (!left || !right || isAnyOrUnknownType(left) || isAnyOrUnknownType(right)) {
+        return false;
+    }
+    // @ts-ignore -- isTypeAssignableTo is a private TypeScript API
+    return checker.isTypeAssignableTo(left, right) && checker.isTypeAssignableTo(right, left);
+}
+/**
+ * Returns true when both types come from the same named declaration and, for
+ * generic declarations, are instantiated with the same type arguments.
+ *
+ * The comparison has two steps:
+ * 1. the declarations must resolve to the same symbol
+ * 2. each type argument must match through `areSameTypeArguments(...)`
+ *
+ * That helper can call back into this function for named type arguments, so
+ * generic comparisons recurse through nested declarations.
+ *
+ * This is intentionally stricter than structural equality: `Props<User>` and
+ * `Props<Product>` are different, and `Props<User>` also stays different from
+ * `Props<{ id: string }>` even if the shapes happen to match.
+ */
+function areSameTypeDeclarations(checker, left, right) {
+    if (!left || !right || isAnyOrUnknownType(left) || isAnyOrUnknownType(right)) {
+        return false;
+    }
+    const leftSymbol = getComparableDeclaredTypeSymbol(left);
+    const rightSymbol = getComparableDeclaredTypeSymbol(right);
+    if (!leftSymbol || leftSymbol !== rightSymbol) {
+        return false;
+    }
+    const leftArgs = getDeclaredTypeArguments(left, checker);
+    const rightArgs = getDeclaredTypeArguments(right, checker);
+    return (leftArgs.length === rightArgs.length &&
+        leftArgs.every((argument, index) => areSameTypeArguments(checker, argument, rightArgs[index])));
+}
+function areSameTypeArguments(checker, left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    if (isAnyOrUnknownType(left) || isAnyOrUnknownType(right)) {
+        return (isAnyOrUnknownType(left) &&
+            isAnyOrUnknownType(right) &&
+            checker.typeToString(left) === checker.typeToString(right));
+    }
+    const leftSymbol = getComparableDeclaredTypeSymbol(left);
+    const rightSymbol = getComparableDeclaredTypeSymbol(right);
+    if (leftSymbol || rightSymbol) {
+        // Keep named type arguments distinct from anonymous structural literals.
+        return leftSymbol !== undefined && leftSymbol === rightSymbol
+            ? areSameTypeDeclarations(checker, left, right)
+            : false;
+    }
+    // Primitives, unions, tuples, and anonymous object literals do not have a
+    // stable declared type symbol, so compare their effective instantiated form.
+    return checker.typeToString(left) === checker.typeToString(right);
+}
+function isAnyOrUnknownType(type) {
+    return (type.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown)) !== 0;
+}
+/**
+ * Returns the symbol to use for declaration-based comparisons.
+ *
+ * Anonymous type literals such as `{ id: string }` are intentionally excluded:
+ * their `TypeLiteral` symbols do not represent stable declaration identities.
+ * Named interfaces and type aliases are still kept because we prefer
+ * `aliasSymbol` over the underlying `TypeLiteral` symbol.
+ */
+function getComparableDeclaredTypeSymbol(type) {
+    const symbol = type.aliasSymbol ?? type.symbol;
+    return symbol && (symbol.flags & typescript_1.default.SymbolFlags.TypeLiteral) === 0 ? symbol : undefined;
+}
+function getDeclaredTypeArguments(type, checker) {
+    if (type.aliasTypeArguments?.length) {
+        return type.aliasTypeArguments;
+    }
+    return isTypeReference(type) ? checker.getTypeArguments(type) : [];
+}
+function isTypeReference(type) {
+    return ((type.flags & typescript_1.default.TypeFlags.Object) !== 0 &&
+        (type.objectFlags & typescript_1.default.ObjectFlags.Reference) !== 0);
+}
 /**
  * Checks if a node has a generic type like:
  *
@@ -192,18 +318,30 @@ function isGenericType(node, services) {
     const type = getTypeFromTreeNode(node, services);
     return type.isTypeParameter();
 }
+/**
+ * Returns the TypeScript type resolved at `node`.
+ */
 function getTypeFromTreeNode(node, services) {
     const checker = services.program.getTypeChecker();
     return checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
 }
+/**
+ * Returns the widened string representation of the type resolved at `node`.
+ */
 function getTypeAsString(node, services) {
     const { typeToString, getBaseTypeOfLiteralType } = services.program.getTypeChecker();
     return typeToString(getBaseTypeOfLiteralType(getTypeFromTreeNode(node, services)));
 }
+/**
+ * Returns the symbol resolved at `node`, if any.
+ */
 function getSymbolAtLocation(node, services) {
     const checker = services.program.getTypeChecker();
     return checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(node));
 }
+/**
+ * Returns the resolved call signature for the call-like expression at `node`.
+ */
 function getSignatureFromCallee(node, services) {
     const checker = services.program.getTypeChecker();
     return checker.getResolvedSignature(services.esTreeNodeToTSNodeMap.get(node));
@@ -251,6 +389,14 @@ function isNumberArray(type, services) {
 function isBigIntArray(type, services) {
     return isArrayElementTypeMatching(type, services, isBigIntType);
 }
+/**
+ * Test if the provided type is an array of booleans.
+ * @param type A TypeScript type.
+ * @param services The services used to get access to the TypeScript type checker
+ */
+function isBooleanArray(type, services) {
+    return isArrayElementTypeMatching(type, services, isBooleanType);
+}
 function isArrayElementTypeMatching(type, services, predicate) {
     const checker = services.program.getTypeChecker();
     if (!isArrayType(type, services)) {
@@ -284,18 +430,33 @@ function isTypeAlias(node, context) {
 function isBooleanLiteralType(type) {
     return type.flags === typescript_1.default.TypeFlags.BooleanLiteral;
 }
+/**
+ * Returns true when `type` is the boolean literal `true`.
+ */
 function isBooleanTrueType(type) {
     return isBooleanLiteralType(type) && type.intrinsicName === 'true';
 }
+/**
+ * Returns true when `type` is boolean-like.
+ */
 function isBooleanType({ flags }) {
-    return flags & typescript_1.default.TypeFlags.BooleanLike;
+    return (flags & typescript_1.default.TypeFlags.BooleanLike) !== 0;
 }
+/**
+ * Returns true when `type` is `null`, `undefined`, or a union containing either.
+ */
 function isNullOrUndefinedType({ flags }) {
     return flags & typescript_1.default.TypeFlags.Null || flags & typescript_1.default.TypeFlags.Undefined;
 }
+/**
+ * Returns true when `type` is object-like.
+ */
 function isObjectType({ flags }) {
     return flags & typescript_1.default.TypeFlags.Object;
 }
+/**
+ * Returns true when `node` exposes a callable member named `methodName`.
+ */
 function typeHasMethod(node, methodName, services) {
     const type = getTypeFromTreeNode(node, services);
     const property = type.getProperty(methodName);

package/cjs/helpers/vitest.js

@@ -3,15 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImported = isImported;
 exports.isAssertion = isAssertion;
 exports.isTSAssertion = isTSAssertion;
 const module_js_1 = require("./module.js");
 const module_ts_js_1 = require("./module-ts.js");
 const typescript_1 = __importDefault(require("typescript"));
-function isImported(context) {
-    return ((0, module_js_1.getRequireCalls)(context).some(r => r.arguments[0].type === 'Literal' && r.arguments[0].value === 'vitest') || (0, module_js_1.getImportDeclarations)(context).some(i => i.source.value === 'vitest'));
-}
 function isAssertion(context, node) {
     const fullyQualifiedName = extractFQNforCallExpression(context, node);
     return isFQNAssertion(fullyQualifiedName);