Merge branch 'master' of https://github.com/typescript-eslint/typescr…

…ipt-eslint into feature/635-add-readonlyArray-option

README.md

@@ -58,7 +58,7 @@ One advantage is there is no tooling required to reconcile differences between A
 
 Palantir, the backers behind TSLint announced earlier this year that **they would be deprecating TSLint in favor of supporting `typescript-eslint`** in order to benefit the community. You can read more about that here: https://medium.com/palantir/tslint-in-2019-1a144c2317a9
 
-The TypeScript Team themselves also announced their plans to move the TypeScript codebase from TSLint to `typescript-eslint`, and they have been big supporters of this project.
+The TypeScript Team themselves also announced their plans to move the TypeScript codebase from TSLint to `typescript-eslint`, and they have been big supporters of this project. More details at https://github.com/microsoft/TypeScript/issues/30553
 
 <br>
 

packages/eslint-plugin/README.md

@@ -145,7 +145,7 @@ Then you should add `airbnb` (or `airbnb-base`) to your `extends` section of `.e
 | [`@typescript-eslint/no-array-constructor`](./docs/rules/no-array-constructor.md)                         | Disallow generic `Array` constructors                                                                                                               | :heavy_check_mark: | :wrench: |                   |
 | [`@typescript-eslint/no-empty-function`](./docs/rules/no-empty-function.md)                               | Disallow empty functions                                                                                                                            |                    |          |                   |
 | [`@typescript-eslint/no-empty-interface`](./docs/rules/no-empty-interface.md)                             | Disallow the declaration of empty interfaces                                                                                                        | :heavy_check_mark: |          |                   |
-| [`@typescript-eslint/no-explicit-any`](./docs/rules/no-explicit-any.md)                                   | Disallow usage of the `any` type                                                                                                                    | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/no-explicit-any`](./docs/rules/no-explicit-any.md)                                   | Disallow usage of the `any` type                                                                                                                    | :heavy_check_mark: | :wrench: |                   |
 | [`@typescript-eslint/no-extra-parens`](./docs/rules/no-extra-parens.md)                                   | Disallow unnecessary parentheses                                                                                                                    |                    | :wrench: |                   |
 | [`@typescript-eslint/no-extraneous-class`](./docs/rules/no-extraneous-class.md)                           | Forbids the use of classes as namespaces                                                                                                            |                    |          |                   |
 | [`@typescript-eslint/no-floating-promises`](./docs/rules/no-floating-promises.md)                         | Requires Promise-like values to be handled appropriately.                                                                                           |                    |          | :thought_balloon: |
@@ -159,7 +159,6 @@ Then you should add `airbnb` (or `airbnb-base`) to your `extends` section of `.e
 | [`@typescript-eslint/no-parameter-properties`](./docs/rules/no-parameter-properties.md)                   | Disallow the use of parameter properties in class constructors                                                                                      | :heavy_check_mark: |          |                   |
 | [`@typescript-eslint/no-require-imports`](./docs/rules/no-require-imports.md)                             | Disallows invocation of `require()`                                                                                                                 |                    |          |                   |
 | [`@typescript-eslint/no-this-alias`](./docs/rules/no-this-alias.md)                                       | Disallow aliasing `this`                                                                                                                            |                    |          |                   |
-| [`@typescript-eslint/no-triple-slash-reference`](./docs/rules/no-triple-slash-reference.md)               | Disallow `/// <reference path="" />` comments                                                                                                       | :heavy_check_mark: |          |                   |
 | [`@typescript-eslint/no-type-alias`](./docs/rules/no-type-alias.md)                                       | Disallow the use of type aliases                                                                                                                    |                    |          |                   |
 | [`@typescript-eslint/no-unnecessary-qualifier`](./docs/rules/no-unnecessary-qualifier.md)                 | Warns when a namespace qualifier is unnecessary                                                                                                     |                    | :wrench: | :thought_balloon: |
 | [`@typescript-eslint/no-unnecessary-type-assertion`](./docs/rules/no-unnecessary-type-assertion.md)       | Warns if a type assertion does not change the type of an expression                                                                                 |                    | :wrench: | :thought_balloon: |
