Add no-boolean-literal-compare rule

docs/_data/rules.json

@@ -582,7 +582,7 @@
     "typescriptOnly": false
   },
   {
-    "ruleName": "no-boolean-compare",
+    "ruleName": "no-boolean-literal-compare",
     "description": "Warns on comparison to a boolean literal, as in `x === true`.",
     "hasFix": true,
     "optionsDescription": "Not configurable.",
@@ -591,7 +591,8 @@
       "true"
     ],
     "type": "style",
-    "typescriptOnly": true
+    "typescriptOnly": true,
+    "requiresTypeInfo": true
   },
   {
     "ruleName": "no-conditional-assignment",

docs/rules/no-boolean-literal-compare/index.html

@@ -0,0 +1,15 @@
+---
+ruleName: no-boolean-literal-compare
+description: 'Warns on comparison to a boolean literal, as in `x === true`.'
+hasFix: true
+optionsDescription: Not configurable.
+options: null
+optionExamples:
+  - 'true'
+type: style
+typescriptOnly: true
+requiresTypeInfo: true
+layout: rule
+title: 'Rule: no-boolean-literal-compare'
+optionsJSON: 'null'
+---

src/language/rule/rule.ts

@@ -111,10 +111,6 @@ export class Replacement {
         return replacements.reduce((text, r) => r.apply(text), content);
     }
 
-    public static deleteFromTo(start: number, end: number): Replacement {
-        return new Replacement(start, end - start, "");
-    }
-
     constructor(private innerStart: number, private innerLength: number, private innerText: string) {
     }
 

src/language/walker/ruleWalker.ts

@@ -105,6 +105,10 @@ export class RuleWalker extends SyntaxWalker implements IWalker {
         return this.createReplacement(start, length, "");
     }
 
+    public deleteFromTo(start: number, end: number): Replacement {
+        return this.createReplacement(start, end - start, "");
+    }
+
     public getRuleName(): string {
         return this.ruleName;
     }

src/rules/noBooleanCompareRule.ts → src/rules/noBooleanLiteralCompareRule.ts

@@ -22,7 +22,7 @@ import * as Lint from "../index";
 export class Rule extends Lint.Rules.TypedRule {
     /* tslint:disable:object-literal-sort-keys */
     public static metadata: Lint.IRuleMetadata = {
-        ruleName: "no-boolean-compare",
+        ruleName: "no-boolean-literal-compare",
         description: "Warns on comparison to a boolean literal, as in `x === true`.",
         hasFix: true,
         optionsDescription: "Not configurable.",
@@ -62,17 +62,32 @@ class Walker extends Lint.ProgramAwareRuleWalker {
         }
 
         const deleted = node.left === expression
-            ? Lint.Replacement.deleteFromTo(node.left.end, node.end)
-            : Lint.Replacement.deleteFromTo(node.getStart(), node.right.getStart());
+            ? this.deleteFromTo(node.left.end, node.end)
+            : this.deleteFromTo(node.getStart(), node.right.getStart());
         const replacements = [deleted];
         if (negate) {
-            replacements.push(this.appendText(node.getStart(), "!"));
+            if (needsParenthesesForNegate(expression)) {
+                replacements.push(this.appendText(node.getStart(), "!("));
+                replacements.push(this.appendText(node.getEnd(), ")"));
+            } else {
+                replacements.push(this.appendText(node.getStart(), "!"));
+            }
         }
 
         this.addFailureAtNode(expression, Rule.FAILURE_STRING(negate), this.createFix(...replacements));
     }
 }
 
+function needsParenthesesForNegate(node: ts.Expression) {
+    switch (node.kind) {
+        case ts.SyntaxKind.AsExpression:
+        case ts.SyntaxKind.BinaryExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+
 function deconstructComparison(node: ts.BinaryExpression): { negate: boolean, expression: ts.Expression } | undefined {
     const { left, operatorToken, right } = node;
     const operator = operatorKind(operatorToken);
@@ -93,9 +108,11 @@ function deconstructComparison(node: ts.BinaryExpression): { negate: boolean, ex
 
 function operatorKind(operatorToken: ts.BinaryOperatorToken): boolean | undefined {
     switch (operatorToken.kind) {
-        case ts.SyntaxKind.EqualsEqualsToken: case ts.SyntaxKind.EqualsEqualsEqualsToken:
+        case ts.SyntaxKind.EqualsEqualsToken:
+        case ts.SyntaxKind.EqualsEqualsEqualsToken:
             return true;
-        case ts.SyntaxKind.ExclamationEqualsToken: case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+        case ts.SyntaxKind.ExclamationEqualsToken:
+        case ts.SyntaxKind.ExclamationEqualsEqualsToken:
             return false;
         default:
             return undefined;

test/rules/no-boolean-literal-compare/test.ts.fix

@@ -0,0 +1,30 @@
+declare const x: boolean;
+
+x;
+x;
+
+!x;
+!x;
+
+!x;
+!x;
+
+x;
+x;
+
+x;
+
+declare const y: boolean | undefined;
+y === true;
+
+declare function f(): boolean;
+!f();
+
+declare const a: number, b: number;
+
+!(a as any as boolean);
+
+!(a < b);
+
+!!x;
+

test/rules/no-boolean-compare/test.ts.lint → test/rules/no-boolean-literal-compare/test.ts.lint

@@ -26,5 +26,20 @@ x == true;
 declare const y: boolean | undefined;
 y === true;
 
+declare function f(): boolean;
+f() === false;
+~~~ [F]
+
+declare const a: number, b: number;
+
+a as any as boolean === false;
+~~~~~~~~~~~~~~~~~~~ [F]
+
+a < b === false;
+~~~~~ [F]
+
+!x === false;
+~~ [F]
+
 [T]: This expression is unnecessarily compared to a boolean. Just use it directly.
 [F]: This expression is unnecessarily compared to a boolean. Just negate it.

test/rules/no-boolean-compare/tslint.json → test/rules/no-boolean-literal-compare/tslint.json

@@ -3,6 +3,6 @@
         "typeCheck": true
     },
     "rules": {
-        "no-boolean-compare": true
+        "no-boolean-literal-compare": true
     }
 }