no-identical-expressions: provide secondary issue locations (#102)

Author: andrea-guarino-sonarsource

src/rules/no-identical-expressions.ts

@@ -23,12 +23,16 @@ import { Rule } from "eslint";
 import { Node, BinaryExpression, LogicalExpression } from "estree";
 import { isIdentifier, isLiteral } from "../utils/nodes";
 import { areEquivalent } from "../utils/equivalence";
+import { report, issueLocation, IssueLocation } from "../utils/locations";
 
 const EQUALITY_OPERATOR_TOKEN_KINDS = new Set(["==", "===", "!=", "!=="]);
 
 // consider only binary expressions with these operators
 const RELEVANT_OPERATOR_TOKEN_KINDS = new Set(["&&", "||", "/", "-", "<<", ">>", "<", "<=", ">", ">="]);
 
+const message = (operator: string) =>
+  `Correct one of the identical sub-expressions on both sides of operator "${operator}"`;
+
 function hasRelevantOperator(node: BinaryExpression | LogicalExpression) {
   return (
     RELEVANT_OPERATOR_TOKEN_KINDS.has(node.operator) ||
@@ -45,6 +49,14 @@ function isOneOntoOneShifting(node: BinaryExpression | LogicalExpression) {
 }
 
 const rule: Rule.RuleModule = {
+  meta: {
+    schema: [
+      {
+        // internal parameter
+        enum: ["sonar-runtime"],
+      },
+    ],
+  },
   create(context: Rule.RuleContext) {
     return {
       LogicalExpression(node: Node) {
@@ -61,13 +73,24 @@ const rule: Rule.RuleModule = {
         !isOneOntoOneShifting(expr) &&
         areEquivalent(expr.left, expr.right, context.getSourceCode())
       ) {
-        context.report({
-          message: `Correct one of the identical sub-expressions on both sides of operator "{{operator}}"`,
-          data: { operator: expr.operator },
-          node: expr,
-        });
+        const secondaryLocations: IssueLocation[] = [];
+        if (expr.left.loc) {
+          secondaryLocations.push(issueLocation(expr.left.loc));
+        }
+        report(
+          context,
+          {
+            message: message(expr.operator),
+            node: isSonarRuntime() ? expr.right : expr,
+          },
+          secondaryLocations,
+        );
       }
     }
+
+    function isSonarRuntime() {
+      return context.options[context.options.length - 1] === "sonar-runtime";
+    }
   },
 };
 

tests/rules/no-identical-expressions.test.ts

@@ -60,6 +60,31 @@ ruleTester.run("no-identical-expressions", rule, {
       code: "a == b || a == b",
       errors: 1,
     },
+    {
+      code: `a == b || a == b
+      //     ^^^^^^>   ^^^^^^`,
+      options: ["sonar-runtime"],
+      errors: [
+        {
+          message: JSON.stringify({
+            secondaryLocations: [
+              {
+                line: 1,
+                column: 0,
+                endLine: 1,
+                endColumn: 6,
+                message: "",
+              },
+            ],
+            message: `Correct one of the identical sub-expressions on both sides of operator "||"`,
+          }),
+          line: 1,
+          endLine: 1,
+          column: 11,
+          endColumn: 17,
+        },
+      ],
+    },
     {
       code: "a > a",
       errors: 1,