@@ -178,6 +177,8 @@ Then you should add `airbnb` (or `airbnb-base`) to your `extends` section of `.e
 | [`@typescript-eslint/require-array-sort-compare`](./docs/rules/require-array-sort-compare.md)             | Enforce giving `compare` argument to `Array#sort`                                                                                                   |                    |          | :thought_balloon: |
 | [`@typescript-eslint/restrict-plus-operands`](./docs/rules/restrict-plus-operands.md)                     | When adding two variables, operands must both be of type number or of type string                                                                   |                    |          | :thought_balloon: |
 | [`@typescript-eslint/semi`](./docs/rules/semi.md)                                                         | Require or disallow semicolons instead of ASI                                                                                                       |                    | :wrench: |                   |
+| [`@typescript-eslint/strict-boolean-expressions`](./docs/rules/strict-boolean-expressions.md)             | Restricts the types allowed in boolean expressions                                                                                                  |                    |          | :thought_balloon: |
+| [`@typescript-eslint/triple-slash-reference`](./docs/rules/triple-slash-reference.md)                     | Sets preference level for triple slash directives versus ES6-style import declarations                                                              |                    |          |                   |
 | [`@typescript-eslint/type-annotation-spacing`](./docs/rules/type-annotation-spacing.md)                   | Require consistent spacing around type annotations                                                                                                  | :heavy_check_mark: | :wrench: |                   |
 | [`@typescript-eslint/unbound-method`](./docs/rules/unbound-method.md)                                     | Enforces unbound methods are called with their expected scope                                                                                       |                    |          | :thought_balloon: |
 | [`@typescript-eslint/unified-signatures`](./docs/rules/unified-signatures.md)                             | Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter                                           |                    |          |                   |

packages/eslint-plugin/ROADMAP.md

@@ -92,7 +92,7 @@
 | [`prefer-object-spread`]             | 🌟  | [`prefer-object-spread`][prefer-object-spread]                        |
 | [`radix`]                            | 🌟  | [`radix`][radix]                                                      |
 | [`restrict-plus-operands`]           | ✅  | [`@typescript-eslint/restrict-plus-operands`]                         |
-| [`strict-boolean-expressions`]       | 🛑  | N/A                                                                   |
+| [`strict-boolean-expressions`]       | ✅  | [`@typescript-eslint/strict-boolean-expressions`]                     |
 | [`strict-type-predicates`]           | 🛑  | N/A                                                                   |
 | [`switch-default`]                   | 🌟  | [`default-case`][default-case]                                        |
 | [`triple-equals`]                    | 🌟  | [`eqeqeq`][eqeqeq]                                                    |

packages/eslint-plugin/docs/rules/array-type.md

@@ -1,33 +1,83 @@
 # Requires using either `T[]` or `Array<T>` for arrays (array-type)
 
-```ts
-class Foo<T = Array<Array<Bar>>> extends Bar<T, Array<T>>
-  implements Baz<Array<T>> {
-  private s: Array<T>;
-
-  constructor(p: Array<T>) {
-    return new Array();
-  }
-}
-```
+Using the same style for array definitions across your codebase makes it easier for your developers to read and understand the types.
 
 ## Rule Details
 
-This rule aims to standardise usage of array.
+This rule aims to standardise usage of array types within your codebase.
 
 ## Options
 
-Default config:
+This rule accepts one option - a single string
+
+- `"array"` enforces use of `T[]` for all types `T`.
+- `"generic"` enforces use of `Array<T>` for all types `T`.
+- `"array-simple"` enforces use of `T[]` if `T` is a simple type.
+
+Without providing an option, by default the rule will enforce `"array"`.
+
+### `"array"`
+
+Always use `T[]` or `readonly T[]` for all array types.
+
+Incorrect code for `"array"`:
+
+```ts
+const x: Array<string> = ['a', 'b'];
+const y: ReadonlyArray<string> = ['a', 'b'];
+```
 
