xo 0.45.0 → 0.46.3

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.js

@@ -0,0 +1,428 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextualType = exports.isUnsafeAssignment = exports.isAnyOrAnyArrayTypeDiscriminated = exports.isTypeUnknownArrayType = exports.isTypeAnyArrayType = exports.isTypeAnyType = exports.isTypeUnknownType = exports.getTypeArguments = exports.getEqualsKind = exports.getTokenAtPosition = exports.getSourceFileOfNode = exports.typeIsOrHasBaseType = exports.isTypeFlagSet = exports.getTypeFlags = exports.getDeclaration = exports.isNullableType = exports.getConstrainedTypeAtLocation = exports.getTypeName = exports.containsAllTypesByName = exports.isTypeArrayTypeOrUnionOfArrayTypes = void 0;
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const debug_1 = __importDefault(require("debug"));
+const tsutils_1 = require("tsutils");
+const ts = __importStar(require("typescript"));
+const log = (0, debug_1.default)('typescript-eslint:eslint-plugin:utils:types');
+/**
+ * Checks if the given type is either an array type,
+ * or a union made up solely of array types.
+ */
+function isTypeArrayTypeOrUnionOfArrayTypes(type, checker) {
+    for (const t of (0, tsutils_1.unionTypeParts)(type)) {
+        if (!checker.isArrayType(t)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isTypeArrayTypeOrUnionOfArrayTypes = isTypeArrayTypeOrUnionOfArrayTypes;
+/**
+ * @param type Type being checked by name.
+ * @param allowedNames Symbol names checking on the type.
+ * @returns Whether the type is, extends, or contains all of the allowed names.
+ */
+function containsAllTypesByName(type, allowAny, allowedNames) {
+    if (isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+        return !allowAny;
+    }
+    if ((0, tsutils_1.isTypeReference)(type)) {
+        type = type.target;
+    }
+    const symbol = type.getSymbol();
+    if (symbol && allowedNames.has(symbol.name)) {
+        return true;
+    }
+    if ((0, tsutils_1.isUnionOrIntersectionType)(type)) {
+        return type.types.every(t => containsAllTypesByName(t, allowAny, allowedNames));
+    }
+    const bases = type.getBaseTypes();
+    return (typeof bases !== 'undefined' &&
+        bases.length > 0 &&
+        bases.every(t => containsAllTypesByName(t, allowAny, allowedNames)));
+}
+exports.containsAllTypesByName = containsAllTypesByName;
+/**
+ * Get the type name of a given type.
+ * @param typeChecker The context sensitive TypeScript TypeChecker.
+ * @param type The type to get the name of.
+ */
+function getTypeName(typeChecker, type) {
+    // It handles `string` and string literal types as string.
+    if ((type.flags & ts.TypeFlags.StringLike) !== 0) {
+        return 'string';
+    }
+    // If the type is a type parameter which extends primitive string types,
+    // but it was not recognized as a string like. So check the constraint
+    // type of the type parameter.
+    if ((type.flags & ts.TypeFlags.TypeParameter) !== 0) {
+        // `type.getConstraint()` method doesn't return the constraint type of
+        // the type parameter for some reason. So this gets the constraint type
+        // via AST.
+        const symbol = type.getSymbol();
+        const decls = symbol === null || symbol === void 0 ? void 0 : symbol.getDeclarations();
+        const typeParamDecl = decls === null || decls === void 0 ? void 0 : decls[0];
+        if (ts.isTypeParameterDeclaration(typeParamDecl) &&
+            typeParamDecl.constraint != null) {
+            return getTypeName(typeChecker, typeChecker.getTypeFromTypeNode(typeParamDecl.constraint));
+        }
+    }
+    // If the type is a union and all types in the union are string like,
+    // return `string`. For example:
+    // - `"a" | "b"` is string.
+    // - `string | string[]` is not string.
+    if (type.isUnion() &&
+        type.types
+            .map(value => getTypeName(typeChecker, value))
+            .every(t => t === 'string')) {
+        return 'string';
+    }
+    // If the type is an intersection and a type in the intersection is string
+    // like, return `string`. For example: `string & {__htmlEscaped: void}`
+    if (type.isIntersection() &&
+        type.types
+            .map(value => getTypeName(typeChecker, value))
+            .some(t => t === 'string')) {
+        return 'string';
+    }
+    return typeChecker.typeToString(type);
+}
+exports.getTypeName = getTypeName;
+/**
+ * Resolves the given node's type. Will resolve to the type's generic constraint, if it has one.
+ */
+function getConstrainedTypeAtLocation(checker, node) {
+    const nodeType = checker.getTypeAtLocation(node);
+    const constrained = checker.getBaseConstraintOfType(nodeType);
+    return constrained !== null && constrained !== void 0 ? constrained : nodeType;
+}
+exports.getConstrainedTypeAtLocation = getConstrainedTypeAtLocation;
+/**
+ * Checks if the given type is (or accepts) nullable
+ * @param isReceiver true if the type is a receiving type (i.e. the type of a called function's parameter)
+ */
+function isNullableType(type, { isReceiver = false, allowUndefined = true, } = {}) {
+    const flags = getTypeFlags(type);
+    if (isReceiver && flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+        return true;
+    }
+    if (allowUndefined) {
+        return (flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
+    }
+    else {
+        return (flags & ts.TypeFlags.Null) !== 0;
+    }
+}
+exports.isNullableType = isNullableType;
+/**
+ * Gets the declaration for the given variable
+ */
+function getDeclaration(checker, node) {
+    var _a;
+    const symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return null;
+    }
+    const declarations = symbol.getDeclarations();
+    return (_a = declarations === null || declarations === void 0 ? void 0 : declarations[0]) !== null && _a !== void 0 ? _a : null;
+}
+exports.getDeclaration = getDeclaration;
+/**
+ * Gets all of the type flags in a type, iterating through unions automatically
+ */
+function getTypeFlags(type) {
+    let flags = 0;
+    for (const t of (0, tsutils_1.unionTypeParts)(type)) {
+        flags |= t.flags;
+    }
+    return flags;
+}
+exports.getTypeFlags = getTypeFlags;
+/**
+ * Checks if the given type is (or accepts) the given flags
+ * @param isReceiver true if the type is a receiving type (i.e. the type of a called function's parameter)
+ */
+function isTypeFlagSet(type, flagsToCheck, isReceiver) {
+    const flags = getTypeFlags(type);
+    if (isReceiver && flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+        return true;
+    }
+    return (flags & flagsToCheck) !== 0;
+}
+exports.isTypeFlagSet = isTypeFlagSet;
+/**
+ * @returns Whether a type is an instance of the parent type, including for the parent's base types.
+ */
+function typeIsOrHasBaseType(type, parentType) {
+    const parentSymbol = parentType.getSymbol();
+    if (!type.getSymbol() || !parentSymbol) {
+        return false;
+    }
+    const typeAndBaseTypes = [type];
+    const ancestorTypes = type.getBaseTypes();
+    if (ancestorTypes) {
+        typeAndBaseTypes.push(...ancestorTypes);
+    }
+    for (const baseType of typeAndBaseTypes) {
+        const baseSymbol = baseType.getSymbol();
+        if (baseSymbol && baseSymbol.name === parentSymbol.name) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.typeIsOrHasBaseType = typeIsOrHasBaseType;
+/**
+ * Gets the source file for a given node
+ */
+function getSourceFileOfNode(node) {
+    while (node && node.kind !== ts.SyntaxKind.SourceFile) {
+        node = node.parent;
+    }
+    return node;
+}
+exports.getSourceFileOfNode = getSourceFileOfNode;
+function getTokenAtPosition(sourceFile, position) {
+    const queue = [sourceFile];
+    let current;
+    while (queue.length > 0) {
+        current = queue.shift();
+        // find the child that contains 'position'
+        for (const child of current.getChildren(sourceFile)) {
+            const start = child.getFullStart();
+            if (start > position) {
+                // If this child begins after position, then all subsequent children will as well.
+                return current;
+            }
+            const end = child.getEnd();
+            if (position < end ||
+                (position === end && child.kind === ts.SyntaxKind.EndOfFileToken)) {
+                queue.push(child);
+                break;
+            }
+        }
+    }
+    return current;
+}
+exports.getTokenAtPosition = getTokenAtPosition;
+function getEqualsKind(operator) {
+    switch (operator) {
+        case '==':
+            return {
+                isPositive: true,
+                isStrict: false,
+            };
+        case '===':
+            return {
+                isPositive: true,
+                isStrict: true,
+            };
+        case '!=':
+            return {
+                isPositive: false,
+                isStrict: false,
+            };
+        case '!==':
+            return {
+                isPositive: false,
+                isStrict: true,
+            };
+        default:
+            return undefined;
+    }
+}
+exports.getEqualsKind = getEqualsKind;
+function getTypeArguments(type, checker) {
+    var _a;
+    // getTypeArguments was only added in TS3.7
+    if (checker.getTypeArguments) {
+        return checker.getTypeArguments(type);
+    }
+    return (_a = type.typeArguments) !== null && _a !== void 0 ? _a : [];
+}
+exports.getTypeArguments = getTypeArguments;
+/**
+ * @returns true if the type is `unknown`
+ */
+function isTypeUnknownType(type) {
+    return isTypeFlagSet(type, ts.TypeFlags.Unknown);
+}
+exports.isTypeUnknownType = isTypeUnknownType;
+/**
+ * @returns true if the type is `any`
+ */
+function isTypeAnyType(type) {
+    if (isTypeFlagSet(type, ts.TypeFlags.Any)) {
+        if (type.intrinsicName === 'error') {
+            log('Found an "error" any type');
+        }
+        return true;
+    }
+    return false;
+}
+exports.isTypeAnyType = isTypeAnyType;
+/**
+ * @returns true if the type is `any[]`
+ */
+function isTypeAnyArrayType(type, checker) {
+    return (checker.isArrayType(type) &&
+        isTypeAnyType(
+        // getTypeArguments was only added in TS3.7
+        getTypeArguments(type, checker)[0]));
+}
+exports.isTypeAnyArrayType = isTypeAnyArrayType;
+/**
+ * @returns true if the type is `unknown[]`
+ */
+function isTypeUnknownArrayType(type, checker) {
+    return (checker.isArrayType(type) &&
+        isTypeUnknownType(
+        // getTypeArguments was only added in TS3.7
+        getTypeArguments(type, checker)[0]));
+}
+exports.isTypeUnknownArrayType = isTypeUnknownArrayType;
+/**
+ * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`,
+ *          otherwise it returns `AnyType.Safe`.
+ */
+function isAnyOrAnyArrayTypeDiscriminated(node, checker) {
+    const type = checker.getTypeAtLocation(node);
+    if (isTypeAnyType(type)) {
+        return 0 /* Any */;
+    }
+    if (isTypeAnyArrayType(type, checker)) {
+        return 1 /* AnyArray */;
+    }
+    return 2 /* Safe */;
+}
+exports.isAnyOrAnyArrayTypeDiscriminated = isAnyOrAnyArrayTypeDiscriminated;
+/**
+ * Does a simple check to see if there is an any being assigned to a non-any type.
+ *
+ * This also checks generic positions to ensure there's no unsafe sub-assignments.
+ * Note: in the case of generic positions, it makes the assumption that the two types are the same.
+ *
+ * @example See tests for examples
+ *
+ * @returns false if it's safe, or an object with the two types if it's unsafe
+ */
+function isUnsafeAssignment(type, receiver, checker, senderNode) {
+    var _a, _b;
+    if (isTypeAnyType(type)) {
+        // Allow assignment of any ==> unknown.
+        if (isTypeUnknownType(receiver)) {
+            return false;
+        }
+        if (!isTypeAnyType(receiver)) {
+            return { sender: type, receiver };
+        }
+    }
+    if ((0, tsutils_1.isTypeReference)(type) && (0, tsutils_1.isTypeReference)(receiver)) {
+        // TODO - figure out how to handle cases like this,
+        // where the types are assignable, but not the same type
+        /*
+        function foo(): ReadonlySet<number> { return new Set<any>(); }
+    
+        // and
+    
+        type Test<T> = { prop: T }
+        type Test2 = { prop: string }
+        declare const a: Test<any>;
+        const b: Test2 = a;
+        */
+        if (type.target !== receiver.target) {
+            // if the type references are different, assume safe, as we won't know how to compare the two types
+            // the generic positions might not be equivalent for both types
+            return false;
+        }
+        if ((senderNode === null || senderNode === void 0 ? void 0 : senderNode.type) === experimental_utils_1.AST_NODE_TYPES.NewExpression &&
+            senderNode.callee.type === experimental_utils_1.AST_NODE_TYPES.Identifier &&
+            senderNode.callee.name === 'Map' &&
+            senderNode.arguments.length === 0 &&
+            senderNode.typeParameters == null) {
+            // special case to handle `new Map()`
+            // unfortunately Map's default empty constructor is typed to return `Map<any, any>` :(
+            // https://github.com/typescript-eslint/typescript-eslint/issues/2109#issuecomment-634144396
+            return false;
+        }
+        const typeArguments = (_a = type.typeArguments) !== null && _a !== void 0 ? _a : [];
+        const receiverTypeArguments = (_b = receiver.typeArguments) !== null && _b !== void 0 ? _b : [];
+        for (let i = 0; i < typeArguments.length; i += 1) {
+            const arg = typeArguments[i];
+            const receiverArg = receiverTypeArguments[i];
+            const unsafe = isUnsafeAssignment(arg, receiverArg, checker, senderNode);
+            if (unsafe) {
+                return { sender: type, receiver };
+            }
+        }
+        return false;
+    }
+    return false;
+}
+exports.isUnsafeAssignment = isUnsafeAssignment;
+/**
+ * Returns the contextual type of a given node.
+ * Contextual type is the type of the target the node is going into.
+ * i.e. the type of a called function's parameter, or the defined type of a variable declaration
+ */
+function getContextualType(checker, node) {
+    const parent = node.parent;
+    if (!parent) {
+        return;
+    }
+    if ((0, tsutils_1.isCallExpression)(parent) || (0, tsutils_1.isNewExpression)(parent)) {
+        if (node === parent.expression) {
+            // is the callee, so has no contextual type
+            return;
+        }
+    }
+    else if ((0, tsutils_1.isVariableDeclaration)(parent) ||
+        (0, tsutils_1.isPropertyDeclaration)(parent) ||
+        (0, tsutils_1.isParameterDeclaration)(parent)) {
+        return parent.type ? checker.getTypeFromTypeNode(parent.type) : undefined;
+    }
+    else if ((0, tsutils_1.isJsxExpression)(parent)) {
+        return checker.getContextualType(parent);
+    }
+    else if ((0, tsutils_1.isPropertyAssignment)(parent) && (0, tsutils_1.isIdentifier)(node)) {
+        return checker.getContextualType(node);
+    }
+    else if ((0, tsutils_1.isBinaryExpression)(parent) &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        parent.right === node) {
+        // is RHS of assignment
+        return checker.getTypeAtLocation(parent.left);
+    }
+    else if (![ts.SyntaxKind.TemplateSpan, ts.SyntaxKind.JsxExpression].includes(parent.kind)) {
+        // parent is not something we know we can get the contextual type of
+        return;
+    }
+    // TODO - support return statement checking
+    return checker.getContextualType(node);
+}
+exports.getContextualType = getContextualType;
+//# sourceMappingURL=types.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/util/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/util/types.ts"],"names":[],"mappings":"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"}

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/adjacent-overload-signatures.md

@@ -0,0 +1,95 @@
+# Require that member overloads be consecutive (`adjacent-overload-signatures`)
+
+Grouping overloaded members together can improve readability of the code.
+
+## Rule Details
+
+This rule aims to standardize the way overloaded members are organized.
+
+The following patterns are considered warnings:
+
+```ts
+declare namespace Foo {
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function bar(): void;
+  export function foo(sn: string | number): void;
+}
+
+type Foo = {
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void;
+  foo(sn: string | number): void;
+};
+
+interface Foo {
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void;
+  foo(sn: string | number): void;
+}
+
+class Foo {
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void {}
+  foo(sn: string | number): void {}
+}
+
+export function foo(s: string): void;
+export function foo(n: number): void;
+export function bar(): void;
+export function foo(sn: string | number): void;
+```
+
+The following patterns are not warnings:
+
+```ts
+declare namespace Foo {
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function foo(sn: string | number): void;
+  export function bar(): void;
+}
+
+type Foo = {
+  foo(s: string): void;
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+};
+
+interface Foo {
+  foo(s: string): void;
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+}
+
+class Foo {
+  foo(s: string): void;
+  foo(n: number): void;
+  foo(sn: string | number): void {}
+  bar(): void {}
+}
+
+export function bar(): void;
+export function foo(s: string): void;
+export function foo(n: number): void;
+export function foo(sn: string | number): void;
+```
+
+## When Not To Use It
+
+If you don't care about the general structure of the code, then you will not need this rule.
+
+## Compatibility
+
+- TSLint: [adjacent-overload-signatures](https://palantir.github.io/tslint/rules/adjacent-overload-signatures/)
+
+## Attributes
+
+- [x] ✅ Recommended
+- [ ] 🔧 Fixable
+- [ ] 💭 Requires type information

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/array-type.md

@@ -0,0 +1,122 @@
+# Requires using either `T[]` or `Array<T>` for arrays (`array-type`)
+
+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 standardize usage of array types within your codebase.
+
+## Options
+
+```ts
+type ArrayOption = 'array' | 'generic' | 'array-simple';
+type Options = {
+  default: ArrayOption;
+  readonly?: ArrayOption;
+};
+
+const defaultOptions: Options = {
+  default: 'array',
+};
+```
+
+The rule accepts an options object with the following properties:
+
+- `default` - sets the array type expected for mutable cases.
+- `readonly` - sets the array type expected for readonly arrays. If this is omitted, then the value for `default` will be used.
+
+Each property can be set to one of three strings: `'array' | 'generic' | 'array-simple'`.
+
+The default config will enforce that all mutable and readonly arrays use the `'array'` syntax.
+
+### `"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'];
+```
+
+Correct code for `"array"`:
+
+```ts
+const x: string[] = ['a', 'b'];
+const y: readonly string[] = ['a', 'b'];
+```
+
+### `"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'];
+```
+
+## Combination matrix
+
+This matrix lists all possible option combinations and their expected results for different types of Arrays.
+
+| defaultOption  | readonlyOption | Array with simple type | Array with non simple type | Readonly array with simple type | Readonly array with non simple type |
+| -------------- | -------------- | ---------------------- | -------------------------- | ------------------------------- | ----------------------------------- |
+| `array`        |                | `number[]`             | `(Foo & Bar)[]`            | `readonly number[]`             | `readonly (Foo & Bar)[]`            |
+| `array`        | `array`        | `number[]`             | `(Foo & Bar)[]`            | `readonly number[]`             | `readonly (Foo & Bar)[]`            |
+| `array`        | `array-simple` | `number[]`             | `(Foo & Bar)[]`            | `readonly number[]`             | `ReadonlyArray<Foo & Bar>`          |
+| `array`        | `generic`      | `number[]`             | `(Foo & Bar)[]`            | `ReadonlyArray<number>`         | `ReadonlyArray<Foo & Bar>`          |
+| `array-simple` |                | `number[]`             | `Array<Foo & Bar>`         | `readonly number[]`             | `ReadonlyArray<Foo & Bar>`          |
+| `array-simple` | `array`        | `number[]`             | `Array<Foo & Bar>`         | `readonly number[]`             | `readonly (Foo & Bar)[]`            |
+| `array-simple` | `array-simple` | `number[]`             | `Array<Foo & Bar>`         | `readonly number[]`             | `ReadonlyArray<Foo & Bar>`          |
+| `array-simple` | `generic`      | `number[]`             | `Array<Foo & Bar>`         | `ReadonlyArray<number>`         | `ReadonlyArray<Foo & Bar>`          |
+| `generic`      |                | `Array<number>`        | `Array<Foo & Bar>`         | `ReadonlyArray<number>`         | `ReadonlyArray<Foo & Bar>`          |
+| `generic`      | `array`        | `Array<number>`        | `Array<Foo & Bar>`         | `readonly number[]`             | `readonly (Foo & Bar)[]`            |
+| `generic`      | `array-simple` | `Array<number>`        | `Array<Foo & Bar>`         | `readonly number[]`             | `ReadonlyArray<Foo & Bar>`          |
+| `generic`      | `generic`      | `Array<number>`        | `Array<Foo & Bar>`         | `ReadonlyArray<number>`         | `ReadonlyArray<Foo & Bar>`          |
+
+## Related to
+
+- TSLint: [array-type](https://palantir.github.io/tslint/rules/array-type/)
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [x] 🔧 Fixable
+- [ ] 💭 Requires type information