eslint-plugin-sonarjs 4.0.0 → 4.0.2

package/cjs/S3757/rule.js

@@ -55,19 +55,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
 const meta = __importStar(require("./generated-meta.js"));
 const BINARY_OPERATORS = new Set(['/', '*', '%', '-', '-=', '*=', '/=', '%=']);
 const UNARY_OPERATORS = new Set(['++', '--', '+', '-']);
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             noEvaluatedNaN: 'Change the expression which uses this operand so that it can\'t evaluate to "NaN" (Not a Number).',
         },
     }),
     create(context) {
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         function isObjectType(...types) {
@@ -83,8 +85,8 @@ exports.rule = {
                 if (!BINARY_OPERATORS.has(expression.operator)) {
                     return;
                 }
-                const leftType = (0, index_js_1.getTypeFromTreeNode)(expression.left, services);
-                const rightType = (0, index_js_1.getTypeFromTreeNode)(expression.right, services);
+                const leftType = (0, type_js_1.getTypeFromTreeNode)(expression.left, services);
+                const rightType = (0, type_js_1.getTypeFromTreeNode)(expression.right, services);
                 if (isObjectType(leftType)) {
                     context.report({ node: expression.left, messageId: 'noEvaluatedNaN' });
                 }
@@ -97,7 +99,7 @@ exports.rule = {
                 if (!UNARY_OPERATORS.has(expr.operator)) {
                     return;
                 }
-                const argType = (0, index_js_1.getTypeFromTreeNode)(expr.argument, services);
+                const argType = (0, type_js_1.getTypeFromTreeNode)(expr.argument, services);
                 if (isObjectType(argType)) {
                     context.report({ node, messageId: 'noEvaluatedNaN' });
                 }

package/cjs/S3758/rule.js

@@ -55,18 +55,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const index_js_1 = require("../helpers/index.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
 const meta = __importStar(require("./generated-meta.js"));
 const comparisonOperators = new Set(['>', '<', '>=', '<=']);
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             reEvaluateDataFlow: 'Re-evaluate the data flow; this operand of a numeric comparison could be of type {{type}}.',
         },
     }),
     create(context) {
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         return {
@@ -80,9 +82,9 @@ exports.rule = {
                     return;
                 }
                 const checker = services.program.getTypeChecker();
-                const leftType = (0, index_js_1.getTypeFromTreeNode)(left, services);
-                const rightType = (0, index_js_1.getTypeFromTreeNode)(right, services);
-                if ((0, index_js_1.isStringType)(leftType) || (0, index_js_1.isStringType)(rightType)) {
+                const leftType = (0, type_js_1.getTypeFromTreeNode)(left, services);
+                const rightType = (0, type_js_1.getTypeFromTreeNode)(right, services);
+                if ((0, type_js_1.isStringType)(leftType) || (0, type_js_1.isStringType)(rightType)) {
                     return;
                 }
                 const isLeftConvertibleToNumber = isConvertibleToNumber(leftType, checker);
@@ -121,7 +123,7 @@ function isConvertibleToNumber(typ, checker) {
     return (valueOfSignatures.length === 0 ||
         valueOfSignatures.some(signature => {
             const returnType = signature.getReturnType();
-            return (0, index_js_1.isNumberType)(returnType) || (0, index_js_1.isBigIntType)(returnType);
+            return (0, type_js_1.isNumberType)(returnType) || (0, type_js_1.isBigIntType)(returnType);
         }));
 }
 function getValueOfSignatures(typ, checker) {

package/cjs/S3760/rule.js

@@ -55,22 +55,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const index_js_1 = require("../helpers/index.js");
+const location_js_1 = require("../helpers/location.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
 const meta = __importStar(require("./generated-meta.js"));
 const MESSAGE = 'Convert this operand into a number.';
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         return {
             BinaryExpression: (node) => {
                 const binaryExpression = node;
                 const operator = binaryExpression.operator;
-                const leftType = (0, index_js_1.getTypeFromTreeNode)(binaryExpression.left, services);
-                const rightType = (0, index_js_1.getTypeFromTreeNode)(binaryExpression.right, services);
+                const leftType = (0, type_js_1.getTypeFromTreeNode)(binaryExpression.left, services);
+                const rightType = (0, type_js_1.getTypeFromTreeNode)(binaryExpression.right, services);
                 if (operator === '+') {
                     checkPlus(leftType, rightType, binaryExpression, context);
                 }
@@ -84,8 +87,8 @@ exports.rule = {
             AssignmentExpression: (node) => {
                 const assignmentExpression = node;
                 const operator = assignmentExpression.operator;
-                const leftType = (0, index_js_1.getTypeFromTreeNode)(assignmentExpression.left, services);
-                const rightType = (0, index_js_1.getTypeFromTreeNode)(assignmentExpression.right, services);
+                const leftType = (0, type_js_1.getTypeFromTreeNode)(assignmentExpression.left, services);
+                const rightType = (0, type_js_1.getTypeFromTreeNode)(assignmentExpression.right, services);
                 if (operator === '+=') {
                     checkPlus(leftType, rightType, assignmentExpression, context);
                 }
@@ -95,9 +98,9 @@ exports.rule = {
             },
             'UnaryExpression[operator="-"]': (node) => {
                 const unaryExpression = node;
-                const type = (0, index_js_1.getTypeFromTreeNode)(unaryExpression.argument, services);
+                const type = (0, type_js_1.getTypeFromTreeNode)(unaryExpression.argument, services);
                 if (isBooleanStringOrDate(type)) {
-                    (0, index_js_1.report)(context, {
+                    (0, location_js_1.report)(context, {
                         node: unaryExpression.argument,
                         message: MESSAGE,
                     });
@@ -105,9 +108,9 @@ exports.rule = {
             },
             UpdateExpression: (node) => {
                 const updateExpression = node;
-                const type = (0, index_js_1.getTypeFromTreeNode)(updateExpression.argument, services);
+                const type = (0, type_js_1.getTypeFromTreeNode)(updateExpression.argument, services);
                 if (isBooleanStringOrDate(type)) {
-                    (0, index_js_1.report)(context, {
+                    (0, location_js_1.report)(context, {
                         node: updateExpression.argument,
                         message: MESSAGE,
                     });
@@ -131,27 +134,27 @@ function isDateMinusDateException(leftType, rightType, operator) {
 }
 function checkPlus(leftType, rightType, expression, context) {
     if (isNumber(leftType) && isBooleanOrDate(rightType)) {
-        (0, index_js_1.report)(context, {
+        (0, location_js_1.report)(context, {
             node: expression.right,
             message: MESSAGE,
-        }, [(0, index_js_1.toSecondaryLocation)(expression.left)]);
+        }, [(0, location_js_1.toSecondaryLocation)(expression.left)]);
     }
     if (isNumber(rightType) && isBooleanOrDate(leftType)) {
-        (0, index_js_1.report)(context, {
+        (0, location_js_1.report)(context, {
             node: expression.left,
             message: MESSAGE,
-        }, [(0, index_js_1.toSecondaryLocation)(expression.right)]);
+        }, [(0, location_js_1.toSecondaryLocation)(expression.right)]);
     }
 }
 function checkComparison(leftType, rightType, expression, context) {
     if (isBooleanOrNumber(leftType) && isBooleanStringOrDate(rightType)) {
-        (0, index_js_1.report)(context, {
+        (0, location_js_1.report)(context, {
             node: expression.right,
             message: MESSAGE,
         });
     }
     else if (isBooleanOrNumber(rightType) && isBooleanStringOrDate(leftType)) {
-        (0, index_js_1.report)(context, {
+        (0, location_js_1.report)(context, {
             node: expression.left,
             message: MESSAGE,
         });
@@ -163,13 +166,13 @@ function checkArithmetic(leftType, rightType, expression, context) {
     }
     const secondaryLocations = [];
     if (isBooleanStringOrDate(leftType)) {
-        secondaryLocations.push((0, index_js_1.toSecondaryLocation)(expression.left));
+        secondaryLocations.push((0, location_js_1.toSecondaryLocation)(expression.left));
     }
     if (isBooleanStringOrDate(rightType)) {
-        secondaryLocations.push((0, index_js_1.toSecondaryLocation)(expression.right));
+        secondaryLocations.push((0, location_js_1.toSecondaryLocation)(expression.right));
     }
     if (secondaryLocations.length !== 0) {
-        (0, index_js_1.report)(context, {
+        (0, location_js_1.report)(context, {
             node: expression,
             message: 'Convert the operands of this operation into numbers.',
         }, secondaryLocations);
@@ -191,5 +194,5 @@ function isNumber(type) {
     return (type.flags & typescript_1.default.TypeFlags.NumberLike) > 0 || type.symbol?.name === 'Number';
 }
 function isBooleanStringOrDate(type) {
-    return isBoolean(type) || (0, index_js_1.isStringType)(type) || type.symbol?.name === 'Date';
+    return isBoolean(type) || (0, type_js_1.isStringType)(type) || type.symbol?.name === 'Date';
 }

package/cjs/S3776/rule.js

@@ -51,12 +51,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const location_js_1 = require("../helpers/location.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const jsx_js_1 = require("../helpers/jsx.js");
+const ast_js_1 = require("../helpers/ast.js");
+const collection_js_1 = require("../helpers/collection.js");
 const meta = __importStar(require("./generated-meta.js"));
 const DEFAULT_THRESHOLD = 15;
 const message = 'Refactor this function to reduce its Cognitive Complexity from {{complexityAmount}} to the {{threshold}} allowed.';
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             refactorFunction: message,
             fileComplexity: '{{complexityAmount}}',
@@ -227,19 +231,19 @@ exports.rule = {
                     parent: node.parent,
                     complexityIfNested,
                     complexityIfThisSecondaryIsTopLevel: complexityIfNotNested,
-                    loc: (0, index_js_1.getMainFunctionTokenLocation)(node, node.parent, context),
+                    loc: (0, location_js_1.getMainFunctionTokenLocation)(node, node.parent, context),
                 });
             }
             if (isFileComplexity) {
                 return;
             }
-            checkFunction(functionComplexity, (0, index_js_1.getMainFunctionTokenLocation)(node, node.parent, context));
+            checkFunction(functionComplexity, (0, location_js_1.getMainFunctionTokenLocation)(node, node.parent, context));
         }
         function visitIfStatement(ifStatement) {
             const { parent } = ifStatement;
-            const { loc: ifLoc } = (0, index_js_1.getFirstToken)(ifStatement, context);
+            const { loc: ifLoc } = (0, location_js_1.getFirstToken)(ifStatement, context);
             // if the current `if` statement is `else if`, do not count it in structural complexity
-            if ((0, index_js_1.isIfStatement)(parent) && parent.alternate === ifStatement) {
+            if ((0, ast_js_1.isIfStatement)(parent) && parent.alternate === ifStatement) {
                 addComplexity(ifLoc);
             }
             else {
@@ -250,33 +254,33 @@ exports.rule = {
             // if `else` branch is not `else if` then
             // - increase nesting level inside `else` statement
             // - add +1 complexity
-            if (ifStatement.alternate && !(0, index_js_1.isIfStatement)(ifStatement.alternate)) {
+            if (ifStatement.alternate && !(0, ast_js_1.isIfStatement)(ifStatement.alternate)) {
                 nestingNodes.add(ifStatement.alternate);
-                const elseTokenLoc = (0, index_js_1.getFirstTokenAfter)(ifStatement.consequent, context).loc;
+                const elseTokenLoc = (0, location_js_1.getFirstTokenAfter)(ifStatement.consequent, context).loc;
                 addComplexity(elseTokenLoc);
             }
         }
         function visitLoop(loop) {
-            addStructuralComplexity((0, index_js_1.getFirstToken)(loop, context).loc);
+            addStructuralComplexity((0, location_js_1.getFirstToken)(loop, context).loc);
             nestingNodes.add(loop.body);
         }
         function visitSwitchStatement(switchStatement) {
-            addStructuralComplexity((0, index_js_1.getFirstToken)(switchStatement, context).loc);
+            addStructuralComplexity((0, location_js_1.getFirstToken)(switchStatement, context).loc);
             for (const switchCase of switchStatement.cases) {
                 nestingNodes.add(switchCase);
             }
         }
         function visitContinueOrBreakStatement(statement) {
             if (statement.label) {
-                addComplexity((0, index_js_1.getFirstToken)(statement, context).loc);
+                addComplexity((0, location_js_1.getFirstToken)(statement, context).loc);
             }
         }
         function visitCatchClause(catchClause) {
-            addStructuralComplexity((0, index_js_1.getFirstToken)(catchClause, context).loc);
+            addStructuralComplexity((0, location_js_1.getFirstToken)(catchClause, context).loc);
             nestingNodes.add(catchClause.body);
         }
         function visitConditionalExpression(conditionalExpression) {
-            const questionTokenLoc = (0, index_js_1.getFirstTokenAfter)(conditionalExpression.test, context).loc;
+            const questionTokenLoc = (0, location_js_1.getFirstTokenAfter)(conditionalExpression.test, context).loc;
             addStructuralComplexity(questionTokenLoc);
             nestingNodes.add(conditionalExpression.consequent);
             nestingNodes.add(conditionalExpression.alternate);
@@ -294,7 +298,7 @@ exports.rule = {
                 const firstLetter = name[0];
                 return firstLetter === firstLetter.toUpperCase();
             };
-            if (!(0, index_js_1.isArrowFunctionExpression)(node) && node.id) {
+            if (!(0, ast_js_1.isArrowFunctionExpression)(node) && node.id) {
                 return checkFirstLetter(node.id.name);
             }
             const { parent } = node;
@@ -304,7 +308,7 @@ exports.rule = {
             return false;
         }
         function visitLogicalExpression(logicalExpression) {
-            const jsxShortCircuitNodes = (0, index_js_1.getJsxShortCircuitNodes)(logicalExpression);
+            const jsxShortCircuitNodes = (0, jsx_js_1.getJsxShortCircuitNodes)(logicalExpression);
             if (jsxShortCircuitNodes != null) {
                 for (const node of jsxShortCircuitNodes) {
                     consideredLogicalExpressions.add(node);
@@ -318,7 +322,7 @@ exports.rule = {
                     if (current.operator !== '||' &&
                         current.operator !== '??' &&
                         (!previous || previous.operator !== current.operator)) {
-                        const operatorTokenLoc = (0, index_js_1.getFirstTokenAfter)(current.left, context).loc;
+                        const operatorTokenLoc = (0, location_js_1.getFirstTokenAfter)(current.left, context).loc;
                         addComplexity(operatorTokenLoc);
                     }
                     previous = current;
@@ -326,7 +330,7 @@ exports.rule = {
             }
         }
         function flattenLogicalExpression(node) {
-            if ((0, index_js_1.isLogicalExpression)(node)) {
+            if ((0, ast_js_1.isLogicalExpression)(node)) {
                 consideredLogicalExpressions.add(node);
                 return [
                     ...flattenLogicalExpression(node.left),
@@ -354,8 +358,8 @@ exports.rule = {
                 complexityIfNotNested.push(complexityPoint);
             }
             if (functionOwnComplexity.length > 0) {
-                const addedWithoutFunctionNesting = (0, index_js_1.last)(functionOwnControlFlowNesting) + 1;
-                (0, index_js_1.last)(functionOwnComplexity).push({
+                const addedWithoutFunctionNesting = (0, collection_js_1.last)(functionOwnControlFlowNesting) + 1;
+                (0, collection_js_1.last)(functionOwnComplexity).push({
                     complexity: addedWithoutFunctionNesting,
                     location,
                 });
@@ -364,7 +368,7 @@ exports.rule = {
         function addComplexity(location) {
             const complexityPoint = { complexity: 1, location };
             if (functionOwnComplexity.length > 0) {
-                (0, index_js_1.last)(functionOwnComplexity).push(complexityPoint);
+                (0, collection_js_1.last)(functionOwnComplexity).push(complexityPoint);
             }
             if (enclosingFunctions.length === 0) {
                 // top level scope
@@ -386,9 +390,9 @@ exports.rule = {
                 const secondaryLocations = complexity.map(complexityPoint => {
                     const { complexity, location } = complexityPoint;
                     const message = complexity === 1 ? '+1' : `+${complexity} (incl. ${complexity - 1} for nesting)`;
-                    return (0, index_js_1.toSecondaryLocation)({ loc: location }, message);
+                    return (0, location_js_1.toSecondaryLocation)({ loc: location }, message);
                 });
-                (0, index_js_1.report)(context, {
+                (0, location_js_1.report)(context, {
                     messageId: 'refactorFunction',
                     message,
                     data: {

package/cjs/S3782/rule.js

@@ -54,14 +54,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
 const typescript_1 = __importDefault(require("typescript"));
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         const tc = services.program.getTypeChecker();
@@ -87,7 +89,7 @@ exports.rule = {
                     return null;
                 }
                 const declaredType = tc.getTypeFromTypeNode(parameterType);
-                const actualType = (0, index_js_1.getTypeFromTreeNode)(callExpression.arguments[i], services);
+                const actualType = (0, type_js_1.getTypeFromTreeNode)(callExpression.arguments[i], services);
                 if (
                 // @ts-ignore private API, see https://github.com/microsoft/TypeScript/issues/9879
                 !tc.isTypeAssignableTo(actualType, declaredType) &&

package/cjs/S3785/rule.js

@@ -55,17 +55,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
+const location_js_1 = require("../helpers/location.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         function isPrimitive(node) {
-            const type = (0, index_js_1.getTypeFromTreeNode)(node, services);
+            const type = (0, type_js_1.getTypeFromTreeNode)(node, services);
             return ((type.flags & typescript_1.default.TypeFlags.StringLike) !== 0 ||
                 (type.flags & typescript_1.default.TypeFlags.NumberLike) !== 0 ||
                 (type.flags & typescript_1.default.TypeFlags.BooleanLike) !== 0 ||
@@ -79,10 +82,10 @@ exports.rule = {
                     const opToken = context.sourceCode
                         .getTokensBetween(left, right)
                         .find(token => token.type === 'Keyword' && token.value === operator);
-                    (0, index_js_1.report)(context, {
+                    (0, location_js_1.report)(context, {
                         message: 'TypeError can be thrown as this operand might have primitive type.',
                         node: right,
-                    }, [(0, index_js_1.toSecondaryLocation)(opToken)]);
+                    }, [(0, location_js_1.toSecondaryLocation)(opToken)]);
                 }
             },
         };

package/cjs/S3796/rule.js

@@ -51,7 +51,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
+const type_js_1 = require("../helpers/type.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const location_js_1 = require("../helpers/location.js");
+const ast_js_1 = require("../helpers/ast.js");
 const meta = __importStar(require("./generated-meta.js"));
 const message = `Add a "return" statement to this callback.`;
 const methodsWithCallback = new Set([
@@ -77,10 +81,10 @@ function hasCallBackWithoutReturn(argument, services) {
         signatures.every(sig => checker.typeToString(sig.getReturnType()) === 'void'));
 }
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         return {
@@ -94,14 +98,14 @@ exports.rule = {
                     return;
                 }
                 if (methodsWithCallback.has(propName) &&
-                    ((0, index_js_1.isArray)(object, services) || (0, index_js_1.isTypedArray)(object, services)) &&
+                    ((0, type_js_1.isArray)(object, services) || (0, type_js_1.isTypedArray)(object, services)) &&
                     hasCallBackWithoutReturn(args[0], services)) {
                     context.report({
                         message,
                         ...getNodeToReport(args[0], node, context),
                     });
                 }
-                else if ((0, index_js_1.isMemberExpression)(callExpression.callee, 'Array', 'from') &&
+                else if ((0, ast_js_1.isMemberExpression)(callExpression.callee, 'Array', 'from') &&
                     args.length > 1 &&
                     hasCallBackWithoutReturn(args[1], services)) {
                     context.report({
@@ -114,10 +118,10 @@ exports.rule = {
     },
 };
 function extractPropName(memberExpression) {
-    if ((0, index_js_1.isDotNotation)(memberExpression)) {
+    if ((0, ast_js_1.isDotNotation)(memberExpression)) {
         return memberExpression.property.name;
     }
-    else if ((0, index_js_1.isIndexNotation)(memberExpression)) {
+    else if ((0, ast_js_1.isIndexNotation)(memberExpression)) {
         return memberExpression.property.value;
     }
     else {
@@ -129,7 +133,7 @@ function getNodeToReport(node, parent, context) {
         node.type === 'FunctionExpression' ||
         node.type === 'ArrowFunctionExpression') {
         return {
-            loc: (0, index_js_1.getMainFunctionTokenLocation)(node, parent, context),
+            loc: (0, location_js_1.getMainFunctionTokenLocation)(node, parent, context),
         };
     }
     return {

package/cjs/S3798/rule.js

@@ -34,10 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const ast_js_1 = require("../helpers/ast.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             defineLocally: 'Define this declaration in a local scope or bind explicitly the property to the global object.',
         },
@@ -78,5 +79,5 @@ function findModuleScope(context) {
 function isRequire(node) {
     return (node?.type === 'CallExpression' &&
         node.arguments.length === 1 &&
-        (0, index_js_1.isIdentifier)(node.callee, 'require'));
+        (0, ast_js_1.isIdentifier)(node.callee, 'require'));
 }

package/cjs/S3800/rule.js

@@ -55,7 +55,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const index_js_1 = require("../helpers/index.js");
+const type_js_1 = require("../helpers/type.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const location_js_1 = require("../helpers/location.js");
+const ancestor_js_1 = require("../helpers/ancestor.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
+const collection_js_1 = require("../helpers/collection.js");
 const meta = __importStar(require("./generated-meta.js"));
 class FunctionScope {
     constructor() {
@@ -70,14 +75,14 @@ class FunctionScope {
 }
 const isASanitationFunction = (signature) => {
     const { types } = signature.getReturnType();
-    return types.length === 2 && types.some(index_js_1.isBooleanTrueType) && types.some(index_js_1.isStringType);
+    return types.length === 2 && types.some(type_js_1.isBooleanTrueType) && types.some(type_js_1.isStringType);
 };
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         let scopes = [];
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         const checker = services.program.getTypeChecker();
@@ -91,22 +96,28 @@ exports.rule = {
                 if (isASanitationFunction(signature)) {
                     return;
                 }
-                const stmts = returnStatements.filter(retStmt => !isNullLike((0, index_js_1.getTypeFromTreeNode)(retStmt.argument, services)));
-                const stmtsTypes = stmts.map(retStmt => (0, index_js_1.getTypeFromTreeNode)(retStmt.argument, services));
-                if (stmtsTypes.every(index_js_1.isAny)) {
+                // Exclude null-like and any-typed returns; any-typed returns come from external/unknown
+                // functions whose signature is unavailable and cannot contribute to type inconsistency.
+                const stmts = returnStatements.filter(retStmt => {
+                    const type = (0, type_js_1.getTypeFromTreeNode)(retStmt.argument, services);
+                    return !isNullLike(type) && !(0, type_js_1.isAny)(type);
+                });
+                const stmtsTypes = stmts.map(retStmt => (0, type_js_1.getTypeFromTreeNode)(retStmt.argument, services));
+                const stmtCategories = stmtsTypes.map(t => prettyPrint(t, checker));
+                if (stmtCategories.filter((val, i, arr) => distinct(val, i, arr)).length <= 1) {
                     return;
                 }
-                (0, index_js_1.report)(context, {
+                (0, location_js_1.report)(context, {
                     message: 'Refactor this function to always return the same type.',
-                    loc: (0, index_js_1.getMainFunctionTokenLocation)(node, (0, index_js_1.getParent)(context, node), context),
-                }, stmts.map((stmt, i) => (0, index_js_1.toSecondaryLocation)(stmt, `Returns ${prettyPrint(stmtsTypes[i], checker)}`)));
+                    loc: (0, location_js_1.getMainFunctionTokenLocation)(node, (0, ancestor_js_1.getParent)(context, node), context),
+                }, stmts.map((stmt, i) => (0, location_js_1.toSecondaryLocation)(stmt, `Returns ${prettyPrint(stmtsTypes[i], checker)}`)));
             }
         }
         return {
             ReturnStatement: (node) => {
                 const retStmt = node;
                 if (scopes.length > 0 && retStmt.argument) {
-                    (0, index_js_1.last)(scopes).addReturnStatement(retStmt);
+                    (0, collection_js_1.last)(scopes).addReturnStatement(retStmt);
                 }
             },
             ':function': () => {

package/cjs/S3801/generated-meta.js

@@ -39,7 +39,7 @@ exports.meta = {
         description: 'Functions should use "return" consistently',
         recommended: false,
         url: 'https://sonarsource.github.io/rspec/#/rspec/S3801/javascript',
-        requiresTypeChecking: false,
+        requiresTypeChecking: true,
     },
     fixable: undefined,
     deprecated: false,