-```JSON
-{
-    "array-type": ["error", { "default": "array", "readonly": "array" }]
-}
+Correct code for `"array"`:
+
+```ts
+const x: string[] = ['a', 'b'];
+const y: readonly string[] = ['a', 'b'];
 ```
 
-- `array` enforces use of `T[]` for all types `T`.
-- `generic` enforces use of `Array<T>` for all types `T`.
-- `array-simple` enforces use of `T[]` if `T` is a simple type.
+### `"generic"`
+
+Always use `Array<T>` or `ReadonlyArray<T>` for all array types.
+
+Incorrect code for `"generic"`:
+
+```ts
+const x: string[] = ['a', 'b'];
+const y: readonly string[] = ['a', 'b'];
+```
+
+Correct code for `"generic"`:
+
+```ts
+const x: Array<string> = ['a', 'b'];
+const y: ReadonlyArray<string> = ['a', 'b'];
+```
+
+### `"array-simple"`
+
+Use `T[]` or `readonly T[]` for simple types (i.e. types which are just primitive names or type references).
+Use `Array<T>` or `ReadonlyArray<T>` for all other types (union types, intersection types, object types, function types, etc).
+
+Incorrect code for `"array-simple"`:
+
+```ts
+const a: (string | number)[] = ['a', 'b'];
+const b: ({ prop: string })[] = [{ prop: 'a' }];
+const c: (() => void)[] = [() => {}];
+const d: Array<MyType> = ['a', 'b'];
+const e: Array<string> = ['a', 'b'];
+const f: ReadonlyArray<string> = ['a', 'b'];
+```
+
+Correct code for `"array-simple"`:
+
+```ts
+const a: Array<string | number> = ['a', 'b'];
+const b: Array<{ prop: string }> = [{ prop: 'a' }];
+const c: Array<() => void> = [() => {}];
+const d: MyType[] = ['a', 'b'];
+const e: string[] = ['a', 'b'];
+const f: readonly string[] = ['a', 'b'];
+```
 
 ## Related to
 

packages/eslint-plugin/docs/rules/no-explicit-any.md

@@ -87,6 +87,24 @@ function greet(param: Array<string>): string {}
 function greet(param: Array<string>): Array<string> {}
 ```
 
+## Options
+
+The rule accepts an options object with the following properties:
+
+```ts
+type Options = {
+  // if true, auto-fixing will be made available in which the "any" type is converted to an "unknown" type
+  fixToUnknown: boolean;
+  // specify if arrays from the rest operator are considered okay
+  ignoreRestArgs: boolean;
+};
+
+const defaults = {
+  fixToUnknown: false,
+  ignoreRestArgs: false,
+};
+```
+
 ### ignoreRestArgs
 
 A boolean to specify if arrays from the rest operator are considered okay. `false` by default.

packages/eslint-plugin/docs/rules/no-triple-slash-reference.md

@@ -12,6 +12,8 @@ A triple-slash reference directive is a comment beginning with three slashes fol
 ES6 Modules handle this now:
 `import animal from "./Animal"`
 
+## DEPRECATED - this rule has been deprecated in favour of [`triple-slash-reference`](./triple-slash-reference.md)
+
 ## Rule Details
 
 Does not allow the use of `/// <reference />` comments.

packages/eslint-plugin/docs/rules/strict-boolean-expressions.md

