Added prefer-readonly rule with fixes (palantir#2896)

src/configs/all.ts

@@ -55,6 +55,7 @@ export const rules = {
     "no-var-requires": true,
     "only-arrow-functions": true,
     "prefer-for-of": true,
+    "prefer-readonly": true,
     "promise-function-async": true,
     "typedef": [
         true,

src/language/rule/abstractRule.ts

@@ -28,7 +28,7 @@ export abstract class AbstractRule implements IRule {
     protected readonly ruleSeverity: RuleSeverity;
     public ruleName: string;
 
-    constructor(private options: IOptions) {
+    constructor(private readonly options: IOptions) {
         this.ruleName = options.ruleName;
         this.ruleArguments = options.ruleArguments;
         this.ruleSeverity = options.ruleSeverity;

src/language/rule/rule.ts

@@ -205,7 +205,7 @@ export class Replacement {
 }
 
 export class RuleFailurePosition {
-    constructor(private position: number, private lineAndCharacter: ts.LineAndCharacter) {
+    constructor(private readonly position: number, private readonly lineAndCharacter: ts.LineAndCharacter) {
     }
 
     public getPosition() {
@@ -238,10 +238,10 @@ export type Fix = Replacement | Replacement[];
 export type FixJson = ReplacementJson | ReplacementJson[];
 
 export class RuleFailure {
-    private fileName: string;
-    private startPosition: RuleFailurePosition;
-    private endPosition: RuleFailurePosition;
-    private rawLines: string;
+    private readonly fileName: string;
+    private readonly startPosition: RuleFailurePosition;
+    private readonly endPosition: RuleFailurePosition;
+    private readonly rawLines: string;
     private ruleSeverity: RuleSeverity;
 
     public static compare(a: RuleFailure, b: RuleFailure): number {
@@ -251,12 +251,12 @@ export class RuleFailure {
         return a.startPosition.getPosition() - b.startPosition.getPosition();
     }
 
-    constructor(private sourceFile: ts.SourceFile,
+    constructor(private readonly sourceFile: ts.SourceFile,
                 start: number,
                 end: number,
-                private failure: string,
-                private ruleName: string,
-                private fix?: Fix) {
+                private readonly failure: string,
+                private readonly ruleName: string,
+                private readonly fix?: Fix) {
 
         this.fileName = sourceFile.fileName;
         this.startPosition = this.createFailurePosition(start);

src/language/typeUtils.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2017 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as ts from "typescript";
+
+export const typeIsOrHasBaseType = (type: ts.Type, parentType: ts.Type) => {
+    if (type.symbol === undefined || parentType.symbol === undefined) {
+        return false;
+    }
+
+    const typeAndBaseTypes = [type];
+    const ancestorTypes = type.getBaseTypes();
+
+    if (ancestorTypes !== undefined) {
+        typeAndBaseTypes.push(...ancestorTypes);
+    }
+
+    for (const baseType of typeAndBaseTypes) {
+        if (baseType.symbol !== undefined && baseType.symbol.name === parentType.symbol.name) {
+            return true;
+        }
+    }
+
+    return false;
+};

src/language/walker/blockScopeAwareRuleWalker.ts

@@ -28,7 +28,7 @@ import { ScopeAwareRuleWalker } from "./scopeAwareRuleWalker";
  * are a superset of regular scopes (new block scopes are created more frequently in a program).
  */
 export abstract class BlockScopeAwareRuleWalker<T, U> extends ScopeAwareRuleWalker<T> { // tslint:disable-line:deprecation
-    private blockScopeStack: U[];
+    private readonly blockScopeStack: U[];
 
     constructor(sourceFile: ts.SourceFile, options: IOptions) {
         super(sourceFile, options);

src/language/walker/programAwareRuleWalker.ts

@@ -21,9 +21,9 @@ import { IOptions } from "../rule/rule";
 import { RuleWalker } from "./ruleWalker";
 
 export class ProgramAwareRuleWalker extends RuleWalker {
-    private typeChecker: ts.TypeChecker;
+    private readonly typeChecker: ts.TypeChecker;
 
-    constructor(sourceFile: ts.SourceFile, options: IOptions, private program: ts.Program) {
+    constructor(sourceFile: ts.SourceFile, options: IOptions, private readonly program: ts.Program) {
         super(sourceFile, options);
 
         this.typeChecker = program.getTypeChecker();

src/language/walker/ruleWalker.ts

@@ -22,12 +22,12 @@ import { SyntaxWalker } from "./syntaxWalker";
 import { IWalker } from "./walker";
 
 export class RuleWalker extends SyntaxWalker implements IWalker {
-    private limit: number;
-    private options?: any[];
-    private failures: RuleFailure[];
-    private ruleName: string;
+    private readonly limit: number;
+    private readonly options?: any[];
+    private readonly failures: RuleFailure[];
+    private readonly ruleName: string;
 
-    constructor(private sourceFile: ts.SourceFile, options: IOptions) {
+    constructor(private readonly sourceFile: ts.SourceFile, options: IOptions) {
         super();
 
         this.failures = [];

src/language/walker/scopeAwareRuleWalker.ts

@@ -56,7 +56,7 @@ import { RuleWalker } from "./ruleWalker";
  * }
  */
 export abstract class ScopeAwareRuleWalker<T> extends RuleWalker {
-    private scopeStack: T[];
+    private readonly scopeStack: T[];
 
     constructor(sourceFile: ts.SourceFile, options: IOptions) {
         super(sourceFile, options);

src/linter.ts

@@ -103,7 +103,7 @@ class Linter {
         );
     }
 
-    constructor(private options: ILinterOptions, private program?: ts.Program) {
+    constructor(private readonly options: ILinterOptions, private program?: ts.Program) {
         if (typeof options !== "object") {
             throw new Error(`Unknown Linter options type: ${typeof options}`);
         }

src/rules/noInferredEmptyObjectTypeRule.ts

@@ -42,7 +42,7 @@ export class Rule extends Lint.Rules.TypedRule {
 }
 
 class NoInferredEmptyObjectTypeRule extends Lint.AbstractWalker<void> {
-    constructor(sourceFile: ts.SourceFile, ruleName: string, private checker: ts.TypeChecker) {
+    constructor(sourceFile: ts.SourceFile, ruleName: string, private readonly checker: ts.TypeChecker) {
         super(sourceFile, ruleName, undefined);
     }
 

src/rules/noThisAssignmentRule.ts

@@ -108,7 +108,7 @@ class NoThisAssignmentWalker extends Lint.AbstractWalker<Options> {
         ts.forEachChild(sourceFile, this.visitNode);
     }
 
-    private visitNode = (node: ts.Node): void => {
+    private readonly visitNode = (node: ts.Node): void => {
         if (utils.isVariableDeclaration(node)) {
             this.visitVariableDeclaration(node);
         }

src/rules/noUnsafeAnyRule.ts

@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.TypedRule {
 }
 
 class NoUnsafeAnyWalker extends Lint.AbstractWalker<void> {
-    constructor(sourceFile: ts.SourceFile, ruleName: string, private checker: ts.TypeChecker) {
+    constructor(sourceFile: ts.SourceFile, ruleName: string, private readonly checker: ts.TypeChecker) {
         super(sourceFile, ruleName, undefined);
     }
 
@@ -57,7 +57,7 @@ class NoUnsafeAnyWalker extends Lint.AbstractWalker<void> {
     }
 
     /** Wraps `visitNode` with the correct `this` binding and discards the return value to prevent `forEachChild` from returning early */
-    private visitNodeCallback = (node: ts.Node) => void this.visitNode(node);
+    private readonly visitNodeCallback = (node: ts.Node) => void this.visitNode(node);
 
     private visitNode(node: ts.Node, anyOk?: boolean): boolean | undefined {
         switch (node.kind) {

src/rules/orderedImportsRule.ts

@@ -181,7 +181,7 @@ function parseOptions(ruleArguments: any[]): Options {
 }
 
 class Walker extends Lint.AbstractWalker<Options> {
-    private importsBlocks = [new ImportsBlock()];
+    private readonly importsBlocks = [new ImportsBlock()];
     // keep a reference to the last Fix object so when the entire block is replaced, the replacement can be added
     private lastFix: Lint.Replacement[] | undefined;
     private nextType = ImportType.LIBRARY_IMPORT;