Deactivate 'no-inverted-boolean' and replace fix with suggestion (#322)

* Deactivate 'no-inverted-boolean' and replace fix with suggestion

* Fix formatting

* Update README

Co-authored-by: yassin-kammoun-sonarsource <[email protected]>

Author: vilchik-elena

README.md

@@ -32,7 +32,7 @@ Code Smells, or maintainability issues, are raised for places of code which migh
 * Two branches in a conditional structure should not have exactly the same implementation ([`no-duplicated-branches`])
 * Boolean expressions should not be gratuitous ([`no-gratuitous-expressions`])
 * Functions should not have identical implementations ([`no-identical-functions`])
-* Boolean checks should not be inverted ([`no-inverted-boolean-check`]) (:wrench: *fixable*)
+* Boolean checks should not be inverted ([`no-inverted-boolean-check`]) (:wrench: *fixable*, *disabled*)
 * "switch" statements should not be nested ([`no-nested-switch`])
 * Template literals should not be nested ([`no-nested-template-literals`])
 * Boolean literals should not be redundant ([`no-redundant-boolean`])

package-lock.json

@@ -38,14 +38,16 @@ const rule: TSESLint.RuleModule<string, string[]> = {
   meta: {
     messages: {
       useOppositeOperator: 'Use the opposite operator ({{invertedOperator}}) instead.',
+      suggestOperationInversion: 'Invert inner operation (apply if NaN is not expected)',
     },
     schema: [],
     type: 'suggestion',
     docs: {
       description: 'Boolean checks should not be inverted',
-      recommended: 'error',
+      recommended: false,
       url: docsUrl(__filename),
     },
+    hasSuggestions: true,
     fixable: 'code',
   },
   create(context) {
@@ -70,10 +72,18 @@ function visitUnaryExpression(
         unaryExpression.parent?.type === 'UnaryExpression' ? ['(', ')'] : ['', ''];
       context.report({
         messageId: 'useOppositeOperator',
+        suggest: [
+          {
+            messageId: 'suggestOperationInversion',
+            fix: fixer =>
+              fixer.replaceText(
+                unaryExpression,
+                `${start}${left} ${invertedOperator} ${right}${end}`,
+              ),
+          },
+        ],
         data: { invertedOperator },
         node: unaryExpression,
-        fix: fixer =>
-          fixer.replaceText(unaryExpression, `${start}${left} ${invertedOperator} ${right}${end}`),
       });
     }
   }

src/rules/no-inverted-boolean-check.ts

@@ -45,82 +45,79 @@ ruleTester.run('no-inverted-boolean-check', rule, {
       code: `if (!(x == 1)) {}`,
       errors: [
         {
-          ...message('!='),
+          ...error('!=', `if (x != 1) {}`),
           line: 1,
           endLine: 1,
           column: 5,
           endColumn: 14,
         },
       ],
-      output: `if (x != 1) {}`,
     },
     // `!=` => `==`
     {
       code: `if (!(x != 1)) {}`,
-      errors: [message('==')],
-      output: `if (x == 1) {}`,
+      errors: [error('==', `if (x == 1) {}`)],
     },
     // `===` => `!==`
     {
       code: `if (!(x === 1)) {}`,
-      errors: [message('!==')],
-      output: `if (x !== 1) {}`,
+      errors: [error('!==', `if (x !== 1) {}`)],
     },
     // `!==` => `===`
     {
       code: `if (!(x !== 1)) {}`,
-      errors: [message('===')],
-      output: `if (x === 1) {}`,
+      errors: [error('===', `if (x === 1) {}`)],
     },
     // `>` => `<=`
     {
       code: `if (!(x > 1)) {}`,
-      errors: [message('<=')],
-      output: `if (x <= 1) {}`,
+      errors: [error('<=', `if (x <= 1) {}`)],
     },
     // `<` => `>=`
     {
       code: `if (!(x < 1)) {}`,
-      errors: [message('>=')],
-      output: `if (x >= 1) {}`,
+      errors: [error('>=', `if (x >= 1) {}`)],
     },
     // `>=` => `<`
     {
       code: `if (!(x >= 1)) {}`,
-      errors: [message('<')],
-      output: `if (x < 1) {}`,
+      errors: [error('<', `if (x < 1) {}`)],
     },
     // `<=` => `>`
     {
       code: `if (!(x <= 1)) {}`,
-      errors: [message('>')],
-      output: `if (x > 1) {}`,
+      errors: [error('>', `if (x > 1) {}`)],
     },
     // ternary operator
     {
       code: `!(x != 1) ? 1 : 2`,
-      errors: [message('==')],
-      output: `x == 1 ? 1 : 2`,
+      errors: [error('==', `x == 1 ? 1 : 2`)],
     },
     // not conditional
     {
       code: `foo(!(x === 1))`,
-      errors: [message('!==')],
-      output: `foo(x !== 1)`,
+      errors: [error('!==', `foo(x !== 1)`)],
     },
     {
       code: `let foo = !(x <= 4)`,
-      errors: [message('>')],
-      output: `let foo = x > 4`,
+      errors: [error('>', `let foo = x > 4`)],
     },
     {
       code: `let foo = !!(a < b)`,
-      errors: [message('>=')],
-      output: 'let foo = !(a >= b)',
+      errors: [error('>=', 'let foo = !(a >= b)')],
     },
   ],
 });
 
-function message(invertedOperator: string): TSESLint.TestCaseError<string> {
-  return { messageId: 'useOppositeOperator', data: { invertedOperator } };
+function error(invertedOperator: string, output: string): TSESLint.TestCaseError<string> {
+  return {
+    messageId: 'useOppositeOperator',
+    data: { invertedOperator },
+    suggestions: [
+      {
+        messageId: 'suggestOperationInversion',
+        output,
+      },
+    ],
+  };
 }