@@ -0,0 +1,57 @@
+# Boolean expressions are limited to booleans (strict-boolean-expressions)
+
+Requires that any boolean expression is limited to true booleans rather than
+casting another primitive to a boolean at runtime.
+
+It is useful to be explicit, for example, if you were trying to check if a
+number was defined. Doing `if (number)` would evaluate to `false` if `number`
+was defined and `0`. This rule forces these expressions to be explicit and to
+strictly use booleans.
+
+The following nodes are checked:
+
+- Arguments to the `!`, `&&`, and `||` operators
+- The condition in a conditional expression `(cond ? x : y)`
+- Conditions for `if`, `for`, `while`, and `do-while` statements.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const number = 0;
+if (number) {
+  return;
+}
+
+let foo = bar || 'foobar';
+
+let undefinedItem;
+let foo = undefinedItem ? 'foo' : 'bar';
+
+let str = 'foo';
+while (str) {
+  break;
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const number = 0;
+if (typeof number !== 'undefined') {
+  return;
+}
+
+let foo = typeof bar !== 'undefined' ? bar : 'foobar';
+
+let undefinedItem;
+let foo = typeof undefinedItem !== 'undefined' ? 'foo' : 'bar';
+
+let str = 'foo';
+while (typeof str !== 'undefined') {
+  break;
+}
+```
+
+## Related To
+
+- TSLint: [strict-boolean-expressions](https://palantir.github.io/tslint/rules/strict-boolean-expressions)

packages/eslint-plugin/docs/rules/triple-slash-reference.md

@@ -0,0 +1,58 @@
+# Sets preference level for triple slash directives versus ES6-style import declarations. (triple-slash-reference)
+
+Use of triple-slash reference type directives is discouraged in favor of the newer `import` style. This rule allows you to ban use of `/// <reference path="" />`, `/// <reference types="" />`, or `/// <reference lib="" />` directives.
+
+Consider using this rule in place of [`no-triple-slash-reference`](./no-triple-slash-reference.md) which has been deprecated.
+
+## Rule Details
+
+With `{ "path": "never", "types": "never", "lib": "never" }` options set, the following will all be **incorrect** usage:
+
+```ts
+/// <reference path="foo" />
+/// <reference types="bar" />
+/// <reference lib="baz" />
+```
+
+Examples of **incorrect** code for the `{ "types": "prefer-import" }` option. Note that these are only errors when **both** stlyes are used for the **same** module:
+
+```ts
+/// <reference types="foo" />
+import * as foo from 'foo';
+```
+
+```ts
+/// <reference types="foo" />
+import foo = require('foo');
+```
+
+With `{ "path": "always", "types": "always", "lib": "always" }` options set, the following will all be **correct** usage:
+
+```ts
+/// <reference path="foo" />
+/// <reference types="bar" />
+/// <reference lib="baz" />
+```
+
+Examples of **correct** code for the `{ "types": "prefer-import" }` option:
+
+```ts
+import * as foo from 'foo';
+```
+
+```ts
+import foo = require('foo');
+```
+
+## When To Use It
+
+If you want to ban use of one or all of the triple slash reference directives, or any time you might use triple-slash type reference directives and ES6 import declarations in the same file.
+
+## When Not To Use It
+
+If you want to use all flavors of triple slash reference directives.
+
+## Compatibility
+
+- TSLint: [no-reference](http://palantir.github.io/tslint/rules/no-reference/)
+- TSLint: [no-reference-import](https://palantir.github.io/tslint/rules/no-reference-import/)

packages/eslint-plugin/src/configs/all.json

@@ -42,7 +42,6 @@
     "@typescript-eslint/no-parameter-properties": "error",
     "@typescript-eslint/no-require-imports": "error",
     "@typescript-eslint/no-this-alias": "error",
-    "@typescript-eslint/no-triple-slash-reference": "error",
     "@typescript-eslint/no-type-alias": "error",
     "@typescript-eslint/no-unnecessary-qualifier": "error",
     "@typescript-eslint/no-unnecessary-type-assertion": "error",
@@ -65,6 +64,7 @@
     "@typescript-eslint/restrict-plus-operands": "error",
     "semi": "off",
     "@typescript-eslint/semi": "error",
+    "@typescript-eslint/triple-slash-reference": "error",
     "@typescript-eslint/type-annotation-spacing": "error",
     "@typescript-eslint/unbound-method": "error",
     "@typescript-eslint/unified-signatures": "error"