diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8f6904d879de..3e2d0e9dd51c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -93,10 +93,13 @@ jobs: - name: Check code formatting run: yarn format-check - - name: Run linting + - name: Lint code run: yarn lint - - name: Validate spelling + - name: Lint markdown + run: yarn lint:markdown + + - name: Check spelling run: yarn check:spelling integration_tests: diff --git a/.markdownlint.json b/.markdownlint.json new file mode 100644 index 000000000000..77f01355394d --- /dev/null +++ b/.markdownlint.json @@ -0,0 +1,95 @@ +{ + "default": false, + + // MD001/heading-increment/header-increment - Heading levels should only increment by one level at a time + "MD001": true, + // MD002/first-heading-h1/first-header-h1 - First heading should be a top level heading + "MD002": false, + // MD003/heading-style/header-style - Heading style + "MD003": false, + // MD004/ul-style - Unordered list style + "MD004": false, + // MD005/list-indent - Inconsistent indentation for list items at the same level + "MD005": false, + // MD006/ul-start-left - Consider starting bulleted lists at the beginning of the line + "MD006": false, + // MD007/ul-indent - Unordered list indentation + "MD007": false, + // MD009/no-trailing-spaces - Trailing spaces + "MD009": false, + // MD010/no-hard-tabs - Hard tabs + "MD010": false, + // MD011/no-reversed-links - Reversed link syntax + "MD011": true, + // MD012/no-multiple-blanks - Multiple consecutive blank lines + "MD012": false, + // MD013/line-length - Line length + "MD013": { "line_length": 99999 }, // no line length + // MD014/commands-show-output - Dollar signs used before commands without showing output + "MD014": false, + // MD018/no-missing-space-atx - No space after hash on atx style heading + "MD018": true, + // MD019/no-multiple-space-atx - Multiple spaces after hash on atx style heading + "MD019": false, + // MD020/no-missing-space-closed-atx - No space inside hashes on closed atx style heading + "MD020": false, + // MD021/no-multiple-space-closed-atx - Multiple spaces inside hashes on closed atx style heading + "MD021": false, + // MD022/blanks-around-headings/blanks-around-headers - Headings should be surrounded by blank lines + "MD022": true, + // MD023/heading-start-left/header-start-left - Headings must start at the beginning of the line + "MD023": false, + // MD024/no-duplicate-heading/no-duplicate-header - Multiple headings with the same content + "MD024": false, + // MD025/single-title/single-h1 - Multiple top level headings in the same document + "MD025": true, + // MD026/no-trailing-punctuation - Trailing punctuation in heading + "MD026": { "punctuation": ".,;:!。，；：！？" }, // specifically allow "?" + // MD027/no-multiple-space-blockquote - Multiple spaces after blockquote symbol + "MD027": false, + // MD028/no-blanks-blockquote - Blank line inside blockquote + "MD028": true, + // MD029/ol-prefix - Ordered list item prefix + "MD029": false, + // MD030/list-marker-space - Spaces after list markers + "MD030": true, + // MD031/blanks-around-fences - Fenced code blocks should be surrounded by blank lines + "MD031": false, + // MD032/blanks-around-lists - Lists should be surrounded by blank lines + "MD032": false, + // MD033/no-inline-html - Inline HTML + "MD033": { "allowed_elements": ["a", "img", "br", "sup", "h1", "p"] }, + // MD034/no-bare-urls - Bare URL used + "MD034": false, + // MD035/hr-style - Horizontal rule style + "MD035": false, + // MD036/no-emphasis-as-heading/no-emphasis-as-header - Emphasis used instead of a heading + "MD036": true, + // MD037/no-space-in-emphasis - Spaces inside emphasis markers + "MD037": true, + // MD038/no-space-in-code - Spaces inside code span elements + "MD038": true, + // MD039/no-space-in-links - Spaces inside link text + "MD039": true, + // MD040/fenced-code-language - Fenced code blocks should have a language specified + "MD040": true, + // MD041/first-line-heading/first-line-h1 - First line in file should be a top level heading + "MD041": false, // would love to do this, but our README files use `

` as their heading + // MD042/no-empty-links - No empty links + "MD042": true, + // MD043/required-headings/required-headers - Required heading structure + "MD043": false, + // MD044/proper-names - Proper names should have the correct capitalization + "MD044": { + "names": ["JavaScript", "TypeScript", "TSLint", "ESLint"], + "code_blocks": false + }, + // MD045/no-alt-text - Images should have alternate text (alt text) + "MD045": true, + // MD046/code-block-style - Code block style + "MD046": { "style": "fenced" }, + // MD047/single-trailing-newline - Files should end with a single newline character + "MD047": false, + // MD048/code-fence-style - Code fence style + "MD048": { "style": "backtick" } +} diff --git a/.markdownlintignore b/.markdownlintignore new file mode 100644 index 000000000000..a5442e435549 --- /dev/null +++ b/.markdownlintignore @@ -0,0 +1,3 @@ +node_modules +CHANGELOG.md +tests/integration/fixtures/markdown diff --git a/.vscode/extensions.json b/.vscode/extensions.json index 33430df8759e..d91eb64d0d49 100644 --- a/.vscode/extensions.json +++ b/.vscode/extensions.json @@ -3,7 +3,8 @@ "esbenp.prettier-vscode", "dbaeumer.vscode-eslint", "editorconfig.editorconfig", - "streetsidesoftware.code-spell-checker" + "streetsidesoftware.code-spell-checker", + "davidanson.vscode-markdownlint" ], "unwantedRecommendations": ["hookyqr.beautify", "dbaeumer.jshint"] } diff --git a/.vscode/settings.json b/.vscode/settings.json index c03c3aac4dd4..dc6744448f3d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,5 +17,5 @@ "typescript.preferences.importModuleSpecifier": "auto", "javascript.preferences.quoteStyle": "single", "typescript.preferences.quoteStyle": "single", - "editor.defaultFormatter": "esbenp.prettier-vscode" + "editor.defaultFormatter": "esbenp.prettier-vscode", } diff --git a/CHANGELOG.md b/CHANGELOG.md index 17a398ca454a..9d0a14f5669d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,35 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + + +### Bug Fixes + +* **eslint-plugin:** [method-signature-style] handle multiline params ([#1861](https://github.com/typescript-eslint/typescript-eslint/issues/1861)) ([5832a86](https://github.com/typescript-eslint/typescript-eslint/commit/5832a8643bbe174ec02df5966bb333e506e45f5d)) +* **eslint-plugin:** [no-empty-interface] use suggestion fixer for ambient contexts ([#1880](https://github.com/typescript-eslint/typescript-eslint/issues/1880)) ([62b2278](https://github.com/typescript-eslint/typescript-eslint/commit/62b2278aec0011c93eae17bed8b278114d3379a2)) +* **eslint-plugin:** [unbound-method] false positive on property function initializer ([#1890](https://github.com/typescript-eslint/typescript-eslint/issues/1890)) ([f1c3b18](https://github.com/typescript-eslint/typescript-eslint/commit/f1c3b18f7aadc81f7dca7aa32aa1a8fe424e04e7)) +* **eslint-plugin:** [unbound-method] ignore assignments _to_ methods ([#1736](https://github.com/typescript-eslint/typescript-eslint/issues/1736)) ([6b4680b](https://github.com/typescript-eslint/typescript-eslint/commit/6b4680b6e7343d9d98fa1de170f387a36d98b73e)) +* **eslint-plugin:** no-empty-interface autofix ([#1865](https://github.com/typescript-eslint/typescript-eslint/issues/1865)) ([829a2f7](https://github.com/typescript-eslint/typescript-eslint/commit/829a2f728f876d356908e2338c2d6620e58f9943)), closes [#1864](https://github.com/typescript-eslint/typescript-eslint/issues/1864) +* **eslint-plugin:** use `isTypeArrayTypeOrUnionOfArrayTypes` util for checking if type is array ([#1728](https://github.com/typescript-eslint/typescript-eslint/issues/1728)) ([05030f8](https://github.com/typescript-eslint/typescript-eslint/commit/05030f8d2bd5a50e95053bc61380891da71cc567)) + + +### Features + +* **eslint-plugin:** [ban-ts-comment] support `ts-expect-error` ([#1706](https://github.com/typescript-eslint/typescript-eslint/issues/1706)) ([469cff3](https://github.com/typescript-eslint/typescript-eslint/commit/469cff332c041f38f60de052769287342455cff1)) +* **eslint-plugin:** [consistent-type-assertions] always allow `const` assertions ([#1713](https://github.com/typescript-eslint/typescript-eslint/issues/1713)) ([af2c00d](https://github.com/typescript-eslint/typescript-eslint/commit/af2c00de62f7e31eaeb88996ebf3f330cc8473b9)) +* **eslint-plugin:** [explicit-function-return-type] add option to allow concise arrows that start with void ([#1732](https://github.com/typescript-eslint/typescript-eslint/issues/1732)) ([2e9c202](https://github.com/typescript-eslint/typescript-eslint/commit/2e9c2028a8a0b226e0f87d4bcc997fa259ca3ebd)) +* **eslint-plugin:** [explicit-module-boundary-types] add optio… ([#1778](https://github.com/typescript-eslint/typescript-eslint/issues/1778)) ([3eee804](https://github.com/typescript-eslint/typescript-eslint/commit/3eee804461d017ea6189cd7f64fcd473623684b4)) +* **eslint-plugin:** [no-base-to-string] add option to ignore tagged templates ([#1763](https://github.com/typescript-eslint/typescript-eslint/issues/1763)) ([f5edb99](https://github.com/typescript-eslint/typescript-eslint/commit/f5edb9938c33f8b68f026eba00db3abe9359ced3)) +* **eslint-plugin:** [restrict-template-expressions] add option `allowAny` ([#1762](https://github.com/typescript-eslint/typescript-eslint/issues/1762)) ([d44c0f9](https://github.com/typescript-eslint/typescript-eslint/commit/d44c0f9bed2404ca00b020b35fd825929e213398)) +* **eslint-plugin:** add rule `prefer-reduce-type-parameter` ([#1707](https://github.com/typescript-eslint/typescript-eslint/issues/1707)) ([c92d240](https://github.com/typescript-eslint/typescript-eslint/commit/c92d240e49113779053eac32038382b282812afc)) +* **eslint-plugin:** add rule `prefer-ts-expect-error` ([#1705](https://github.com/typescript-eslint/typescript-eslint/issues/1705)) ([7021f21](https://github.com/typescript-eslint/typescript-eslint/commit/7021f2151a25db2a8edf17e06cd6f21e90761ec8)) +* **eslint-plugin:** add rule no-unsafe-assignment ([#1694](https://github.com/typescript-eslint/typescript-eslint/issues/1694)) ([a49b860](https://github.com/typescript-eslint/typescript-eslint/commit/a49b860cbbb2c7d718b99f561e2fb6eaadf16f17)) + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1df1de8f857d..9cd07ba705b6 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -50,6 +50,7 @@ We have a sophisticated CI process setup which gets run on every PR. You must pa - Coverage reports should automatically be generated locally, and the `codecov` bot should also comment on your PR with the percentage, as well as links to the line-by-line coverage of each file touched by your PR. - Ensure you have no lint errors. - You can run `yarn lint` in any package or in the root. + - You can run `yarn lint:markdown` in the root. - If you have made changes to any markdown documentation, ensure there are no spelling errors - You can run `yarn check:spelling` in the root. - Or if you are using vscode, you can use [`Code Spell Checker`](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker) plugin. @@ -60,7 +61,7 @@ We have a sophisticated CI process setup which gets run on every PR. You must pa Once your changes are ready, you can raise a PR. The title of your PR should match the following format: -``` +```text (): ``` diff --git a/docs/getting-started/README.md b/docs/getting-started/README.md index f3abf26f1c42..27a99d4b9fae 100644 --- a/docs/getting-started/README.md +++ b/docs/getting-started/README.md @@ -6,6 +6,6 @@ The goal of these docs are to give you a quick overview of the project and all o The docs are broken down into the following categories: -### [I want to lint my TypeScript codebase.](./linting/README.md) +## [I want to lint my TypeScript codebase.](./linting/README.md) -### [(TODO) I want to write an ESLint plugin in TypeScript.](./plugin-development/README.md) +## [(TODO) I want to write an ESLint plugin in TypeScript.](./plugin-development/README.md) diff --git a/lerna.json b/lerna.json index ecad9d3e932c..dde84901cc10 100644 --- a/lerna.json +++ b/lerna.json @@ -1,5 +1,5 @@ { - "version": "2.27.0", + "version": "2.28.0", "npmClient": "yarn", "useWorkspaces": true, "stream": true diff --git a/package.json b/package.json index 5aa87589e193..562b5cd9370f 100644 --- a/package.json +++ b/package.json @@ -30,6 +30,8 @@ "kill-integration-test-containers": "docker-compose -f tests/integration/docker-compose.yml down -v --rmi local", "lint": "eslint . --ext .js,.ts", "lint-fix": "eslint . --ext .js,.ts --fix", + "lint:markdown": "markdownlint '**/*.md' --config=.markdownlint.json --ignore-path=.markdownlintignore", + "lint:markdown:fix": "lint:markdown --fix", "pre-commit": "yarn lint-staged", "pre-push": "yarn format-check", "postinstall": "lerna bootstrap && yarn build && lerna link", @@ -70,6 +72,7 @@ "jest": "^25.1.0", "lerna": "^3.20.2", "lint-staged": "^9.4.3", + "markdownlint-cli": "^0.22.0", "prettier": "^1.19.1", "ts-jest": "^25.0.0", "ts-node": "^8.5.0", diff --git a/packages/eslint-plugin-internal/CHANGELOG.md b/packages/eslint-plugin-internal/CHANGELOG.md index 00db774efbae..c86faff06c0c 100644 --- a/packages/eslint-plugin-internal/CHANGELOG.md +++ b/packages/eslint-plugin-internal/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + +**Note:** Version bump only for package @typescript-eslint/eslint-plugin-internal + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) diff --git a/packages/eslint-plugin-internal/package.json b/packages/eslint-plugin-internal/package.json index c70d071c3955..40e465ce4eb4 100644 --- a/packages/eslint-plugin-internal/package.json +++ b/packages/eslint-plugin-internal/package.json @@ -1,6 +1,6 @@ { "name": "@typescript-eslint/eslint-plugin-internal", - "version": "2.27.0", + "version": "2.28.0", "private": true, "main": "dist/index.js", "scripts": { @@ -12,7 +12,7 @@ "typecheck": "tsc -p tsconfig.json --noEmit" }, "dependencies": { - "@typescript-eslint/experimental-utils": "2.27.0", + "@typescript-eslint/experimental-utils": "2.28.0", "prettier": "*" } } diff --git a/packages/eslint-plugin-tslint/CHANGELOG.md b/packages/eslint-plugin-tslint/CHANGELOG.md index feca294a7d3f..3c242a42c633 100644 --- a/packages/eslint-plugin-tslint/CHANGELOG.md +++ b/packages/eslint-plugin-tslint/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + +**Note:** Version bump only for package @typescript-eslint/eslint-plugin-tslint + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) **Note:** Version bump only for package @typescript-eslint/eslint-plugin-tslint diff --git a/packages/eslint-plugin-tslint/package.json b/packages/eslint-plugin-tslint/package.json index 5a3c9134f85c..158d9a84b159 100644 --- a/packages/eslint-plugin-tslint/package.json +++ b/packages/eslint-plugin-tslint/package.json @@ -1,6 +1,6 @@ { "name": "@typescript-eslint/eslint-plugin-tslint", - "version": "2.27.0", + "version": "2.28.0", "main": "dist/index.js", "typings": "src/index.ts", "description": "TSLint wrapper plugin for ESLint", @@ -31,7 +31,7 @@ "typecheck": "tsc -p tsconfig.json --noEmit" }, "dependencies": { - "@typescript-eslint/experimental-utils": "2.27.0", + "@typescript-eslint/experimental-utils": "2.28.0", "lodash": "^4.17.15" }, "peerDependencies": { @@ -41,6 +41,6 @@ }, "devDependencies": { "@types/lodash": "^4.14.149", - "@typescript-eslint/parser": "2.27.0" + "@typescript-eslint/parser": "2.28.0" } } diff --git a/packages/eslint-plugin/CHANGELOG.md b/packages/eslint-plugin/CHANGELOG.md index 965a0e893bea..72d30f22b36c 100644 --- a/packages/eslint-plugin/CHANGELOG.md +++ b/packages/eslint-plugin/CHANGELOG.md @@ -3,6 +3,35 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + + +### Bug Fixes + +* **eslint-plugin:** [method-signature-style] handle multiline params ([#1861](https://github.com/typescript-eslint/typescript-eslint/issues/1861)) ([5832a86](https://github.com/typescript-eslint/typescript-eslint/commit/5832a8643bbe174ec02df5966bb333e506e45f5d)) +* **eslint-plugin:** [no-empty-interface] use suggestion fixer for ambient contexts ([#1880](https://github.com/typescript-eslint/typescript-eslint/issues/1880)) ([62b2278](https://github.com/typescript-eslint/typescript-eslint/commit/62b2278aec0011c93eae17bed8b278114d3379a2)) +* **eslint-plugin:** [unbound-method] false positive on property function initializer ([#1890](https://github.com/typescript-eslint/typescript-eslint/issues/1890)) ([f1c3b18](https://github.com/typescript-eslint/typescript-eslint/commit/f1c3b18f7aadc81f7dca7aa32aa1a8fe424e04e7)) +* **eslint-plugin:** [unbound-method] ignore assignments _to_ methods ([#1736](https://github.com/typescript-eslint/typescript-eslint/issues/1736)) ([6b4680b](https://github.com/typescript-eslint/typescript-eslint/commit/6b4680b6e7343d9d98fa1de170f387a36d98b73e)) +* **eslint-plugin:** no-empty-interface autofix ([#1865](https://github.com/typescript-eslint/typescript-eslint/issues/1865)) ([829a2f7](https://github.com/typescript-eslint/typescript-eslint/commit/829a2f728f876d356908e2338c2d6620e58f9943)), closes [#1864](https://github.com/typescript-eslint/typescript-eslint/issues/1864) +* **eslint-plugin:** use `isTypeArrayTypeOrUnionOfArrayTypes` util for checking if type is array ([#1728](https://github.com/typescript-eslint/typescript-eslint/issues/1728)) ([05030f8](https://github.com/typescript-eslint/typescript-eslint/commit/05030f8d2bd5a50e95053bc61380891da71cc567)) + + +### Features + +* **eslint-plugin:** [ban-ts-comment] support `ts-expect-error` ([#1706](https://github.com/typescript-eslint/typescript-eslint/issues/1706)) ([469cff3](https://github.com/typescript-eslint/typescript-eslint/commit/469cff332c041f38f60de052769287342455cff1)) +* **eslint-plugin:** [consistent-type-assertions] always allow `const` assertions ([#1713](https://github.com/typescript-eslint/typescript-eslint/issues/1713)) ([af2c00d](https://github.com/typescript-eslint/typescript-eslint/commit/af2c00de62f7e31eaeb88996ebf3f330cc8473b9)) +* **eslint-plugin:** [explicit-function-return-type] add option to allow concise arrows that start with void ([#1732](https://github.com/typescript-eslint/typescript-eslint/issues/1732)) ([2e9c202](https://github.com/typescript-eslint/typescript-eslint/commit/2e9c2028a8a0b226e0f87d4bcc997fa259ca3ebd)) +* **eslint-plugin:** [explicit-module-boundary-types] add optio… ([#1778](https://github.com/typescript-eslint/typescript-eslint/issues/1778)) ([3eee804](https://github.com/typescript-eslint/typescript-eslint/commit/3eee804461d017ea6189cd7f64fcd473623684b4)) +* **eslint-plugin:** [no-base-to-string] add option to ignore tagged templates ([#1763](https://github.com/typescript-eslint/typescript-eslint/issues/1763)) ([f5edb99](https://github.com/typescript-eslint/typescript-eslint/commit/f5edb9938c33f8b68f026eba00db3abe9359ced3)) +* **eslint-plugin:** [restrict-template-expressions] add option `allowAny` ([#1762](https://github.com/typescript-eslint/typescript-eslint/issues/1762)) ([d44c0f9](https://github.com/typescript-eslint/typescript-eslint/commit/d44c0f9bed2404ca00b020b35fd825929e213398)) +* **eslint-plugin:** add rule `prefer-reduce-type-parameter` ([#1707](https://github.com/typescript-eslint/typescript-eslint/issues/1707)) ([c92d240](https://github.com/typescript-eslint/typescript-eslint/commit/c92d240e49113779053eac32038382b282812afc)) +* **eslint-plugin:** add rule `prefer-ts-expect-error` ([#1705](https://github.com/typescript-eslint/typescript-eslint/issues/1705)) ([7021f21](https://github.com/typescript-eslint/typescript-eslint/commit/7021f2151a25db2a8edf17e06cd6f21e90761ec8)) +* **eslint-plugin:** add rule no-unsafe-assignment ([#1694](https://github.com/typescript-eslint/typescript-eslint/issues/1694)) ([a49b860](https://github.com/typescript-eslint/typescript-eslint/commit/a49b860cbbb2c7d718b99f561e2fb6eaadf16f17)) + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md index 92131acf458e..7ed22981926c 100644 --- a/packages/eslint-plugin/README.md +++ b/packages/eslint-plugin/README.md @@ -134,6 +134,7 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int | [`@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-arguments`](./docs/rules/no-unnecessary-type-arguments.md) | Enforces that type arguments will not be used if not required | | :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 | :heavy_check_mark: | :wrench: | :thought_balloon: | +| [`@typescript-eslint/no-unsafe-assignment`](./docs/rules/no-unsafe-assignment.md) | Disallows assigning any to variables and properties | | | :thought_balloon: | | [`@typescript-eslint/no-unsafe-call`](./docs/rules/no-unsafe-call.md) | Disallows calling an any type value | | | :thought_balloon: | | [`@typescript-eslint/no-unsafe-member-access`](./docs/rules/no-unsafe-member-access.md) | Disallows member access on any typed variables | | | :thought_balloon: | | [`@typescript-eslint/no-unsafe-return`](./docs/rules/no-unsafe-return.md) | Disallows returning any from a function | | | :thought_balloon: | @@ -148,8 +149,10 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int | [`@typescript-eslint/prefer-optional-chain`](./docs/rules/prefer-optional-chain.md) | Prefer using concise optional chain expressions instead of chained logical ands | | :wrench: | | | [`@typescript-eslint/prefer-readonly`](./docs/rules/prefer-readonly.md) | Requires that private members are marked as `readonly` if they're never modified outside of the constructor | | :wrench: | :thought_balloon: | | [`@typescript-eslint/prefer-readonly-parameter-types`](./docs/rules/prefer-readonly-parameter-types.md) | Requires that function parameters are typed as readonly to prevent accidental mutation of inputs | | | :thought_balloon: | +| [`@typescript-eslint/prefer-reduce-type-parameter`](./docs/rules/prefer-reduce-type-parameter.md) | Prefer using type parameter when calling `Array#reduce` instead of casting | | :wrench: | :thought_balloon: | | [`@typescript-eslint/prefer-regexp-exec`](./docs/rules/prefer-regexp-exec.md) | Enforce that `RegExp#exec` is used instead of `String#match` if no global flag is provided | :heavy_check_mark: | | :thought_balloon: | | [`@typescript-eslint/prefer-string-starts-ends-with`](./docs/rules/prefer-string-starts-ends-with.md) | Enforce the use of `String#startsWith` and `String#endsWith` instead of other equivalent methods of checking substrings | :heavy_check_mark: | :wrench: | :thought_balloon: | +| [`@typescript-eslint/prefer-ts-expect-error`](./docs/rules/prefer-ts-expect-error.md) | Recommends using `// @ts-expect-error` over `// @ts-ignore` | | :wrench: | | | [`@typescript-eslint/promise-function-async`](./docs/rules/promise-function-async.md) | Requires any function or method that returns a Promise to be marked async | | | :thought_balloon: | | [`@typescript-eslint/require-array-sort-compare`](./docs/rules/require-array-sort-compare.md) | Requires `Array#sort` calls to always provide a `compareFunction` | | | :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: | diff --git a/packages/eslint-plugin/ROADMAP.md b/packages/eslint-plugin/ROADMAP.md index 7ca8048769be..c6348ab26588 100644 --- a/packages/eslint-plugin/ROADMAP.md +++ b/packages/eslint-plugin/ROADMAP.md @@ -184,7 +184,7 @@ It lists all TSLint rules along side rules from the ESLint ecosystem that are th | [`one-variable-per-declaration`] | 🌟 | [`one-var`][one-var] | | [`ordered-imports`] | 🌓 | [`import/order`] | | [`prefer-function-over-method`] | 🌟 | [`class-methods-use-this`][class-methods-use-this] | -| [`prefer-method-signature`] | 🛑 | N/A | +| [`prefer-method-signature`] | ✅ | [`@typescript-eslint/method-signature-style`] | | [`prefer-switch`] | 🛑 | N/A | | [`prefer-template`] | 🌟 | [`prefer-template`][prefer-template] | | [`prefer-while`] | 🛑 | N/A | @@ -202,7 +202,7 @@ It lists all TSLint rules along side rules from the ESLint ecosystem that are th [1] Recommended config: `["error", { blankLine: "always", prev: "*", next: "return" }]`
[2] Doesn't check other control flow statements, such as `break` or `continue`. -## tslint-microsoft-contrib rules +## `tslint-microsoft-contrib` rules Rule listing is [here](https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules). Deprecated rules are excluded (`missing-jsdoc`, `missing-optional-annotation`, `no-duplicate-case`, `no-duplicate-parameter-names`, `no-function-constructor-with-string-args`, `no-increment-decrement`, `no-empty-interfaces`, `no-missing-visibility-modifiers`, `no-multiple-var-decl`, `no-reserved-keywords`, `no-stateless-class`, `no-var-self`, `no-unnecessary-bind`, and `valid-typeof`). See the docs in the link above to find out what to use instead. @@ -211,7 +211,7 @@ Deprecated rules are excluded (`missing-jsdoc`, `missing-optional-annotation`, ` Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint-plugin-chai-expect-keywords), [`chai-expect`](https://github.com/Turbo87/eslint-plugin-chai-expect), [`chai-friendly`](https://github.com/ihordiachenko/eslint-plugin-chai-friendly), [`mocha`](https://github.com/lo1tuma/eslint-plugin-mocha), and [`jest`](https://github.com/jest-community/eslint-plugin-jest) -| tslint-microsoft-contrib rule | | ESLint rule | +| `tslint-microsoft-contrib` rule | | ESLint rule | | ---------------------------------- | :-: | ------------------------- | | `chai-prefer-contains-to-index-of` | 🛑 | N/A | | `chai-vague-errors` | 🛑 | N/A | @@ -220,16 +220,16 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint- ### TypeScript -| tslint-microsoft-contrib rule | | ESLint rule | -| ----------------------------- | :-: | ---------------------------------------------------------- | -| `prefer-array-literal` | 🌓 | [`@typescript-eslint/no-array-constructor`] [1] | -| `prefer-type-cast` | 🛑 | N/A | +| `tslint-microsoft-contrib` rule | | ESLint rule | +| ------------------------------- | :-: | ---------------------------------------------------------- | +| `prefer-array-literal` | 🌓 | [`@typescript-eslint/no-array-constructor`] [1] | +| `prefer-type-cast` | 🛑 | N/A | [1] ESLint rule is slightly less strict, allowing `new Array()` and `Array(2)`. ### Miscellaneous -| tslint-microsoft-contrib rule | | ESLint rule | +| `tslint-microsoft-contrib` rule | | ESLint rule | | ------------------------------------- | :-: | ---------------------------------------------------------------------- | | `export-name` | 🛑 | N/A ([relevant plugin][plugin:import]) | | `function-name` | 🛑 | N/A | @@ -274,7 +274,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint- ### Security -| tslint-microsoft-contrib rule | | ESLint rule | +| `tslint-microsoft-contrib` rule | | ESLint rule | | ------------------------------- | :-: | -------------------------------------------------- | | `no-disable-auto-sanitization` | 🛑 | N/A | | `no-document-domain` | 🌓 | Use [`no-restricted-syntax`][no-restricted-syntax] | @@ -291,7 +291,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint- ### Browser -| tslint-microsoft-contrib rule | | ESLint rule | +| `tslint-microsoft-contrib` rule | | ESLint rule | | ----------------------------------- | :-: | -------------------------------------------------- | | `jquery-deferred-must-complete` | 🛑 | N/A | | `no-backbone-get-set-outside-model` | 🛑 | N/A | @@ -306,7 +306,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint- ### React A11y -| tslint-microsoft-contrib rule | | ESLint rule | +| `tslint-microsoft-contrib` rule | | ESLint rule | | ----------------------------------------- | :-: | ---------------------------------------------------------- | | `react-a11y-accessible-headings` | 🌓 | [`jsx-a11y/heading-has-content`] [1] | | `react-a11y-anchors` | 🔌 | [`jsx-a11y/anchor-is-valid`] | @@ -597,6 +597,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint- [`@typescript-eslint/consistent-type-definitions`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/consistent-type-definitions.md [`@typescript-eslint/explicit-member-accessibility`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/explicit-member-accessibility.md [`@typescript-eslint/member-ordering`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/member-ordering.md +[`@typescript-eslint/method-signature-style`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/method-signature-style.md [`@typescript-eslint/no-explicit-any`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-explicit-any.md [`@typescript-eslint/no-empty-interface`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-empty-interface.md [`@typescript-eslint/no-inferrable-types`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-inferrable-types.md diff --git a/packages/eslint-plugin/docs/rules/ban-ts-comment.md b/packages/eslint-plugin/docs/rules/ban-ts-comment.md index 58f99dc048a5..cb540bc8d092 100644 --- a/packages/eslint-plugin/docs/rules/ban-ts-comment.md +++ b/packages/eslint-plugin/docs/rules/ban-ts-comment.md @@ -5,7 +5,8 @@ Using these to suppress TypeScript Compiler Errors reduces the effectiveness of The directive comments supported by TypeScript are: -``` +```ts +// @ts-expect-error // @ts-ignore // @ts-nocheck // @ts-check @@ -14,22 +15,24 @@ The directive comments supported by TypeScript are: ## Rule Details This rule lets you set which directive comments you want to allow in your codebase. -By default, only `@ts-check` is allowed, as it enables rather then suppresses errors. +By default, only `@ts-check` is allowed, as it enables rather than suppresses errors. The configuration looks like this: -``` +```ts interface Options { + 'ts-expect-error'?: boolean; 'ts-ignore'?: boolean; 'ts-nocheck'?: boolean; 'ts-check'?: boolean; } const defaultOptions: Options = { + 'ts-expect-error': true, 'ts-ignore': true, 'ts-nocheck': true, - 'ts-check': false -} + 'ts-check': false, +}; ``` A value of `true` for a particular directive means that this rule will report if it finds any usage of said directive. diff --git a/packages/eslint-plugin/docs/rules/ban-ts-ignore.md b/packages/eslint-plugin/docs/rules/ban-ts-ignore.md index 8f69c864669b..936d7936afc9 100644 --- a/packages/eslint-plugin/docs/rules/ban-ts-ignore.md +++ b/packages/eslint-plugin/docs/rules/ban-ts-ignore.md @@ -4,6 +4,11 @@ This rule has been deprecated in favor of [`ban-ts-comment`](./ban-ts-comment.md Suppressing TypeScript Compiler Errors can be hard to discover. +## DEPRECATED + +This rule has been deprecated in favour of the [`ban-ts-comment`](./ban-ts-comment.md) rule. +It will be removed in a future version of this plugin. + ## Rule Details Does not allow the use of `// @ts-ignore` comments. diff --git a/packages/eslint-plugin/docs/rules/brace-style.md b/packages/eslint-plugin/docs/rules/brace-style.md index c8268dea44ee..06dfa1619fb2 100644 --- a/packages/eslint-plugin/docs/rules/brace-style.md +++ b/packages/eslint-plugin/docs/rules/brace-style.md @@ -3,11 +3,11 @@ ## Rule Details This rule extends the base [`eslint/brace-style`](https://eslint.org/docs/rules/brace-style) rule. -It supports all options and features of the base rule. +It adds support for `enum`, `interface`, `namespace` and `module` declarations. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "brace-style": "off", diff --git a/packages/eslint-plugin/docs/rules/camelcase.md b/packages/eslint-plugin/docs/rules/camelcase.md index f0b49d0420fa..89cd63aa9295 100644 --- a/packages/eslint-plugin/docs/rules/camelcase.md +++ b/packages/eslint-plugin/docs/rules/camelcase.md @@ -1,135 +1,43 @@ # Enforce camelCase naming convention (`camelcase`) -When it comes to naming variables, style guides generally fall into one of two -camps: camelCase (`variableName`) and underscores (`variable_name`). This rule -focuses on using the camelCase approach. If your style guide calls for -camelCasing your variable names, then this rule is for you! +## DEPRECATED -## Rule Details +This rule has been deprecated in favour of the [`naming-convention`](./naming-convention.md) rule. +It will be removed in a future version of this plugin. -This rule looks for any underscores (`_`) located within the source code. -It ignores leading and trailing underscores and only checks those in the middle -of a variable name. If ESLint decides that the variable is a constant -(all uppercase), then no warning will be thrown. Otherwise, a warning will be -thrown. This rule only flags definitions and assignments but not function calls. -In case of ES6 `import` statements, this rule only targets the name of the -variable that will be imported into the local module scope. +## Rule Details -**_This rule was taken from the ESLint core rule `camelcase`._** -**_Available options and test cases may vary depending on the version of ESLint installed in the system._** +This rule extends the base [`eslint/camelcase`](https://eslint.org/docs/rules/camelcase) rule. +It adds support for numerous TypeScript features. -## Options +## How to use -```cjson +```jsonc { - // note you must disable the base rule as it can report incorrect errors - "camelcase": "off", - "@typescript-eslint/camelcase": ["error", { "properties": "always" }] + // note you must disable the base rule as it can report incorrect errors + "camelcase": "off", + "@typescript-eslint/camelcase": ["error"] } ``` -This rule has an object option: - -- `"properties": "never"` (default) does not check property names -- `"properties": "always"` enforces camelCase style for property names -- `"genericType": "never"` (default) does not check generic identifiers -- `"genericType": "always"` enforces camelCase style for generic identifiers -- `"ignoreDestructuring": false` (default) enforces camelCase style for destructured identifiers -- `"ignoreDestructuring": true` does not check destructured identifiers -- `allow` (`string[]`) list of properties to accept. Accept regex. - -### properties: "always" - -Examples of **incorrect** code for this rule with the default `{ "properties": "always" }` option: - -```js -/*eslint @typescript-eslint/camelcase: "error"*/ - -import { no_camelcased } from 'external-module'; - -var my_favorite_color = '#112C85'; - -function do_something() { - // ... -} - -obj.do_something = function() { - // ... -}; +## Options -function foo({ no_camelcased }) { - // ... -} +See [`eslint/camelcase` options](https://eslint.org/docs/rules/camelcase#options). +This rule adds the following options: -function foo({ isCamelcased: no_camelcased }) { - // ... +```ts +interface Options extends BaseCamelcaseOptions { + genericType?: 'always' | 'never'; } -function foo({ no_camelcased = 'default value' }) { - // ... -} - -var obj = { - my_pref: 1, +const defaultOptions: Options = { + ...baseCamelcaseDefaultOptions, + genericType: 'never', }; - -var { category_id = 1 } = query; - -var { foo: no_camelcased } = bar; - -var { foo: bar_baz = 1 } = quz; -``` - -Examples of **correct** code for this rule with the default `{ "properties": "always" }` option: - -```js -/*eslint @typescript-eslint/camelcase: "error"*/ - -import { no_camelcased as camelCased } from 'external-module'; - -var myFavoriteColor = '#112C85'; -var _myFavoriteColor = '#112C85'; -var myFavoriteColor_ = '#112C85'; -var MY_FAVORITE_COLOR = '#112C85'; -var foo = bar.baz_boom; -var foo = { qux: bar.baz_boom }; - -obj.do_something(); -do_something(); -new do_something(); - -var { category_id: category } = query; - -function foo({ isCamelCased }) { - // ... -} - -function foo({ isCamelCased: isAlsoCamelCased }) { - // ... -} - -function foo({ isCamelCased = 'default value' }) { - // ... -} - -var { categoryId = 1 } = query; - -var { foo: isCamelCased } = bar; - -var { foo: isCamelCased = 1 } = quz; ``` -### `properties: "never"` - -Examples of **correct** code for this rule with the `{ "properties": "never" }` option: - -```js -/*eslint @typescript-eslint/camelcase: ["error", {properties: "never"}]*/ - -var obj = { - my_pref: 1, -}; -``` +- `"genericType": "never"` (default) does not check generic identifiers +- `"genericType": "always"` enforces camelCase style for generic identifiers ### `genericType: "always"` @@ -225,74 +133,4 @@ class Foo { } ``` -### `ignoreDestructuring: false` - -Examples of **incorrect** code for this rule with the default `{ "ignoreDestructuring": false }` option: - -```js -/*eslint @typescript-eslint/camelcase: "error"*/ - -var { category_id } = query; - -var { category_id = 1 } = query; - -var { category_id: category_id } = query; - -var { category_id: category_alias } = query; - -var { category_id: categoryId, ...other_props } = query; -``` - -### `ignoreDestructuring: true` - -Examples of **incorrect** code for this rule with the `{ "ignoreDestructuring": true }` option: - -```js -/*eslint @typescript-eslint/camelcase: ["error", {ignoreDestructuring: true}]*/ - -var { category_id: category_alias } = query; - -var { category_id, ...other_props } = query; -``` - -Examples of **correct** code for this rule with the `{ "ignoreDestructuring": true }` option: - -```js -/*eslint @typescript-eslint/camelcase: ["error", {ignoreDestructuring: true}]*/ - -var { category_id } = query; - -var { category_id = 1 } = query; - -var { category_id: category_id } = query; -``` - -## allow - -Examples of **correct** code for this rule with the `allow` option: - -```js -/*eslint @typescript-eslint/camelcase: ["error", {allow: ["UNSAFE_componentWillMount"]}]*/ - -function UNSAFE_componentWillMount() { - // ... -} -``` - -```js -/*eslint @typescript-eslint/camelcase: ["error", {allow: ["^UNSAFE_"]}]*/ - -function UNSAFE_componentWillMount() { - // ... -} - -function UNSAFE_componentWillMount() { - // ... -} -``` - -## When Not To Use It - -If you have established coding standards using a different naming convention (separating words with underscores), turn this rule off. - Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/camelcase.md) diff --git a/packages/eslint-plugin/docs/rules/class-literal-property-style.md b/packages/eslint-plugin/docs/rules/class-literal-property-style.md index 903a695dd76b..1bca8390fd3b 100644 --- a/packages/eslint-plugin/docs/rules/class-literal-property-style.md +++ b/packages/eslint-plugin/docs/rules/class-literal-property-style.md @@ -1,7 +1,7 @@ # Ensures that literals on classes are exposed in a consistent style (`class-literal-property-style`) When writing TypeScript applications, it's typically safe to store literal values on classes using fields with the `readonly` modifier to prevent them from being reassigned. -When writing TypeScript libraries that could be used by Javascript users however, it's typically safer to expose these literals using `getter`s, since the `readonly` modifier is enforced at compile type. +When writing TypeScript libraries that could be used by JavaScript users however, it's typically safer to expose these literals using `getter`s, since the `readonly` modifier is enforced at compile type. ## Rule Details @@ -11,7 +11,7 @@ By default this rule prefers the `fields` style as it means JS doesn't have to s Note that this rule only checks for constant _literal_ values (string, template string, number, bigint, boolean, regexp, null). It does not check objects or arrays, because a readonly field behaves differently to a getter in those cases. It also does not check functions, as it is a common pattern to use readonly fields with arrow function values as auto-bound methods. This is because these types can be mutated and carry with them more complex implications about their usage. -#### The `fields` style +### The `fields` style This style checks for any getter methods that return literal values, and requires them to be defined using fields with the `readonly` modifier instead. @@ -50,7 +50,7 @@ class Mx { } ``` -#### The `getters` style +### The `getters` style This style checks for any `readonly` fields that are assigned literal values, and requires them to be defined as getters instead. This style pairs well with the [`@typescript-eslint/prefer-readonly`](prefer-readonly.md) rule, diff --git a/packages/eslint-plugin/docs/rules/class-name-casing.md b/packages/eslint-plugin/docs/rules/class-name-casing.md index 38c30609747a..ae5d5da7a2e6 100644 --- a/packages/eslint-plugin/docs/rules/class-name-casing.md +++ b/packages/eslint-plugin/docs/rules/class-name-casing.md @@ -2,6 +2,11 @@ This rule enforces PascalCase names for classes and interfaces. +## DEPRECATED + +This rule has been deprecated in favour of the [`naming-convention`](./naming-convention.md) rule. +It will be removed in a future version of this plugin. + ## Rule Details This rule aims to make it easy to differentiate classes from regular variables at a glance. diff --git a/packages/eslint-plugin/docs/rules/comma-spacing.md b/packages/eslint-plugin/docs/rules/comma-spacing.md index 145e3607726c..0920180416ad 100644 --- a/packages/eslint-plugin/docs/rules/comma-spacing.md +++ b/packages/eslint-plugin/docs/rules/comma-spacing.md @@ -7,7 +7,7 @@ It adds support for trailing comma in a types parameters list. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "comma-spacing": "off", diff --git a/packages/eslint-plugin/docs/rules/consistent-type-assertions.md b/packages/eslint-plugin/docs/rules/consistent-type-assertions.md index cdf0fb7656cb..43e67b755b52 100644 --- a/packages/eslint-plugin/docs/rules/consistent-type-assertions.md +++ b/packages/eslint-plugin/docs/rules/consistent-type-assertions.md @@ -8,6 +8,8 @@ Type assertions are also commonly referred as "type casting" in TypeScript (even In addition to ensuring that type assertions are written in a consistent way, this rule also helps make your codebase more type-safe. +`const` assertions, [introduced in TypeScript 3.4](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions), is always allowed by this rule. Examples of it include `let x = "hello" as const;` and `let x = "hello";`. + ## Options ```ts diff --git a/packages/eslint-plugin/docs/rules/default-param-last.md b/packages/eslint-plugin/docs/rules/default-param-last.md index f3eb9f27b9a1..c9c51df40a36 100644 --- a/packages/eslint-plugin/docs/rules/default-param-last.md +++ b/packages/eslint-plugin/docs/rules/default-param-last.md @@ -2,7 +2,8 @@ ## Rule Details -This rule enforces default or optional parameters to be the last of parameters. +This rule extends the base [`eslint/default-param-last`](https://eslint.org/docs/rules/default-param-last) rule. +It adds support for optional parameters. Examples of **incorrect** code for this rule: @@ -38,4 +39,18 @@ class Foo { } ``` +## How to use + +```jsonc +{ + // note you must disable the base rule as it can report incorrect errors + "default-param-last": "off", + "@typescript-eslint/default-param-last": ["error"] +} +``` + +## Options + +See [`eslint/default-param-last` options](https://eslint.org/docs/rules/default-param-last#options). + Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/default-param-last.md) diff --git a/packages/eslint-plugin/docs/rules/explicit-function-return-type.md b/packages/eslint-plugin/docs/rules/explicit-function-return-type.md index 360fdce01e65..aa94a29a0ef3 100644 --- a/packages/eslint-plugin/docs/rules/explicit-function-return-type.md +++ b/packages/eslint-plugin/docs/rules/explicit-function-return-type.md @@ -69,6 +69,8 @@ type Options = { allowTypedFunctionExpressions?: boolean; // if true, functions immediately returning another function expression will not be checked allowHigherOrderFunctions?: boolean; + // if true, concise arrow functions that start with the void keyword will not be checked + allowConciseArrowFunctionExpressionStartingWithVoid?: boolean; }; const defaults = { @@ -198,6 +200,24 @@ function fn() { } ``` +### `allowConciseArrowFunctionExpressionsStartingWithVoid` + +Examples of **incorrect** code for this rule with `{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }`: + +```ts +var join = (a: string, b: string) => `${a}${b}`; + +const log = (message: string) => { + console.log(message); +}; +``` + +Examples of **correct** code for this rule with `{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }`: + +```ts +var log = (message: string) => void console.log(message); +``` + ## When Not To Use It If you don't wish to prevent calling code from using function return values in unexpected ways, then diff --git a/packages/eslint-plugin/docs/rules/explicit-module-boundary-types.md b/packages/eslint-plugin/docs/rules/explicit-module-boundary-types.md index a5327a1e547d..3c077a75c881 100644 --- a/packages/eslint-plugin/docs/rules/explicit-module-boundary-types.md +++ b/packages/eslint-plugin/docs/rules/explicit-module-boundary-types.md @@ -86,12 +86,17 @@ type Options = { * An array of function/method names that will not have their arguments or their return values checked. */ allowedNames?: string[]; + /** + * If true, track references to exported variables as well as direct exports. + */ + shouldTrackReferences?: boolean; }; const defaults = { allowTypedFunctionExpressions: true, allowHigherOrderFunctions: true, allowedNames: [], + shouldTrackReferences: true, }; ``` @@ -238,6 +243,28 @@ You may pass function/method names you would like this rule to ignore, like so: } ``` +### `shouldTrackReferences` + +Examples of **incorrect** code for this rule with `{ shouldTrackReferences: true }`: + +```ts +function foo(bar) { + return bar; +} + +export default foo; +``` + +Examples of **correct** code for this rule with `{ shouldTrackReferences: true }`: + +```ts +function foo(bar: string): string { + return bar; +} + +export default foo; +``` + ## When Not To Use It If you wish to make sure all functions have explicit return types, as opposed to only the module boundaries, you can use [explicit-function-return-type](https://github.com/eslint/eslint/blob/master/docs/rules/explicit-function-return-type.md) diff --git a/packages/eslint-plugin/docs/rules/func-call-spacing.md b/packages/eslint-plugin/docs/rules/func-call-spacing.md index aa1d3fde96ad..8aa9e7e0cbff 100644 --- a/packages/eslint-plugin/docs/rules/func-call-spacing.md +++ b/packages/eslint-plugin/docs/rules/func-call-spacing.md @@ -1,17 +1,13 @@ # Require or disallow spacing between function identifiers and their invocations (`func-call-spacing`) -When calling a function, developers may insert optional whitespace between the function’s name and the parentheses that invoke it. -This rule requires or disallows spaces between the function name and the opening parenthesis that calls it. - ## Rule Details This rule extends the base [`eslint/func-call-spacing`](https://eslint.org/docs/rules/func-call-spacing) rule. -It supports all options and features of the base rule. -This version adds support for generic type parameters on function calls. +It adds support for generic type parameters on function calls. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "func-call-spacing": "off", diff --git a/packages/eslint-plugin/docs/rules/generic-type-naming.md b/packages/eslint-plugin/docs/rules/generic-type-naming.md index 185b3811d9a8..dc9642735359 100644 --- a/packages/eslint-plugin/docs/rules/generic-type-naming.md +++ b/packages/eslint-plugin/docs/rules/generic-type-naming.md @@ -3,6 +3,11 @@ It can be helpful to enforce a consistent naming style for generic type variables used within a type. For example, prefixing them with `T` and ensuring a somewhat descriptive name, or enforcing Hungarian notation. +## DEPRECATED + +This rule has been deprecated in favour of the [`naming-convention`](./naming-convention.md) rule. +It will be removed in a future version of this plugin. + ## Rule Details This rule allows you to enforce conventions over type variables. By default, it does nothing. @@ -13,7 +18,7 @@ The rule takes a single string option, which is a regular expression that type v Examples of **correct** code with a configuration of `'^T[A-Z][a-zA-Z]+$'`: -```typescript +```ts type ReadOnly = { readonly [TKey in keyof TType]: TType[TKey]; }; @@ -25,7 +30,7 @@ interface SimpleMap { Examples of **incorrect** code with a configuration of `'^T[A-Z][a-zA-Z]+$'`: -```typescript +```ts type ReadOnly = { readonly [Key in keyof T]: T[Key] }; interface SimpleMap { diff --git a/packages/eslint-plugin/docs/rules/indent.md b/packages/eslint-plugin/docs/rules/indent.md index 4636cfeaeb56..023c774657ae 100644 --- a/packages/eslint-plugin/docs/rules/indent.md +++ b/packages/eslint-plugin/docs/rules/indent.md @@ -1,713 +1,24 @@ # Enforce consistent indentation (`indent`) -There are several common guidelines which require specific indentation of nested blocks and statements, like: - -```js -function hello(indentSize, type) { - if (indentSize === 4 && type !== 'tab') { - console.log('Each next indentation will increase on 4 spaces'); - } -} -``` - -These are the most common scenarios recommended in different style guides: - -- Two spaces, not longer and no tabs: Google, npm, NodeJS, Idiomatic, Felix -- Tabs: jQuery -- Four spaces: Crockford +## PLEASE READ THIS ISSUE BEFORE USING THIS RULE [#1824](https://github.com/typescript-eslint/typescript-eslint/issues/1824) ## Rule Details -This rule enforces a consistent indentation style. The default style is `4 spaces`. - -## Options - -This rule has a mixed option: +This rule extends the base [`eslint/indent`](https://eslint.org/docs/rules/indent) rule. +It adds support for TypeScript nodes. -For example, for 2-space indentation: +## How to use -```cjson +```jsonc { - // note you must disable the base rule as it can report incorrect errors - "indent": "off", - "@typescript-eslint/indent": ["error", 2] + // note you must disable the base rule as it can report incorrect errors + "indent": "off", + "@typescript-eslint/indent": ["error"] } ``` -Or for tabbed indentation: - -```cjson -{ - // note you must disable the base rule as it can report incorrect errors - "indent": "off", - "@typescript-eslint/indent": ["error", "tab"] -} -``` - -Examples of **incorrect** code for this rule with the default options: - - -```js -/*eslint @typescript-eslint/indent: "error"*/ - -if (a) { - b=c; - function foo(d) { - e=f; - } -} -``` - -Examples of **correct** code for this rule with the default options: - - -```js -/*eslint @typescript-eslint/indent: "error"*/ - -if (a) { - b=c; - function foo(d) { - e=f; - } -} -``` - -This rule has an object option: - -- `"SwitchCase"` (default: 0) enforces indentation level for `case` clauses in `switch` statements -- `"VariableDeclarator"` (default: 1) enforces indentation level for `var` declarators; can also take an object to define separate rules for `var`, `let` and `const` declarations. -- `"outerIIFEBody"` (default: 1) enforces indentation level for file-level IIFEs. -- `"MemberExpression"` (default: 1) enforces indentation level for multi-line property chains. This can also be set to `"off"` to disable checking for `MemberExpression` indentation. -- `"FunctionDeclaration"` takes an object to define rules for function declarations. - - `parameters` (default: 1) enforces indentation level for parameters in a function declaration. This can either be a number indicating indentation level, or the string `"first"` indicating that all parameters of the declaration must be aligned with the first parameter. This can also be set to `"off"` to disable checking for `FunctionDeclaration` parameters. - - `body` (default: 1) enforces indentation level for the body of a function declaration. -- `"FunctionExpression"` takes an object to define rules for function expressions. - - `parameters` (default: 1) enforces indentation level for parameters in a function expression. This can either be a number indicating indentation level, or the string `"first"` indicating that all parameters of the expression must be aligned with the first parameter. This can also be set to `"off"` to disable checking for `FunctionExpression` parameters. - - `body` (default: 1) enforces indentation level for the body of a function expression. -- `"CallExpression"` takes an object to define rules for function call expressions. - - `arguments` (default: 1) enforces indentation level for arguments in a call expression. This can either be a number indicating indentation level, or the string `"first"` indicating that all arguments of the expression must be aligned with the first argument. This can also be set to `"off"` to disable checking for `CallExpression` arguments. -- `"ArrayExpression"` (default: 1) enforces indentation level for elements in arrays. It can also be set to the string `"first"`, indicating that all the elements in the array should be aligned with the first element. This can also be set to `"off"` to disable checking for array elements. -- `"ObjectExpression"` (default: 1) enforces indentation level for properties in objects. It can be set to the string `"first"`, indicating that all properties in the object should be aligned with the first property. This can also be set to `"off"` to disable checking for object properties. -- `"ImportDeclaration"` (default: 1) enforces indentation level for import statements. It can be set to the string `"first"`, indicating that all imported members from a module should be aligned with the first member in the list. This can also be set to `"off"` to disable checking for imported module members. -- `"flatTernaryExpressions": true` (`false` by default) requires no indentation for ternary expressions which are nested in other ternary expressions. -- `"ignoredNodes"` accepts an array of [selectors](https://eslint.org/docs/developer-guide/selectors). If an AST node is matched by any of the selectors, the indentation of tokens which are direct children of that node will be ignored. This can be used as an escape hatch to relax the rule if you disagree with the indentation that it enforces for a particular syntactic pattern. -- `"ignoreComments"` (default: false) can be used when comments do not need to be aligned with nodes on the previous or next line. - -Level of indentation denotes the multiple of the indent specified. Example: - -- Indent of 4 spaces with `VariableDeclarator` set to `2` will indent the multi-line variable declarations with 8 spaces. -- Indent of 2 spaces with `VariableDeclarator` set to `2` will indent the multi-line variable declarations with 4 spaces. -- Indent of 2 spaces with `VariableDeclarator` set to `{"var": 2, "let": 2, "const": 3}` will indent the multi-line variable declarations with 4 spaces for `var` and `let`, 6 spaces for `const` statements. -- Indent of tab with `VariableDeclarator` set to `2` will indent the multi-line variable declarations with 2 tabs. -- Indent of 2 spaces with `SwitchCase` set to `0` will not indent `case` clauses with respect to `switch` statements. -- Indent of 2 spaces with `SwitchCase` set to `1` will indent `case` clauses with 2 spaces with respect to `switch` statements. -- Indent of 2 spaces with `SwitchCase` set to `2` will indent `case` clauses with 4 spaces with respect to `switch` statements. -- Indent of tab with `SwitchCase` set to `2` will indent `case` clauses with 2 tabs with respect to `switch` statements. -- Indent of 2 spaces with `MemberExpression` set to `0` will indent the multi-line property chains with 0 spaces. -- Indent of 2 spaces with `MemberExpression` set to `1` will indent the multi-line property chains with 2 spaces. -- Indent of 2 spaces with `MemberExpression` set to `2` will indent the multi-line property chains with 4 spaces. -- Indent of 4 spaces with `MemberExpression` set to `0` will indent the multi-line property chains with 0 spaces. -- Indent of 4 spaces with `MemberExpression` set to `1` will indent the multi-line property chains with 4 spaces. -- Indent of 4 spaces with `MemberExpression` set to `2` will indent the multi-line property chains with 8 spaces. - -### tab - -Examples of **incorrect** code for this rule with the `"tab"` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", "tab"]*/ - -if (a) { - b=c; -function foo(d) { - e=f; - } -} -``` - -Examples of **correct** code for this rule with the `"tab"` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", "tab"]*/ - -if (a) { -/*tab*/b=c; -/*tab*/function foo(d) { -/*tab*//*tab*/e=f; -/*tab*/} -} -``` - -### `SwitchCase` - -Examples of **incorrect** code for this rule with the `2, { "SwitchCase": 1 }` options: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "SwitchCase": 1 }]*/ - -switch(a){ -case "a": - break; -case "b": - break; -} -``` - -Examples of **correct** code for this rule with the `2, { "SwitchCase": 1 }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "SwitchCase": 1 }]*/ - -switch(a){ - case "a": - break; - case "b": - break; -} -``` - -### `VariableDeclarator` - -Examples of **incorrect** code for this rule with the `2, { "VariableDeclarator": 1 }` options: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "VariableDeclarator": 1 }]*/ -/*eslint-env es6*/ - -var a, - b, - c; -let a, - b, - c; -const a = 1, - b = 2, - c = 3; -``` - -Examples of **correct** code for this rule with the `2, { "VariableDeclarator": 1 }` options: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "VariableDeclarator": 1 }]*/ -/*eslint-env es6*/ - -var a, - b, - c; -let a, - b, - c; -const a = 1, - b = 2, - c = 3; -``` - -Examples of **correct** code for this rule with the `2, { "VariableDeclarator": 2 }` options: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "VariableDeclarator": 2 }]*/ -/*eslint-env es6*/ - -var a, - b, - c; -let a, - b, - c; -const a = 1, - b = 2, - c = 3; -``` - -Examples of **correct** code for this rule with the `2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } }` options: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } }]*/ -/*eslint-env es6*/ - -var a, - b, - c; -let a, - b, - c; -const a = 1, - b = 2, - c = 3; -``` - -### `outerIIFEBody` - -Examples of **incorrect** code for this rule with the options `2, { "outerIIFEBody": 0 }`: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "outerIIFEBody": 0 }]*/ - -(function() { - - function foo(x) { - return x + 1; - } - -})(); - - -if(y) { -console.log('foo'); -} -``` - -Examples of **correct** code for this rule with the options `2, {"outerIIFEBody": 0}`: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "outerIIFEBody": 0 }]*/ - -(function() { - -function foo(x) { - return x + 1; -} - -})(); - - -if(y) { - console.log('foo'); -} -``` - -### `MemberExpression` - -Examples of **incorrect** code for this rule with the `2, { "MemberExpression": 1 }` options: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "MemberExpression": 1 }]*/ - -foo -.bar -.baz() -``` - -Examples of **correct** code for this rule with the `2, { "MemberExpression": 1 }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "MemberExpression": 1 }]*/ - -foo - .bar - .baz(); -``` - -### `FunctionDeclaration` - -Examples of **incorrect** code for this rule with the `2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/ - -function foo(bar, - baz, - qux) { - qux(); -} -``` - -Examples of **correct** code for this rule with the `2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/ - -function foo(bar, - baz, - qux) { - qux(); -} -``` - -Examples of **incorrect** code for this rule with the `2, { "FunctionDeclaration": {"parameters": "first"} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/ - -function foo(bar, baz, - qux, boop) { - qux(); -} -``` - -Examples of **correct** code for this rule with the `2, { "FunctionDeclaration": {"parameters": "first"} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/ - -function foo(bar, baz, - qux, boop) { - qux(); -} -``` - -### `FunctionExpression` - -Examples of **incorrect** code for this rule with the `2, { "FunctionExpression": {"body": 1, "parameters": 2} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/ - -var foo = function(bar, - baz, - qux) { - qux(); -} -``` - -Examples of **correct** code for this rule with the `2, { "FunctionExpression": {"body": 1, "parameters": 2} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/ - -var foo = function(bar, - baz, - qux) { - qux(); -} -``` - -Examples of **incorrect** code for this rule with the `2, { "FunctionExpression": {"parameters": "first"} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/ - -var foo = function(bar, baz, - qux, boop) { - qux(); -} -``` - -Examples of **correct** code for this rule with the `2, { "FunctionExpression": {"parameters": "first"} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/ - -var foo = function(bar, baz, - qux, boop) { - qux(); -} -``` - -### `CallExpression` - -Examples of **incorrect** code for this rule with the `2, { "CallExpression": {"arguments": 1} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/ - -foo(bar, - baz, - qux -); -``` - -Examples of **correct** code for this rule with the `2, { "CallExpression": {"arguments": 1} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/ - -foo(bar, - baz, - qux -); -``` - -Examples of **incorrect** code for this rule with the `2, { "CallExpression": {"arguments": "first"} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/ - -foo(bar, baz, - baz, boop, beep); -``` - -Examples of **correct** code for this rule with the `2, { "CallExpression": {"arguments": "first"} }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/ - -foo(bar, baz, - baz, boop, beep); -``` - -### `ArrayExpression` - -Examples of **incorrect** code for this rule with the `2, { "ArrayExpression": 1 }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "ArrayExpression": 1 }]*/ - -var foo = [ - bar, -baz, - qux -]; -``` - -Examples of **correct** code for this rule with the `2, { "ArrayExpression": 1 }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "ArrayExpression": 1 }]*/ - -var foo = [ - bar, - baz, - qux -]; -``` - -Examples of **incorrect** code for this rule with the `2, { "ArrayExpression": "first" }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"ArrayExpression": "first"}]*/ - -var foo = [bar, - baz, - qux -]; -``` - -Examples of **correct** code for this rule with the `2, { "ArrayExpression": "first" }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"ArrayExpression": "first"}]*/ - -var foo = [bar, - baz, - qux -]; -``` - -### `ObjectExpression` - -Examples of **incorrect** code for this rule with the `2, { "ObjectExpression": 1 }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "ObjectExpression": 1 }]*/ - -var foo = { - bar: 1, -baz: 2, - qux: 3 -}; -``` - -Examples of **correct** code for this rule with the `2, { "ObjectExpression": 1 }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, { "ObjectExpression": 1 }]*/ - -var foo = { - bar: 1, - baz: 2, - qux: 3 -}; -``` - -Examples of **incorrect** code for this rule with the `2, { "ObjectExpression": "first" }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"ObjectExpression": "first"}]*/ - -var foo = { bar: 1, - baz: 2 }; -``` - -Examples of **correct** code for this rule with the `2, { "ObjectExpression": "first" }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 2, {"ObjectExpression": "first"}]*/ - -var foo = { bar: 1, - baz: 2 }; -``` - -### `ImportDeclaration` - -Examples of **correct** code for this rule with the `4, { "ImportDeclaration": 1 }` option (the default): - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { ImportDeclaration: 1 }]*/ - -import { foo, - bar, - baz, -} from 'qux'; - -import { - foo, - bar, - baz, -} from 'qux'; -``` - -Examples of **incorrect** code for this rule with the `4, { ImportDeclaration: "first" }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { ImportDeclaration: "first" }]*/ - -import { foo, - bar, - baz, -} from 'qux'; -``` - -Examples of **correct** code for this rule with the `4, { ImportDeclaration: "first" }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { ImportDeclaration: "first" }]*/ - -import { foo, - bar, - baz, -} from 'qux'; -``` - -### `flatTernaryExpressions` - -Examples of **incorrect** code for this rule with the default `4, { "flatTernaryExpressions": false }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { "flatTernaryExpressions": false }]*/ - -var a = - foo ? bar : - baz ? qux : - boop; -``` - -Examples of **correct** code for this rule with the default `4, { "flatTernaryExpressions": false }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { "flatTernaryExpressions": false }]*/ - -var a = - foo ? bar : - baz ? qux : - boop; -``` - -Examples of **incorrect** code for this rule with the `4, { "flatTernaryExpressions": true }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { "flatTernaryExpressions": true }]*/ - -var a = - foo ? bar : - baz ? qux : - boop; -``` - -Examples of **correct** code for this rule with the `4, { "flatTernaryExpressions": true }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { "flatTernaryExpressions": true }]*/ - -var a = - foo ? bar : - baz ? qux : - boop; -``` - -### `ignoredNodes` - -The following configuration ignores the indentation of `ConditionalExpression` ("ternary expression") nodes: - -Examples of **correct** code for this rule with the `4, { "ignoredNodes": ["ConditionalExpression"] }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { "ignoredNodes": ["ConditionalExpression"] }]*/ - -var a = foo - ? bar - : baz; - -var a = foo - ? bar -: baz; -``` - -The following configuration ignores indentation in the body of IIFEs. - -Examples of **correct** code for this rule with the `4, { "ignoredNodes": ["CallExpression > FunctionExpression.callee > BlockStatement.body"] }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { "ignoredNodes": ["CallExpression > FunctionExpression.callee > BlockStatement.body"] }]*/ - -(function() { - -foo(); -bar(); - -}) -``` - -### `ignoreComments` - -Examples of additional **correct** code for this rule with the `4, { "ignoreComments": true }` option: - - -```js -/*eslint @typescript-eslint/indent: ["error", 4, { "ignoreComments": true }] */ - -if (foo) { - doSomething(); - -// comment intentionally de-indented - doSomethingElse(); -} -``` - -## Compatibility +## Options -- **JSHint**: `indent` -- **JSCS**: [`validateIndentation`](https://jscs-dev.github.io/rule/validateIndentation) +See [`eslint/indent` options](https://eslint.org/docs/rules/indent#options). Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/indent.md) diff --git a/packages/eslint-plugin/docs/rules/interface-name-prefix.md b/packages/eslint-plugin/docs/rules/interface-name-prefix.md index f6439b490fd1..6322c9c79d65 100644 --- a/packages/eslint-plugin/docs/rules/interface-name-prefix.md +++ b/packages/eslint-plugin/docs/rules/interface-name-prefix.md @@ -5,6 +5,11 @@ The unprefixed name is then available for a class that provides a standard imple Alternatively, the contributor guidelines for the TypeScript repo suggest [never prefixing](https://github.com/Microsoft/TypeScript/wiki/Coding-guidelines#names) interfaces with `I`. +## DEPRECATED + +This rule has been deprecated in favour of the [`naming-convention`](./naming-convention.md) rule. +It will be removed in a future version of this plugin. + ## Rule Details This rule enforces whether or not the `I` prefix is required for interface names. diff --git a/packages/eslint-plugin/docs/rules/member-naming.md b/packages/eslint-plugin/docs/rules/member-naming.md index e12f4f239b56..0dd8a5a2f29c 100644 --- a/packages/eslint-plugin/docs/rules/member-naming.md +++ b/packages/eslint-plugin/docs/rules/member-naming.md @@ -2,6 +2,11 @@ It can be helpful to enforce naming conventions for `private` (and sometimes `protected`) members of an object. For example, prefixing private properties with a `_` allows them to be easily discerned when being inspected by tools that do not have knowledge of TypeScript (such as most debuggers). +## DEPRECATED + +This rule has been deprecated in favour of the [`naming-convention`](./naming-convention.md) rule. +It will be removed in a future version of this plugin. + ## Rule Details This rule allows you to enforce conventions for class property and method names by their visibility. By default, it enforces nothing. diff --git a/packages/eslint-plugin/docs/rules/member-ordering.md b/packages/eslint-plugin/docs/rules/member-ordering.md index cccf2bbbe0ab..9a2a4cdee8f6 100644 --- a/packages/eslint-plugin/docs/rules/member-ordering.md +++ b/packages/eslint-plugin/docs/rules/member-ordering.md @@ -53,37 +53,37 @@ Note: There is a deprecated syntax to specify the member types as an array. There are multiple ways to specify the member types. The most explicit and granular form is the following: -```json5 +```jsonc [ // Index signature - 'signature', + "signature", // Fields - 'public-static-field', - 'protected-static-field', - 'private-static-field', - 'public-instance-field', - 'protected-instance-field', - 'private-instance-field', - 'public-abstract-field', - 'protected-abstract-field', - 'private-abstract-field', + "public-static-field", + "protected-static-field", + "private-static-field", + "public-instance-field", + "protected-instance-field", + "private-instance-field", + "public-abstract-field", + "protected-abstract-field", + "private-abstract-field", // Constructors - 'public-constructor', - 'protected-constructor', - 'private-constructor', + "public-constructor", + "protected-constructor", + "private-constructor", // Methods - 'public-static-method', - 'protected-static-method', - 'private-static-method', - 'public-instance-method', - 'protected-instance-method', - 'private-instance-method', - 'public-abstract-method', - 'protected-abstract-method', - 'private-abstract-method', + "public-static-method", + "protected-static-method", + "private-static-method", + "public-instance-method", + "protected-instance-method", + "private-instance-method", + "public-abstract-method", + "protected-abstract-method", + "private-abstract-method" ] ``` @@ -93,23 +93,23 @@ Note: If you only specify some of the possible types, the non-specified ones can It is also possible to group member types by their accessibility (`static`, `instance`, `abstract`), ignoring their scope. -```json5 +```jsonc [ // Index signature // No accessibility for index signature. See above. // Fields - 'public-field', // = ['public-static-field', 'public-instance-field']) - 'protected-field', // = ['protected-static-field', 'protected-instance-field']) - 'private-field', // = ['private-static-field', 'private-instance-field']) + "public-field", // = ["public-static-field", "public-instance-field"]) + "protected-field", // = ["protected-static-field", "protected-instance-field"]) + "private-field", // = ["private-static-field", "private-instance-field"]) // Constructors // Only the accessibility of constructors is configurable. See below. // Methods - 'public-method', // = ['public-static-method', 'public-instance-method']) - 'protected-method', // = ['protected-static-method', 'protected-instance-method']) - 'private-method', // = ['private-static-method', 'private-instance-method']) + "public-method", // = ["public-static-method", "public-instance-method"]) + "protected-method", // = ["protected-static-method", "protected-instance-method"]) + "private-method" // = ["private-static-method", "private-instance-method"]) ] ``` @@ -117,23 +117,23 @@ It is also possible to group member types by their accessibility (`static`, `ins Another option is to group the member types by their scope (`public`, `protected`, `private`), ignoring their accessibility. -```json5 +```jsonc [ // Index signature // No scope for index signature. See above. // Fields - 'static-field', // = ['public-static-field', 'protected-static-field', 'private-static-field']) - 'instance-field', // = ['public-instance-field', 'protected-instance-field', 'private-instance-field']) - 'abstract-field', // = ['public-abstract-field', 'protected-abstract-field', 'private-abstract-field']) + "static-field", // = ["public-static-field", "protected-static-field", "private-static-field"]) + "instance-field", // = ["public-instance-field", "protected-instance-field", "private-instance-field"]) + "abstract-field", // = ["public-abstract-field", "protected-abstract-field", "private-abstract-field"]) // Constructors - 'constructor', // = ['public-constructor', 'protected-constructor', 'private-constructor']) + "constructor", // = ["public-constructor", "protected-constructor", "private-constructor"]) // Methods - 'static-method', // = ['public-static-method', 'protected-static-method', 'private-static-method']) - 'instance-method', // = ['public-instance-method', 'protected-instance-method', 'private-instance-method']) - 'abstract-method', // = ['public-abstract-method', 'protected-abstract-method', 'private-abstract-method']) + "static-method", // = ["public-static-method", "protected-static-method", "private-static-method"]) + "instance-method", // = ["public-instance-method", "protected-instance-method", "private-instance-method"]) + "abstract-method" // = ["public-abstract-method", "protected-abstract-method", "private-abstract-method"]) ] ``` @@ -141,21 +141,21 @@ Another option is to group the member types by their scope (`public`, `protected The third grouping option is to ignore both scope and accessibility. -```json5 +```jsonc [ // Index signature // No grouping for index signature. See above. // Fields - 'field', // = ['public-static-field', 'protected-static-field', 'private-static-field', 'public-instance-field', 'protected-instance-field', 'private-instance-field', - // 'public-abstract-field', 'protected-abstract-field', private-abstract-field']) + "field", // = ["public-static-field", "protected-static-field", "private-static-field", "public-instance-field", "protected-instance-field", "private-instance-field", + // "public-abstract-field", "protected-abstract-field", private-abstract-field"]) // Constructors // Only the accessibility of constructors is configurable. See above. // Methods - 'method', // = ['public-static-method', 'protected-static-method', 'private-static-method', 'public-instance-method', 'protected-instance-method', 'private-instance-method', - // 'public-abstract-method', 'protected-abstract-method', 'private-abstract-method']) + "method" // = ["public-static-method", "protected-static-method", "private-static-method", "public-instance-method", "protected-instance-method", "private-instance-method", + // "public-abstract-method", "protected-abstract-method", "private-abstract-method"]) ] ``` @@ -163,65 +163,65 @@ The third grouping option is to ignore both scope and accessibility. The default configuration looks as follows: -```json5 +```jsonc { - default: [ + "default": [ // Index signature - 'signature', + "signature", // Fields - 'public-static-field', - 'protected-static-field', - 'private-static-field', + "public-static-field", + "protected-static-field", + "private-static-field", - 'public-instance-field', - 'protected-instance-field', - 'private-instance-field', + "public-instance-field", + "protected-instance-field", + "private-instance-field", - 'public-abstract-field', - 'protected-abstract-field', - 'private-abstract-field', + "public-abstract-field", + "protected-abstract-field", + "private-abstract-field", - 'public-field', - 'protected-field', - 'private-field', + "public-field", + "protected-field", + "private-field", - 'static-field', - 'instance-field', - 'abstract-field', + "static-field", + "instance-field", + "abstract-field", - 'field', + "field", // Constructors - 'public-constructor', - 'protected-constructor', - 'private-constructor', + "public-constructor", + "protected-constructor", + "private-constructor", - 'constructor', + "constructor", // Methods - 'public-static-method', - 'protected-static-method', - 'private-static-method', + "public-static-method", + "protected-static-method", + "private-static-method", - 'public-instance-method', - 'protected-instance-method', - 'private-instance-method', + "public-instance-method", + "protected-instance-method", + "private-instance-method", - 'public-abstract-method', - 'protected-abstract-method', - 'private-abstract-method', + "public-abstract-method", + "protected-abstract-method", + "private-abstract-method", - 'public-method', - 'protected-method', - 'private-method', + "public-method", + "protected-method", + "private-method", - 'static-method', - 'instance-method', - 'abstract-method', + "static-method", + "instance-method", + "abstract-method", - 'method', - ], + "method" + ] } ``` @@ -749,7 +749,7 @@ type Foo = { It is possible to sort all members within a group alphabetically. -#### Configuration: `{ default: { memberTypes: , order: 'alphabetically' } }` +#### Configuration: `{ default: { memberTypes: , order: "alphabetically" } }` This will apply the default order (see above) and enforce an alphabetic order within each group. @@ -795,7 +795,7 @@ interface Foo { It is also possible to sort all members and ignore the member groups completely. -#### Configuration: `{ default: { memberTypes: 'never', order: 'alphabetically' } }` +#### Configuration: `{ default: { memberTypes: "never", order: "alphabetically" } }` ##### Incorrect example diff --git a/packages/eslint-plugin/docs/rules/no-array-constructor.md b/packages/eslint-plugin/docs/rules/no-array-constructor.md index 3ab59cbc6ffa..fb9a68e7429f 100644 --- a/packages/eslint-plugin/docs/rules/no-array-constructor.md +++ b/packages/eslint-plugin/docs/rules/no-array-constructor.md @@ -1,10 +1,9 @@ # Disallow generic `Array` constructors (`no-array-constructor`) -Use of the `Array` constructor to construct a new array is generally discouraged in favor of array literal notation because of the single-argument pitfall and because the `Array` global may be redefined. Two exceptions are when the Array constructor is used to intentionally create sparse arrays of a specified size by giving the constructor a single numeric argument, or when using TypeScript type parameters to specify the type of the items of the array (`new Array()`). - ## Rule Details -This rule disallows `Array` constructors. +This rule extends the base [`eslint/no-array-constructor`](https://eslint.org/docs/rules/no-array-constructor) rule. +It adds support for the generically typed `Array` constructor (`new Array()`). Examples of **incorrect** code for this rule: @@ -27,8 +26,18 @@ Array(500); new Array(someOtherArray.length); ``` -## When Not To Use It +## How to use + +```jsonc +{ + // note you must disable the base rule as it can report incorrect errors + "no-array-constructor": "off", + "@typescript-eslint/no-array-constructor": ["error"] +} +``` + +## Options -This rule enforces a nearly universal stylistic concern. That being said, this rule may be disabled if the constructor style is preferred. +See [`eslint/no-array-constructor` options](https://eslint.org/docs/rules/no-array-constructor#options). -Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/7685fed33b15763ee3cf7dbe1facfc5ba85173f3/docs/rules/no-array-constructor.md) +Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-array-constructor.md) diff --git a/packages/eslint-plugin/docs/rules/no-base-to-string.md b/packages/eslint-plugin/docs/rules/no-base-to-string.md index 4e73eb6339ad..5c476b51303d 100644 --- a/packages/eslint-plugin/docs/rules/no-base-to-string.md +++ b/packages/eslint-plugin/docs/rules/no-base-to-string.md @@ -1,6 +1,6 @@ # Requires that `.toString()` is only called on objects which provide useful information when stringified (`no-base-to-string`) -JavaScript will call `toString()` on an object when it is converted to a string, such as when `+` adding to a string or in `${}` template literals. +JavaScript will call `toString()` on an object when it is converted to a string, such as when `+` adding to a string or in `${}` template literals. The default Object `.toString()` returns `"[object Object]"`, so this rule requires stringified objects define a more useful `.toString()` method. @@ -52,6 +52,32 @@ const literalWithToString = { `Value: ${literalWithToString}`; ``` +## Options + +The rule accepts an options object with the following properties: + +```ts +type Options = { + // if true, interpolated expressions in tagged templates will not be checked + ignoreTaggedTemplateExpressions?: boolean; +}; + +const defaults = { + ignoreTaggedTemplateExpressions: false, +}; +``` + +### `ignoreTaggedTemplateExpressions` + +This allows to skip checking tagged templates, for cases where the tags do not necessarily stringify interpolated values. + +Examples of additional **correct** code for this rule with `{ ignoreTaggedTemplateExpressions: true }`: + +```ts +function tag() {} +tag`${{}}`; +``` + ## When Not To Use It If you don't mind `"[object Object]"` in your strings, then you will not need this rule. diff --git a/packages/eslint-plugin/docs/rules/no-dupe-class-members.md b/packages/eslint-plugin/docs/rules/no-dupe-class-members.md index d0b3b57d988a..ddfc1b9f1bd8 100644 --- a/packages/eslint-plugin/docs/rules/no-dupe-class-members.md +++ b/packages/eslint-plugin/docs/rules/no-dupe-class-members.md @@ -7,7 +7,7 @@ It adds support for TypeScript's method overload definitions. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "no-dupe-class-members": "off", @@ -15,4 +15,8 @@ It adds support for TypeScript's method overload definitions. } ``` +## Options + +See [`eslint/no-dupe-class-members` options](https://eslint.org/docs/rules/no-dupe-class-members#options). + Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-dupe-class-members.md) diff --git a/packages/eslint-plugin/docs/rules/no-empty-function.md b/packages/eslint-plugin/docs/rules/no-empty-function.md index 17628cb93c8b..df6a3f825836 100644 --- a/packages/eslint-plugin/docs/rules/no-empty-function.md +++ b/packages/eslint-plugin/docs/rules/no-empty-function.md @@ -1,80 +1,24 @@ # Disallow empty functions (`no-empty-function`) -Empty functions can reduce readability because readers need to guess whether it’s intentional or not. So writing a clear comment for empty functions is a good practice. - ## Rule Details -The `@typescript-eslint/no-empty-function` rule extends the `no-empty-function` rule from ESLint core, and adds support for handling TypeScript specific code that would otherwise trigger the rule. +This rule extends the base [`eslint/no-empty-function`](https://eslint.org/docs/rules/no-empty-function) rule. +It adds support for handling TypeScript specific code that would otherwise trigger the rule. One example of valid TypeScript specific code that would otherwise trigger the `no-empty-function` rule is the use of [parameter properties](https://www.typescriptlang.org/docs/handbook/classes.html#parameter-properties) in constructor functions: -```typescript -class Person { - constructor(private firstName: string, private surname: string) {} -} -``` - -The above code is functionally equivalent to: +## How to use -```typescript -class Person { - private firstName: string; - private surname: string; - - constructor(firstName: string, surname: string) { - this.firstName = firstName; - this.surname = surname; - } -} -``` - -Parameter properties enable both the _declaration_ and _initialization_ of member properties in a single location, avoiding the boilerplate & duplication that is common when initializing member properties from parameter values in a constructor function. - -In these cases, although the constructor has an empty function body, it is technically valid and should not trigger an error. - -See the [ESLint documentation](https://eslint.org/docs/rules/no-empty-function) for more details on the `no-empty-function` rule. - -## Rule Changes - -```cjson +```jsonc { - // note you must disable the base rule as it can report incorrect errors - "no-empty-function": "off", - "@typescript-eslint/no-empty-function": "error" + // note you must disable the base rule as it can report incorrect errors + "no-empty-function": "off", + "@typescript-eslint/no-empty-function": ["error"] } ``` ## Options -This rule has an object option: - -- `allow` (`string[]`) - - `"protected-constructors"` - Protected class constructors. - - `"private-constructors"` - Private class constructors. - - [See the other options allowed](https://github.com/eslint/eslint/blob/master/docs/rules/no-empty-function.md#options) - -#### allow: protected-constructors - -Examples of **correct** code for the `{ "allow": ["protected-constructors"] }` option: - -```ts -/*eslint @typescript-eslint/no-empty-function: ["error", { "allow": ["protected-constructors"] }]*/ - -class Foo { - protected constructor() {} -} -``` - -#### allow: private-constructors - -Examples of **correct** code for the `{ "allow": ["private-constructors"] }` option: - -```ts -/*eslint @typescript-eslint/no-empty-function: ["error", { "allow": ["private-constructors"] }]*/ - -class Foo { - private constructor() {} -} -``` +See [`eslint/no-empty-function` options](https://eslint.org/docs/rules/no-empty-function#options). Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-empty-function.md) diff --git a/packages/eslint-plugin/docs/rules/no-extra-parens.md b/packages/eslint-plugin/docs/rules/no-extra-parens.md index bcb21dec28df..8173b2ef1adb 100644 --- a/packages/eslint-plugin/docs/rules/no-extra-parens.md +++ b/packages/eslint-plugin/docs/rules/no-extra-parens.md @@ -1,22 +1,22 @@ # Disallow unnecessary parentheses (`no-extra-parens`) -This rule restricts the use of parentheses to only where they are necessary. - ## Rule Details This rule extends the base [`eslint/no-extra-parens`](https://eslint.org/docs/rules/no-extra-parens) rule. -It supports all options and features of the base rule plus TS type assertions. +It adds support for TypeScript type assertions. ## How to use -```cjson +```jsonc { - // note you must disable the base rule as it can report incorrect errors - "no-extra-parens": "off", - "@typescript-eslint/no-extra-parens": ["error"] + // note you must disable the base rule as it can report incorrect errors + "no-extra-parens": "off", + "@typescript-eslint/no-extra-parens": ["error"] } ``` ## Options See [`eslint/no-extra-parens` options](https://eslint.org/docs/rules/no-extra-parens#options). + +Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-extra-parens.md) diff --git a/packages/eslint-plugin/docs/rules/no-extra-semi.md b/packages/eslint-plugin/docs/rules/no-extra-semi.md index bed5e29d657b..f6865bd8b54a 100644 --- a/packages/eslint-plugin/docs/rules/no-extra-semi.md +++ b/packages/eslint-plugin/docs/rules/no-extra-semi.md @@ -3,10 +3,11 @@ ## Rule Details This rule extends the base [`eslint/no-extra-semi`](https://eslint.org/docs/rules/no-extra-semi) rule. +It adds support for class properties. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "no-extra-semi": "off", @@ -14,4 +15,8 @@ This rule extends the base [`eslint/no-extra-semi`](https://eslint.org/docs/rule } ``` +## Options + +See [`eslint/no-extra-semi` options](https://eslint.org/docs/rules/no-extra-semi#options). + Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-extra-semi.md) diff --git a/packages/eslint-plugin/docs/rules/no-magic-numbers.md b/packages/eslint-plugin/docs/rules/no-magic-numbers.md index 377e92723607..f41204c132bf 100644 --- a/packages/eslint-plugin/docs/rules/no-magic-numbers.md +++ b/packages/eslint-plugin/docs/rules/no-magic-numbers.md @@ -1,25 +1,72 @@ # Disallow magic numbers (`no-magic-numbers`) -'Magic numbers' are numbers that occur multiple times in code without an explicit meaning. -They should preferably be replaced by named constants. - ## Rule Details -The `@typescript-eslint/no-magic-numbers` rule extends the `no-magic-numbers` rule from ESLint core, and adds support for handling TypeScript specific code that would otherwise trigger the rule. +This rule extends the base [`eslint/no-magic-numbers`](https://eslint.org/docs/rules/no-magic-numbers) rule. +It adds support for: -See the [ESLint documentation](https://eslint.org/docs/rules/no-magic-numbers) for more details on the `no-magic-numbers` rule. +- numeric literal types (`type T = 1`), +- `enum` members (`enum Foo { bar = 1 }`), +- `readonly` class properties (`class Foo { readonly bar = 1 }`). -## Rule Changes +## How to use -```cjson +```jsonc { - // note you must disable the base rule as it can report incorrect errors - "no-magic-numbers": "off", - "@typescript-eslint/no-magic-numbers": ["error", { "ignoreNumericLiteralTypes": true }] + // note you must disable the base rule as it can report incorrect errors + "no-magic-numbers": "off", + "@typescript-eslint/no-magic-numbers": [ + "error", + { + /* options */ + } + ] +} +``` + +## Options + +See [`eslint/no-magic-numbers` options](https://eslint.org/docs/rules/no-magic-numbers#options). +This rule adds the following options: + +```ts +interface Options extends BaseNoMagicNumbersOptions { + ignoreEnums?: boolean; + ignoreNumericLiteralTypes?: boolean; + ignoreReadonlyClassProperties?: boolean; +} + +const defaultOptions: Options = { + ...baseNoMagicNumbersDefaultOptions, + ignoreEnums: false, + ignoreNumericLiteralTypes: false, + ignoreReadonlyClassProperties: false, +}; +``` + +### `ignoreEnums` + +A boolean to specify if enums used in TypeScript are considered okay. `false` by default. + +Examples of **incorrect** code for the `{ "ignoreEnums": false }` option: + +```ts +/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": false }]*/ + +enum foo = { + SECOND = 1000, } ``` -In addition to the options supported by the `no-magic-numbers` rule in ESLint core, the rule adds the following options: +Examples of **correct** code for the `{ "ignoreEnums": true }` option: + +```ts +/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": true }]*/ + +enum foo = { + SECOND = 1000, +} +``` ### `ignoreNumericLiteralTypes` @@ -69,28 +116,4 @@ class Foo { } ``` -### `ignoreEnums` - -A boolean to specify if enums used in TypeScript are considered okay. `false` by default. - -Examples of **incorrect** code for the `{ "ignoreEnums": false }` option: - -```ts -/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": false }]*/ - -enum foo = { - SECOND = 1000, -} -``` - -Examples of **correct** code for the `{ "ignoreEnums": true }` option: - -```ts -/*eslint @typescript-eslint/no-magic-numbers: ["error", { "ignoreEnums": true }]*/ - -enum foo = { - SECOND = 1000, -} -``` - Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-magic-numbers.md) diff --git a/packages/eslint-plugin/docs/rules/no-this-alias.md b/packages/eslint-plugin/docs/rules/no-this-alias.md index 7f5ee719fa0f..b5d2afb542cc 100644 --- a/packages/eslint-plugin/docs/rules/no-this-alias.md +++ b/packages/eslint-plugin/docs/rules/no-this-alias.md @@ -39,15 +39,15 @@ Examples of **correct** code for this rule: You can pass an object option: -```json5 +```jsonc { - '@typescript-eslint/no-this-alias': [ - 'error', + "@typescript-eslint/no-this-alias": [ + "error", { - allowDestructuring: true, // Allow `const { props, state } = this`; false by default - allowedNames: ['self'], // Allow `const self = this`; `[]` by default - }, - ], + "allowDestructuring": true, // Allow `const { props, state } = this`; false by default + "allowedNames": ["self"] // Allow `const self = this`; `[]` by default + } + ] } ``` diff --git a/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md b/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md new file mode 100644 index 000000000000..1a452e431eb3 --- /dev/null +++ b/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md @@ -0,0 +1,62 @@ +# Disallows assigning any to variables and properties (`no-unsafe-assignment`) + +Despite your best intentions, the `any` type can sometimes leak into your codebase. +Assigning an `any` typed value to a variable can be hard to pick up on, particularly if it leaks in from an external library. Operations on the variable will not be checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase. + +## Rule Details + +This rule disallows assigning `any` to a variable, and assigning `any[]` to an array destructuring. +This rule also compares the assigned type to the variable's type to ensure you don't assign an unsafe `any` in a generic position to a receiver that's expecting a specific type. For example, it will error if you assign `Set` to a variable declared as `Set`. + +Examples of **incorrect** code for this rule: + +```ts +const x = 1 as any, + y = 1 as any; +const [x] = 1 as any; +const [x] = [] as any[]; +const [x] = [1 as any]; +[x] = [1] as [any]; + +function foo(a = 1 as any) {} +class Foo { + constructor(private a = 1 as any) {} +} +class Foo { + private a = 1 as any; +} + +// generic position examples +const x: Set = new Set(); +const x: Map = new Map(); +const x: Set = new Set(); +const x: Set>> = new Set>>(); +``` + +Examples of **correct** code for this rule: + +```ts +const x = 1, + y = 1; +const [x] = [1]; +[x] = [1] as [number]; + +function foo(a = 1) {} +class Foo { + constructor(private a = 1) {} +} +class Foo { + private a = 1; +} + +// generic position examples +const x: Set = new Set(); +const x: Map = new Map(); +const x: Set = new Set(); +const x: Set>> = new Set>>(); +``` + +## Related to + +- [`no-explicit-any`](./no-explicit-any.md) +- TSLint: [`no-unsafe-any`](https://palantir.github.io/tslint/rules/no-unsafe-any/) diff --git a/packages/eslint-plugin/docs/rules/no-unsafe-call.md b/packages/eslint-plugin/docs/rules/no-unsafe-call.md index 3c18b7c1ee23..490ff78ced55 100644 --- a/packages/eslint-plugin/docs/rules/no-unsafe-call.md +++ b/packages/eslint-plugin/docs/rules/no-unsafe-call.md @@ -1,7 +1,7 @@ # Disallows calling an any type value (`no-unsafe-call`) Despite your best intentions, the `any` type can sometimes leak into your codebase. -Member access on `any` typed variables is not checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase. +The arguments to, and return value of calling an `any` typed variable are not checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase. ## Rule Details diff --git a/packages/eslint-plugin/docs/rules/no-untyped-public-signature.md b/packages/eslint-plugin/docs/rules/no-untyped-public-signature.md index 87a17895c384..ffcd083b57dc 100644 --- a/packages/eslint-plugin/docs/rules/no-untyped-public-signature.md +++ b/packages/eslint-plugin/docs/rules/no-untyped-public-signature.md @@ -2,6 +2,11 @@ public methods are meant to be used by code outside of your class. By typing both the parameters and the return type of public methods they will be more readable and easy to use. +## DEPRECATED + +This rule has been deprecated in favour of the [`explicit-module-boundary-types`](./explicit-module-boundary-types.md) rule. +It will be removed in a future version of this plugin. + ## Rule Details This rule aims to ensure that only typed public methods are declared in the code. @@ -46,9 +51,12 @@ This rule, in its default state, does not require any argument. You may pass method names you would like this rule to ignore, like so: -```cjson +```jsonc { - "@typescript-eslint/no-untyped-public-signature": ["error", { "ignoredMethods": ["ignoredMethodName"] }] + "@typescript-eslint/no-untyped-public-signature": [ + "error", + { "ignoredMethods": ["ignoredMethodName"] } + ] } ``` diff --git a/packages/eslint-plugin/docs/rules/no-unused-expressions.md b/packages/eslint-plugin/docs/rules/no-unused-expressions.md index 63674120fbcb..cb61c2ed0409 100644 --- a/packages/eslint-plugin/docs/rules/no-unused-expressions.md +++ b/packages/eslint-plugin/docs/rules/no-unused-expressions.md @@ -1,16 +1,13 @@ # Disallow unused expressions (`no-unused-expressions`) -This rule aims to eliminate unused expressions which have no effect on the state of the program. - ## Rule Details This rule extends the base [`eslint/no-unused-expressions`](https://eslint.org/docs/rules/no-unused-expressions) rule. -It supports all options and features of the base rule. -This version adds support for numerous typescript features. +It adds support for optional call expressions `x?.()`, and directive in module declarations. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "no-unused-expressions": "off", diff --git a/packages/eslint-plugin/docs/rules/no-unused-vars.md b/packages/eslint-plugin/docs/rules/no-unused-vars.md index a84b4362d61e..44cfae690f8e 100644 --- a/packages/eslint-plugin/docs/rules/no-unused-vars.md +++ b/packages/eslint-plugin/docs/rules/no-unused-vars.md @@ -1,305 +1,24 @@ # Disallow unused variables (`no-unused-vars`) -Variables that are declared and not used anywhere in the code are most likely an error due to incomplete refactoring. Such variables take up space in the code and can lead to confusion by readers. +## PLEASE READ THIS ISSUE BEFORE USING THIS RULE [#1856](https://github.com/typescript-eslint/typescript-eslint/issues/1856) ## Rule Details -This rule is aimed at eliminating unused variables, functions, and parameters of functions. +This rule extends the base [`eslint/no-unused-vars`](https://eslint.org/docs/rules/no-unused-vars) rule. +It adds support for TypeScript features, such as types. -A variable is considered to be used if any of the following are true: +## How to use -- It represents a function that is called (`doSomething()`) -- It is read (`var y = x`) -- It is passed into a function as an argument (`doSomething(x)`) -- It is read inside of a function that is passed to another function (`doSomething(function() { foo(); })`) - -A variable is _not_ considered to be used if it is only ever assigned to (`var x = 5`) or declared. - -Examples of **incorrect** code for this rule: - -```js -/*eslint no-unused-vars: "error"*/ -/*global some_unused_var*/ - -// It checks variables you have defined as global -some_unused_var = 42; - -var x; - -// Write-only variables are not considered as used. -var y = 10; -y = 5; - -// A read for a modification of itself is not considered as used. -var z = 0; -z = z + 1; - -// By default, unused arguments cause warnings. -(function(foo) { - return 5; -})(); - -// Unused recursive functions also cause warnings. -function fact(n) { - if (n < 2) return 1; - return n * fact(n - 1); -} - -// When a function definition destructures an array, unused entries from the array also cause warnings. -function getY([x, y]) { - return y; -} -``` - -Examples of **correct** code for this rule: - -```js -/*eslint no-unused-vars: "error"*/ - -var x = 10; -alert(x); - -// foo is considered used here -myFunc( - function foo() { - // ... - }.bind(this), -); - -(function(foo) { - return foo; -})(); - -var myFunc; -myFunc = setTimeout(function() { - // myFunc is considered used - myFunc(); -}, 50); - -// Only the second argument from the destructured array is used. -function getY([, y]) { - return y; -} -``` - -### exported - -In environments outside of CommonJS or ECMAScript modules, you may use `var` to create a global variable that may be used by other scripts. You can use the `/* exported variableName */` comment block to indicate that this variable is being exported and therefore should not be considered unused. - -Note that `/* exported */` has no effect for any of the following: - -- when the environment is `node` or `commonjs` -- when `parserOptions.sourceType` is `module` -- when `ecmaFeatures.globalReturn` is `true` - -The line comment `// exported variableName` will not work as `exported` is not line-specific. - -Examples of **correct** code for `/* exported variableName */` operation: - -```js -/* exported global_var */ - -var global_var = 42; -``` - -## Options - -This rule takes one argument which can be a string or an object. The string settings are the same as those of the `vars` property (explained below). - -By default this rule is enabled with `all` option for variables and `after-used` for arguments. - -```CJSON +```jsonc { - "rules": { - // note you must disable the base rule as it can report incorrect errors - "no-unused-vars": "off", - "@typescript-eslint/no-unused-vars": ["error", { - "vars": "all", - "args": "after-used", - "ignoreRestSiblings": false - }] - } + // note you must disable the base rule as it can report incorrect errors + "no-unused-vars": "off", + "@typescript-eslint/no-unused-vars": ["error"] } ``` -### `vars` - -The `vars` option has two settings: - -- `all` checks all variables for usage, including those in the global scope. This is the default setting. -- `local` checks only that locally-declared variables are used but will allow global variables to be unused. - -#### `vars: local` - -Examples of **correct** code for the `{ "vars": "local" }` option: - -```js -/*eslint no-unused-vars: ["error", { "vars": "local" }]*/ -/*global some_unused_var */ - -some_unused_var = 42; -``` - -### `varsIgnorePattern` - -The `varsIgnorePattern` option specifies exceptions not to check for usage: variables whose names match a regexp pattern. For example, variables whose names contain `ignored` or `Ignored`. - -Examples of **correct** code for the `{ "varsIgnorePattern": "[iI]gnored" }` option: - -```js -/*eslint no-unused-vars: ["error", { "varsIgnorePattern": "[iI]gnored" }]*/ - -var firstVarIgnored = 1; -var secondVar = 2; -console.log(secondVar); -``` - -### `args` - -The `args` option has three settings: - -- `after-used` - unused positional arguments that occur before the last used argument will not be checked, but all named arguments and all positional arguments after the last used argument will be checked. -- `all` - all named arguments must be used. -- `none` - do not check arguments. - -#### `args: after-used` - -Examples of **incorrect** code for the default `{ "args": "after-used" }` option: - -```js -/*eslint no-unused-vars: ["error", { "args": "after-used" }]*/ - -// 2 errors, for the parameters after the last used parameter (bar) -// "baz" is defined but never used -// "qux" is defined but never used -(function(foo, bar, baz, qux) { - return bar; -})(); -``` - -Examples of **correct** code for the default `{ "args": "after-used" }` option: - -```js -/*eslint no-unused-vars: ["error", {"args": "after-used"}]*/ - -(function(foo, bar, baz, qux) { - return qux; -})(); -``` - -#### `args: all` - -Examples of **incorrect** code for the `{ "args": "all" }` option: - -```js -/*eslint no-unused-vars: ["error", { "args": "all" }]*/ - -// 2 errors -// "foo" is defined but never used -// "baz" is defined but never used -(function(foo, bar, baz) { - return bar; -})(); -``` - -#### `args: none` - -Examples of **correct** code for the `{ "args": "none" }` option: - -```js -/*eslint no-unused-vars: ["error", { "args": "none" }]*/ - -(function(foo, bar, baz) { - return bar; -})(); -``` - -### `ignoreRestSiblings` - -The `ignoreRestSiblings` option is a boolean (default: `false`). Using a [Rest Property](https://github.com/tc39/proposal-object-rest-spread) it is possible to "omit" properties from an object, but by default the sibling properties are marked as "unused". With this option enabled the rest property's siblings are ignored. - -Examples of **correct** code for the `{ "ignoreRestSiblings": true }` option: - -```js -/*eslint no-unused-vars: ["error", { "ignoreRestSiblings": true }]*/ -// 'type' is ignored because it has a rest property sibling. -var { type, ...coords } = data; -``` - -### `argsIgnorePattern` - -The `argsIgnorePattern` option specifies exceptions not to check for usage: arguments whose names match a regexp pattern. For example, variables whose names begin with an underscore. - -Examples of **correct** code for the `{ "argsIgnorePattern": "^_" }` option: - -```js -/*eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }]*/ - -function foo(x, _y) { - return x + 1; -} -foo(); -``` - -### `caughtErrors` - -The `caughtErrors` option is used for `catch` block arguments validation. - -It has two settings: - -- `none` - do not check error objects. This is the default setting. -- `all` - all named arguments must be used. - -#### `caughtErrors: none` - -Not specifying this rule is equivalent of assigning it to `none`. - -Examples of **correct** code for the `{ "caughtErrors": "none" }` option: - -```js -/*eslint no-unused-vars: ["error", { "caughtErrors": "none" }]*/ - -try { - //... -} catch (err) { - console.error('errors'); -} -``` - -#### `caughtErrors: all` - -Examples of **incorrect** code for the `{ "caughtErrors": "all" }` option: - -```js -/*eslint no-unused-vars: ["error", { "caughtErrors": "all" }]*/ - -// 1 error -// "err" is defined but never used -try { - //... -} catch (err) { - console.error('errors'); -} -``` - -### `caughtErrorsIgnorePattern` - -The `caughtErrorsIgnorePattern` option specifies exceptions not to check for usage: catch arguments whose names match a regexp pattern. For example, variables whose names begin with a string 'ignore'. - -Examples of **correct** code for the `{ "caughtErrorsIgnorePattern": "^ignore" }` option: - -```js -/*eslint no-unused-vars: ["error", { "caughtErrorsIgnorePattern": "^ignore" }]*/ - -try { - //... -} catch (ignoreErr) { - console.error('errors'); -} -``` - -## When Not To Use It +## Options -If you don't want to be notified about unused variables or function arguments, you can safely turn this rule off. +See [`eslint/no-unused-vars` options](https://eslint.org/docs/rules/no-unused-vars#options). Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-unused-vars.md) diff --git a/packages/eslint-plugin/docs/rules/no-use-before-define.md b/packages/eslint-plugin/docs/rules/no-use-before-define.md index e6acf6045683..569b8130386d 100644 --- a/packages/eslint-plugin/docs/rules/no-use-before-define.md +++ b/packages/eslint-plugin/docs/rules/no-use-before-define.md @@ -1,146 +1,46 @@ # Disallow the use of variables before they are defined (`no-use-before-define`) -In JavaScript, prior to ES6, variable and function declarations are hoisted to the top of a scope, so it's possible to use identifiers before their formal declarations in code. This can be confusing and some believe it is best to always declare variables and functions before using them. - -In ES6, block-level bindings (`let` and `const`) introduce a "temporal dead zone" where a `ReferenceError` will be thrown with any attempt to access the variable before its declaration. +## PLEASE READ THIS ISSUE BEFORE USING THIS RULE [#1856](https://github.com/typescript-eslint/typescript-eslint/issues/1856) ## Rule Details -This rule will warn when it encounters a reference to an identifier that has not yet been declared. - -Examples of **incorrect** code for this rule: - -```ts -/*eslint no-use-before-define: "error"*/ -/*eslint-env es6*/ - -alert(a); -var a = 10; - -f(); -function f() {} - -function g() { - return b; -} -var b = 1; - -// With blockBindings: true -{ - alert(c); - let c = 1; -} - -let myVar: StringOrNumber; -type StringOrNumber = string | number; -``` - -Examples of **correct** code for this rule: +This rule extends the base [`eslint/no-use-before-define`](https://eslint.org/docs/rules/no-use-before-define) rule. +It adds support for `type`, `interface` and `enum` declarations. -```ts -/*eslint no-use-before-define: "error"*/ -/*eslint-env es6*/ +## How to use -var a; -a = 10; -alert(a); - -function f() {} -f(1); - -var b = 1; -function g() { - return b; -} - -// With blockBindings: true +```jsonc { - let C; - c++; + // note you must disable the base rule as it can report incorrect errors + "no-use-before-define": "off", + "@typescript-eslint/no-use-before-define": ["error"] } - -type StringOrNumber = string | number; -let myVar: StringOrNumber; ``` ## Options -```json -{ - "no-use-before-define": ["error", { "functions": true, "classes": true }] -} -``` - -- `functions` (`boolean`) - - The flag which shows whether or not this rule checks function declarations. - If this is `true`, this rule warns every reference to a function before the function declaration. - Otherwise, ignores those references. - Function declarations are hoisted, so it's safe. - Default is `true`. -- `classes` (`boolean`) - - The flag which shows whether or not this rule checks class declarations of upper scopes. - If this is `true`, this rule warns every reference to a class before the class declaration. - Otherwise, ignores those references if the declaration is in upper function scopes. - Class declarations are not hoisted, so it might be danger. - Default is `true`. -- `enums` (`boolean`) - - The flag which shows whether or not this rule checks enum declarations of upper scopes. - If this is `true`, this rule warns every reference to a enum before the enum declaration. - Otherwise, ignores those references. - Default is `true`. -- `variables` (`boolean`) - - This flag determines whether or not the rule checks variable declarations in upper scopes. - If this is `true`, the rule warns every reference to a variable before the variable declaration. - Otherwise, the rule ignores a reference if the declaration is in an upper scope, while still reporting the reference if it's in the same scope as the declaration. - Default is `true`. -- `typedefs` (`boolean`, **added** in `@typescript-eslint/eslint-plugin`) - - The flag which shows whether or not this rule checks type declarations. - If this is `true`, this rule warns every reference to a type before the type declaration. - Otherwise, ignores those references. - Type declarations are hoisted, so it's safe. - Default is `true`. - -This rule accepts `"nofunc"` string as an option. -`"nofunc"` is the same as `{ "functions": false, "classes": true }`. - -### `functions` - -Examples of **correct** code for the `{ "functions": false }` option: - -```js -/*eslint no-use-before-define: ["error", { "functions": false }]*/ - -f(); -function f() {} -``` - -### `classes` +See [`eslint/no-use-before-define` options](https://eslint.org/docs/rules/no-use-before-define#options). +This rule adds the following options: -Examples of **incorrect** code for the `{ "classes": false }` option: - -```js -/*eslint no-use-before-define: ["error", { "classes": false }]*/ -/*eslint-env es6*/ - -new A(); -class A {} -``` - -Examples of **correct** code for the `{ "classes": false }` option: - -```js -/*eslint no-use-before-define: ["error", { "classes": false }]*/ -/*eslint-env es6*/ - -function foo() { - return new A(); +```ts +interface Options extends BaseNoMagicNumbersOptions { + enums?: boolean; + typedefs?: boolean; } -class A {} +const defaultOptions: Options = { + ...baseNoMagicNumbersDefaultOptions, + enums: true, + typedefs: true, +}; ``` ### `enums` +The flag which shows whether or not this rule checks enum declarations of upper scopes. +If this is `true`, this rule warns every reference to a enum before the enum declaration. +Otherwise, ignores those references. + Examples of **incorrect** code for the `{ "enums": true }` option: ```ts @@ -176,31 +76,13 @@ enum Foo { } ``` -### `variables` - -Examples of **incorrect** code for the `{ "variables": false }` option: - -```js -/*eslint no-use-before-define: ["error", { "variables": false }]*/ - -console.log(foo); -var foo = 1; -``` - -Examples of **correct** code for the `{ "variables": false }` option: - -```js -/*eslint no-use-before-define: ["error", { "variables": false }]*/ - -function baz() { - console.log(foo); -} - -var foo = 1; -``` - ### `typedefs` +The flag which shows whether or not this rule checks type declarations. +If this is `true`, this rule warns every reference to a type before the type declaration. +Otherwise, ignores those references. +Type declarations are hoisted, so it's safe. + Examples of **correct** code for the `{ "typedefs": false }` option: ```ts diff --git a/packages/eslint-plugin/docs/rules/no-useless-constructor.md b/packages/eslint-plugin/docs/rules/no-useless-constructor.md index 757ae5d4a127..524ad4b92d9c 100644 --- a/packages/eslint-plugin/docs/rules/no-useless-constructor.md +++ b/packages/eslint-plugin/docs/rules/no-useless-constructor.md @@ -1,88 +1,26 @@ # Disallow unnecessary constructors (`no-useless-constructor`) -ES2015 provides a default class constructor if one is not specified. As such, it is unnecessary to provide an empty constructor or one that simply delegates into its parent class, as in the following examples: - -```js -class A { - constructor() {} -} - -class A extends B { - constructor(value) { - super(value); - } -} -``` - ## Rule Details -This rule flags class constructors that can be safely removed without changing how the class works. - -## Examples - -Examples of **incorrect** code for this rule: - -```js -/*eslint @typescript-eslint/no-useless-constructor: "error"*/ - -class A { - constructor() {} -} - -class A extends B { - constructor(...args) { - super(...args); - } -} -``` +This rule extends the base [`eslint/no-useless-constructor`](https://eslint.org/docs/rules/no-useless-constructor) rule. +It adds support for: -Examples of **correct** code for this rule: - -```js -/*eslint @typescript-eslint/no-useless-constructor: "error"*/ - -class A {} - -class A { - constructor() { - doSomething(); - } -} - -class A extends B { - constructor() { - super('foo'); - } -} - -class A extends B { - constructor() { - super(); - doSomething(); - } -} - -class A extends B { - constructor(protected name: string) {} -} - -class A extends B { - protected constructor() {} -} -``` +- constructors marked as `protected` / `private` (i.e. marking a constructor as non-public), +- `public` constructors when there is no superclass, +- constructors with only parameter properties. -## Rule Changes +## How to use -```cjson +```jsonc { - // note you must disable the base rule as it can report incorrect errors - "no-useless-constructor": "off", - "@typescript-eslint/no-useless-constructor": "error", + // note you must disable the base rule as it can report incorrect errors + "no-useless-constructor": "off", + "@typescript-eslint/no-useless-constructor": ["error"] } ``` -## When Not To Use It +## Options -If you don't want to be notified about unnecessary constructors, you can safely disable this rule. +See [`eslint/no-useless-constructor` options](https://eslint.org/docs/rules/no-useless-constructor#options). Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/no-useless-constructor.md) diff --git a/packages/eslint-plugin/docs/rules/prefer-as-const.md b/packages/eslint-plugin/docs/rules/prefer-as-const.md index bb288192d267..b710a8275e7a 100644 --- a/packages/eslint-plugin/docs/rules/prefer-as-const.md +++ b/packages/eslint-plugin/docs/rules/prefer-as-const.md @@ -25,4 +25,4 @@ let foo = { bar: 'baz' }; ## When Not To Use It -If you are using typescript < 3.4 +If you are using TypeScript < 3.4 diff --git a/packages/eslint-plugin/docs/rules/prefer-readonly.md b/packages/eslint-plugin/docs/rules/prefer-readonly.md index 6731a7585807..9ce16a8c35fb 100644 --- a/packages/eslint-plugin/docs/rules/prefer-readonly.md +++ b/packages/eslint-plugin/docs/rules/prefer-readonly.md @@ -52,9 +52,9 @@ This rule, in its default state, does not require any argument. You may pass `"onlyInlineLambdas": true` as a rule option within an object to restrict checking only to members immediately assigned a lambda value. -```cjson +```jsonc { - "@typescript-eslint/prefer-readonly": ["error", { "onlyInlineLambdas": true }] + "@typescript-eslint/prefer-readonly": ["error", { "onlyInlineLambdas": true }] } ``` diff --git a/packages/eslint-plugin/docs/rules/prefer-reduce-type-parameter.md b/packages/eslint-plugin/docs/rules/prefer-reduce-type-parameter.md new file mode 100644 index 000000000000..d6f68021cc73 --- /dev/null +++ b/packages/eslint-plugin/docs/rules/prefer-reduce-type-parameter.md @@ -0,0 +1,54 @@ +# Prefer using type parameter when calling `Array#reduce` instead of casting (`prefer-reduce-type-parameter`) + +It's common to call `Array#reduce` with a generic type, such as an array or object, as the initial value. +Since these values are empty, their types are not usable: + +- `[]` has type `never[]`, which can't have items pushed into it as nothing is type `never` +- `{}` has type `{}`, which doesn't have an index signature and so can't have properties added to it + +A common solution to this problem is to cast the initial value. While this will work, it's not the most optimal +solution as casting has subtle effects on the underlying types that can allow bugs to slip in. + +A better (and lesser known) solution is to pass the type in as a generic parameter to `Array#reduce` explicitly. +This means that TypeScript doesn't have to try to infer the type, and avoids the common pitfalls that come with casting. + +## Rule Details + +This rule looks for calls to `Array#reduce`, and warns if an initial value is being passed & casted, +suggesting instead to pass the cast type to `Array#reduce` as its generic parameter. + +Examples of **incorrect** code for this rule: + +```ts +[1, 2, 3].reduce((arr, num) => arr.concat(num * 2), [] as number[]); + +['a', 'b'].reduce( + (accum, name) => ({ + ...accum, + [name]: true, + }), + {} as Record, +); +``` + +Examples of **correct** code for this rule: + +```ts +[1, 2, 3].reduce((arr, num) => arr.concat(num * 2), []); + +['a', 'b'].reduce>( + (accum, name) => ({ + ...accum, + [name]: true, + }), + {}, +); +``` + +## Options + +There are no options. + +## When Not To Use It + +If you don't want to use typechecking in your linting, you can't use this rule. diff --git a/packages/eslint-plugin/docs/rules/prefer-ts-expect-error.md b/packages/eslint-plugin/docs/rules/prefer-ts-expect-error.md new file mode 100644 index 000000000000..7ec0cac771ba --- /dev/null +++ b/packages/eslint-plugin/docs/rules/prefer-ts-expect-error.md @@ -0,0 +1,47 @@ +# Recommends using `// @ts-expect-error` over `// @ts-ignore` (`prefer-ts-expect-error`) + +TypeScript allows you to suppress all errors on a line by placing a single-line comment starting with `@ts-ignore` immediately before the erroring line. +While powerful, there is no way to know if a `@ts-ignore` is actually suppressing an error without manually investigating what happens when the `@ts-ignore` is removed. + +This means its easy for `@ts-ignore`s to be forgotten about, and remain in code even after the error they were suppressing is fixed. +This is dangerous, as if a new error arises on that line it'll be suppressed by the forgotten about `@ts-ignore`, and so be missed. + +To address this, TS3.9 ships with a new single-line comment directive: `// @ts-expect-error`. + +This directive operates in the same manner as `@ts-ignore`, but will error if the line it's meant to be suppressing doesn't actually contain an error, making it a lot safer. + +## Rule Details + +This rule looks for usages of `@ts-ignore`, and flags them to be replaced with `@ts-expect-error`. + +Examples of **incorrect** code for this rule: + +```ts +// @ts-ignore +const str: string = 1; + +const isOptionEnabled = (key: string): boolean => { + // @ts-ignore: if key isn't in globalOptions it'll be undefined which is false + return !!globalOptions[key]; +}; +``` + +Examples of **correct** code for this rule: + +```ts +// @ts-expect-error +const str: string = 1; + +const isOptionEnabled = (key: string): boolean => { + // @ts-expect-error: if key isn't in globalOptions it'll be undefined which is false + return !!globalOptions[key]; +}; +``` + +## When Not To Use It + +If you are not using TypeScript 3.9 (or greater), then you will not be able to use this rule, as the directive is not supported + +## Further Reading + +- [Original Implementing PR](https://github.com/microsoft/TypeScript/pull/36014) diff --git a/packages/eslint-plugin/docs/rules/quotes.md b/packages/eslint-plugin/docs/rules/quotes.md index e9c37df36f75..6b63587f6b46 100644 --- a/packages/eslint-plugin/docs/rules/quotes.md +++ b/packages/eslint-plugin/docs/rules/quotes.md @@ -3,11 +3,11 @@ ## Rule Details This rule extends the base [`eslint/quotes`](https://eslint.org/docs/rules/quotes) rule. -It supports all options and features of the base rule. +It adds support for TypeScript features which allow quoted names, but not backtick quoted names. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "quotes": "off", diff --git a/packages/eslint-plugin/docs/rules/require-await.md b/packages/eslint-plugin/docs/rules/require-await.md index 23160dc7db5d..2d8ad41fda9e 100644 --- a/packages/eslint-plugin/docs/rules/require-await.md +++ b/packages/eslint-plugin/docs/rules/require-await.md @@ -1,49 +1,32 @@ # Disallow async functions which have no `await` expression (`require-await`) -Asynchronous functions that don’t use `await` might not need to be asynchronous functions and could be the unintentional result of refactoring. - ## Rule Details -The `@typescript-eslint/require-await` rule extends the `require-await` rule from ESLint core, and allows for cases where the additional typing information can prevent false positives that would otherwise trigger the rule. - -One example is when a function marked as `async` returns a value that is: +This rule extends the base [`eslint/require-await`](https://eslint.org/docs/rules/require-await) rule. +It uses type information to add support for `async` functions that return a `Promise`. -1. already a promise; or -2. the result of calling another `async` function +Examples of **correct** code for this rule: -```typescript -async function numberOne(): Promise { +```ts +async function returnsPromise1() { return Promise.resolve(1); } -async function getDataFromApi(endpoint: string): Promise { - return fetch(endpoint); -} -``` - -In the above examples, the core `require-await` triggers the following warnings: - -``` -async function 'numberOne' has no 'await' expression -async function 'getDataFromApi' has no 'await' expression +const returnsPromise2 = () => returnsPromise1(); ``` -One way to resolve these errors is to remove the `async` keyword. However doing so can cause a conflict with the [`@typescript-eslint/promise-function-async`](https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/promise-function-async.md) rule (if enabled), which requires any function returning a promise to be marked as `async`. +## How to use -Another way to resolve these errors is to add an `await` keyword to the return statements. However doing so can cause a conflict with the [`no-return-await`](https://eslint.org/docs/rules/no-return-await) rule (if enabled), which warns against using `return await` since the return value of an `async` function is always wrapped in `Promise.resolve` anyway. - -With the additional typing information available in TypeScript code, this extension to the `require-await` rule is able to look at the _actual_ return types of an `async` function (before being implicitly wrapped in `Promise.resolve`), and avoid the need for an `await` expression when the return value is already a promise. - -See the [ESLint documentation](https://eslint.org/docs/rules/require-await) for more details on the `require-await` rule. - -## Rule Changes - -```cjson +```jsonc { - // note you must disable the base rule as it can report incorrect errors - "require-await": "off", - "@typescript-eslint/require-await": "error" + // note you must disable the base rule as it can report incorrect errors + "require-await": "off", + "@typescript-eslint/require-await": "error" } ``` +## Options + +See [`eslint/require-await` options](https://eslint.org/docs/rules/require-await#options). + Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/require-await.md) diff --git a/packages/eslint-plugin/docs/rules/restrict-template-expressions.md b/packages/eslint-plugin/docs/rules/restrict-template-expressions.md index 549da98eebd3..4c52e74445f5 100644 --- a/packages/eslint-plugin/docs/rules/restrict-template-expressions.md +++ b/packages/eslint-plugin/docs/rules/restrict-template-expressions.md @@ -59,6 +59,16 @@ const msg1 = `arg = ${arg}`; const msg2 = `arg = ${arg || 'not truthy'}`; ``` +### `allowAny` + +Examples of additional **correct** code for this rule with `{ allowAny: true }`: + +```ts +const user = JSON.parse('{ "name": "foo" }'); +const msg1 = `arg = ${user.name}`; +const msg2 = `arg = ${user.name || 'the user with no name'}`; +``` + ### `allowNullable` Examples of additional **correct** code for this rule with `{ allowNullable: true }`: diff --git a/packages/eslint-plugin/docs/rules/return-await.md b/packages/eslint-plugin/docs/rules/return-await.md index c00c2be5d02f..1f0adc71ec1f 100644 --- a/packages/eslint-plugin/docs/rules/return-await.md +++ b/packages/eslint-plugin/docs/rules/return-await.md @@ -4,95 +4,114 @@ Returning an awaited promise can make sense for better stack trace information a ## Rule Details -The `@typescript-eslint/return-await` rule specifies that awaiting a returned non-promise is never allowed. By default, the rule requires awaiting a returned promise in a `try-catch-finally` block and disallows returning an awaited promise in any other context. Optionally, the rule can require awaiting returned promises in all contexts, or disallow them in all contexts. +This rule builds on top of the [`eslint/no-return-await`](https://eslint.org/docs/rules/no-return-await) rule. +It expands upon the base rule to add support for optionally requiring `return await` in certain cases. + +## How to use + +```jsonc +{ + // note you must disable the base rule as it can report incorrect errors + "no-return-await": "off", + "@typescript-eslint/return-await": "error" +} +``` ## Options -`in-try-catch` (default): `await`-ing a returned promise is required in `try-catch-finally` blocks and disallowed elsewhere. +```ts +type Options = 'in-try-catch' | 'always' | 'never'; + +const defaultOptions: Options = 'in-try-catch'; +``` -`always`: `await`-ing a returned promise is required everywhere. +### `in-try-catch` -`never`: `await`-ing a returned promise is disallowed everywhere. +Requires that a returned promise must be `await`ed in `try-catch-finally` blocks, and disallows it elsewhere. -```typescript -// valid in-try-catch -async function validInTryCatch1() { +Examples of **incorrect** code with `in-try-catch`: + +```ts +async function invalidInTryCatch1() { try { - return await Promise.resolve('try'); + return Promise.resolve('try'); } catch (e) {} } -async function validInTryCatch2() { - return Promise.resolve('try'); +async function invalidInTryCatch2() { + return await Promise.resolve('try'); } -async function validInTryCatch3() { - return 'value'; +async function invalidInTryCatch3() { + return await 'value'; } +``` -// valid always -async function validAlways1() { +Examples of **correct** code with `in-try-catch`: + +```ts +async function validInTryCatch1() { try { return await Promise.resolve('try'); } catch (e) {} } -async function validAlways2() { - return await Promise.resolve('try'); +async function validInTryCatch2() { + return Promise.resolve('try'); } -async function validAlways3() { +async function validInTryCatch3() { return 'value'; } +``` -// valid never -async function validNever1() { +### `always` + +Requires that all returned promises are `await`ed. + +Examples of **incorrect** code with `always`: + +```ts +async function invalidAlways1() { try { return Promise.resolve('try'); } catch (e) {} } -async function validNever2() { +async function invalidAlways2() { return Promise.resolve('try'); } -async function validNever3() { - return 'value'; +async function invalidAlways3() { + return await 'value'; } ``` -```typescript -// invalid in-try-catch -async function invalidInTryCatch1() { +Examples of **correct** code with `always`: + +```ts +async function validAlways1() { try { - return Promise.resolve('try'); + return await Promise.resolve('try'); } catch (e) {} } -async function invalidInTryCatch2() { +async function validAlways2() { return await Promise.resolve('try'); } -async function invalidInTryCatch3() { - return await 'value'; +async function validAlways3() { + return 'value'; } +``` -// invalid always -async function invalidAlways1() { - try { - return Promise.resolve('try'); - } catch (e) {} -} +### `never` -async function invalidAlways2() { - return Promise.resolve('try'); -} +Disallows all `await`ing any returned promises. -async function invalidAlways3() { - return await 'value'; -} +Examples of **incorrect** code with `never`: -// invalid never +```ts async function invalidNever1() { try { return await Promise.resolve('try'); @@ -108,16 +127,20 @@ async function invalidNever3() { } ``` -The rule also applies to `finally` blocks. So the following would be invalid with default options: +Examples of **correct** code with `never`: -```typescript -async function invalid() { +```ts +async function validNever1() { try { - return await Promise.resolve('try'); - } catch (e) { - return Promise.resolve('catch'); - } finally { - // cleanup - } + return Promise.resolve('try'); + } catch (e) {} +} + +async function validNever2() { + return Promise.resolve('try'); +} + +async function validNever3() { + return 'value'; } ``` diff --git a/packages/eslint-plugin/docs/rules/semi.md b/packages/eslint-plugin/docs/rules/semi.md index bbb3154fa1a8..c233d3546316 100644 --- a/packages/eslint-plugin/docs/rules/semi.md +++ b/packages/eslint-plugin/docs/rules/semi.md @@ -5,15 +5,13 @@ This rule enforces consistent use of semicolons after statements. ## Rule Details This rule extends the base [`eslint/semi`](https://eslint.org/docs/rules/semi) rule. -It supports all options and features of the base rule. -This version adds support for numerous typescript features. +It adds support for TypeScript features that require semicolons. -See also the [`@typescript-eslint/member-delimiter-style`](member-delimiter-style.md) rule, -which allows you to specify the delimiter for `type` and `interface` members. +See also the [`@typescript-eslint/member-delimiter-style`](member-delimiter-style.md) rule, which allows you to specify the delimiter for `type` and `interface` members. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "semi": "off", diff --git a/packages/eslint-plugin/docs/rules/space-before-function-paren.md b/packages/eslint-plugin/docs/rules/space-before-function-paren.md index bfbcb22d8871..db2579e44d1b 100644 --- a/packages/eslint-plugin/docs/rules/space-before-function-paren.md +++ b/packages/eslint-plugin/docs/rules/space-before-function-paren.md @@ -1,33 +1,13 @@ # Enforces consistent spacing before function parenthesis (`space-before-function-paren`) -When formatting a function, whitespace is allowed between the function name or `function` keyword and the opening parenthesis. Named functions also require a space between the `function` keyword and the function name, but anonymous functions require no whitespace. For example: - - -```ts -function withoutSpace(x) { - // ... -} - -function withSpace (x) { - // ... -} - -var anonymousWithoutSpace = function() {}; - -var anonymousWithSpace = function () {}; -``` - -Style guides may require a space after the `function` keyword for anonymous functions, while others specify no whitespace. Similarly, the space after a function name may or may not be required. - ## Rule Details This rule extends the base [`eslint/space-before-function-paren`](https://eslint.org/docs/rules/space-before-function-paren) rule. -It supports all options and features of the base rule. -This version adds support for generic type parameters on function calls. +It adds support for generic type parameters on function calls. ## How to use -```cjson +```jsonc { // note you must disable the base rule as it can report incorrect errors "space-before-function-paren": "off", diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json index 290f200a0d3e..d872079514a8 100644 --- a/packages/eslint-plugin/package.json +++ b/packages/eslint-plugin/package.json @@ -1,6 +1,6 @@ { "name": "@typescript-eslint/eslint-plugin", - "version": "2.27.0", + "version": "2.28.0", "description": "TypeScript plugin for ESLint", "keywords": [ "eslint", @@ -41,7 +41,7 @@ "typecheck": "tsc -p tsconfig.json --noEmit" }, "dependencies": { - "@typescript-eslint/experimental-utils": "2.27.0", + "@typescript-eslint/experimental-utils": "2.28.0", "functional-red-black-tree": "^1.0.1", "regexpp": "^3.0.0", "tsutils": "^3.17.1" diff --git a/packages/eslint-plugin/src/configs/all.json b/packages/eslint-plugin/src/configs/all.json index cfcb38ced24f..c736840a3fff 100644 --- a/packages/eslint-plugin/src/configs/all.json +++ b/packages/eslint-plugin/src/configs/all.json @@ -63,6 +63,7 @@ "@typescript-eslint/no-unnecessary-qualifier": "error", "@typescript-eslint/no-unnecessary-type-arguments": "error", "@typescript-eslint/no-unnecessary-type-assertion": "error", + "@typescript-eslint/no-unsafe-assignment": "error", "@typescript-eslint/no-unsafe-call": "error", "@typescript-eslint/no-unsafe-member-access": "error", "@typescript-eslint/no-unsafe-return": "error", @@ -85,8 +86,10 @@ "@typescript-eslint/prefer-optional-chain": "error", "@typescript-eslint/prefer-readonly": "error", "@typescript-eslint/prefer-readonly-parameter-types": "error", + "@typescript-eslint/prefer-reduce-type-parameter": "error", "@typescript-eslint/prefer-regexp-exec": "error", "@typescript-eslint/prefer-string-starts-ends-with": "error", + "@typescript-eslint/prefer-ts-expect-error": "error", "@typescript-eslint/promise-function-async": "error", "quotes": "off", "@typescript-eslint/quotes": "error", diff --git a/packages/eslint-plugin/src/rules/ban-ts-comment.ts b/packages/eslint-plugin/src/rules/ban-ts-comment.ts index 53505cfea22d..a422349eefaa 100644 --- a/packages/eslint-plugin/src/rules/ban-ts-comment.ts +++ b/packages/eslint-plugin/src/rules/ban-ts-comment.ts @@ -2,6 +2,7 @@ import { AST_TOKEN_TYPES } from '@typescript-eslint/experimental-utils'; import * as util from '../util'; interface Options { + 'ts-expect-error'?: boolean; 'ts-ignore'?: boolean; 'ts-nocheck'?: boolean; 'ts-check'?: boolean; @@ -9,6 +10,7 @@ interface Options { const defaultOptions: [Options] = [ { + 'ts-expect-error': true, 'ts-ignore': true, 'ts-nocheck': true, 'ts-check': false, @@ -34,6 +36,10 @@ export default util.createRule<[Options], MessageIds>({ { type: 'object', properties: { + 'ts-expect-error': { + type: 'boolean', + default: true, + }, 'ts-ignore': { type: 'boolean', default: true, @@ -53,7 +59,7 @@ export default util.createRule<[Options], MessageIds>({ }, defaultOptions, create(context, [options]) { - const tsCommentRegExp = /^\/*\s*@ts-(ignore|check|nocheck)/; + const tsCommentRegExp = /^\/*\s*@ts-(expect-error|ignore|check|nocheck)/; const sourceCode = context.getSourceCode(); return { diff --git a/packages/eslint-plugin/src/rules/ban-ts-ignore.ts b/packages/eslint-plugin/src/rules/ban-ts-ignore.ts index 7551df8d0224..551bb0401a97 100644 --- a/packages/eslint-plugin/src/rules/ban-ts-ignore.ts +++ b/packages/eslint-plugin/src/rules/ban-ts-ignore.ts @@ -16,7 +16,7 @@ export default util.createRule({ 'Do not use "// @ts-ignore" comments because they suppress compilation errors.', }, deprecated: true, - replacedBy: ['@typescript-eslint/ban-ts-comment'], + replacedBy: ['ban-ts-comment'], }, defaultOptions: [], create(context) { diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts index ae54149d0a74..0620822f83c9 100644 --- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts +++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts @@ -75,10 +75,27 @@ export default util.createRule({ create(context, [options]) { const sourceCode = context.getSourceCode(); + function isConst(node: TSESTree.TypeNode): boolean { + if (node.type !== AST_NODE_TYPES.TSTypeReference) { + return false; + } + + return ( + node.typeName.type === AST_NODE_TYPES.Identifier && + node.typeName.name === 'const' + ); + } + function reportIncorrectAssertionType( node: TSESTree.TSTypeAssertion | TSESTree.TSAsExpression, ): void { + // If this node is `as const`, then don't report an error. + if (isConst(node.typeAnnotation)) { + return; + } + const messageId = options.assertionStyle; + context.report({ node, messageId, @@ -97,8 +114,7 @@ export default util.createRule({ case AST_NODE_TYPES.TSTypeReference: return ( // Ignore `as const` and `` - (node.typeName.type === AST_NODE_TYPES.Identifier && - node.typeName.name !== 'const') || + !isConst(node) || // Allow qualified names which have dots between identifiers, `Foo.Bar` node.typeName.type === AST_NODE_TYPES.TSQualifiedName ); diff --git a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts index b8ee7ff584b3..f0a5978d02f5 100644 --- a/packages/eslint-plugin/src/rules/explicit-function-return-type.ts +++ b/packages/eslint-plugin/src/rules/explicit-function-return-type.ts @@ -1,4 +1,7 @@ -import { TSESTree } from '@typescript-eslint/experimental-utils'; +import { + AST_NODE_TYPES, + TSESTree, +} from '@typescript-eslint/experimental-utils'; import * as util from '../util'; import { checkFunctionReturnType, @@ -11,6 +14,7 @@ type Options = [ allowTypedFunctionExpressions?: boolean; allowHigherOrderFunctions?: boolean; allowDirectConstAssertionInArrowFunctions?: boolean; + allowConciseArrowFunctionExpressionsStartingWithVoid?: boolean; }, ]; type MessageIds = 'missingReturnType'; @@ -44,6 +48,9 @@ export default util.createRule({ allowDirectConstAssertionInArrowFunctions: { type: 'boolean', }, + allowConciseArrowFunctionExpressionsStartingWithVoid: { + type: 'boolean', + }, }, additionalProperties: false, }, @@ -55,6 +62,7 @@ export default util.createRule({ allowTypedFunctionExpressions: true, allowHigherOrderFunctions: true, allowDirectConstAssertionInArrowFunctions: true, + allowConciseArrowFunctionExpressionsStartingWithVoid: false, }, ], create(context, [options]) { @@ -64,6 +72,16 @@ export default util.createRule({ 'ArrowFunctionExpression, FunctionExpression'( node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression, ): void { + if ( + options.allowConciseArrowFunctionExpressionsStartingWithVoid && + node.type === AST_NODE_TYPES.ArrowFunctionExpression && + node.expression && + node.body.type === AST_NODE_TYPES.UnaryExpression && + node.body.operator === 'void' + ) { + return; + } + checkFunctionExpressionReturnType(node, options, sourceCode, loc => context.report({ node, diff --git a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts index 55c6bd29f99e..b00d8eb1087e 100644 --- a/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts +++ b/packages/eslint-plugin/src/rules/explicit-module-boundary-types.ts @@ -1,6 +1,7 @@ import { TSESTree, AST_NODE_TYPES, + TSESLint, } from '@typescript-eslint/experimental-utils'; import * as util from '../util'; import { @@ -15,6 +16,7 @@ type Options = [ allowHigherOrderFunctions?: boolean; allowDirectConstAssertionInArrowFunctions?: boolean; allowedNames?: string[]; + shouldTrackReferences?: boolean; }, ]; type MessageIds = 'missingReturnType' | 'missingArgType'; @@ -52,6 +54,9 @@ export default util.createRule({ type: 'string', }, }, + shouldTrackReferences: { + type: 'boolean', + }, }, additionalProperties: false, }, @@ -63,6 +68,7 @@ export default util.createRule({ allowHigherOrderFunctions: true, allowDirectConstAssertionInArrowFunctions: true, allowedNames: [], + shouldTrackReferences: true, }, ], create(context, [options]) { @@ -171,50 +177,201 @@ export default util.createRule({ return false; } + /** + * Finds an array of a function expression node referred by a variable passed from parameters + */ + function findFunctionExpressionsInScope( + variable: TSESLint.Scope.Variable, + ): + | (TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression)[] + | undefined { + const writeExprs = variable.references + .map(ref => ref.writeExpr) + .filter( + ( + expr, + ): expr is + | TSESTree.ArrowFunctionExpression + | TSESTree.FunctionExpression => + expr?.type === AST_NODE_TYPES.FunctionExpression || + expr?.type === AST_NODE_TYPES.ArrowFunctionExpression, + ); + + return writeExprs; + } + + /** + * Finds a function node referred by a variable passed from parameters + */ + function findFunctionInScope( + variable: TSESLint.Scope.Variable, + ): TSESTree.FunctionDeclaration | undefined { + if (variable.defs[0].type !== 'FunctionName') { + return; + } + + const functionNode = variable.defs[0].node; + + if (functionNode?.type !== AST_NODE_TYPES.FunctionDeclaration) { + return; + } + + return functionNode; + } + + /** + * Checks if a function referred by the identifier passed from parameters follow the rule + */ + function checkWithTrackingReferences(node: TSESTree.Identifier): void { + const scope = context.getScope(); + const variable = scope.set.get(node.name); + + if (!variable) { + return; + } + + if (variable.defs[0].type === 'ClassName') { + const classNode = variable.defs[0].node; + for (const classElement of classNode.body.body) { + if ( + classElement.type === AST_NODE_TYPES.MethodDefinition && + classElement.value.type === AST_NODE_TYPES.FunctionExpression + ) { + checkFunctionExpression(classElement.value); + } + + if ( + classElement.type === AST_NODE_TYPES.ClassProperty && + (classElement.value?.type === AST_NODE_TYPES.FunctionExpression || + classElement.value?.type === + AST_NODE_TYPES.ArrowFunctionExpression) + ) { + checkFunctionExpression(classElement.value); + } + } + } + + const functionNode = findFunctionInScope(variable); + if (functionNode) { + checkFunction(functionNode); + } + + const functionExpressions = findFunctionExpressionsInScope(variable); + if (functionExpressions && functionExpressions.length > 0) { + for (const functionExpression of functionExpressions) { + checkFunctionExpression(functionExpression); + } + } + } + + /** + * Checks if a function expression follow the rule + */ + function checkFunctionExpression( + node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression, + ): void { + if ( + node.parent?.type === AST_NODE_TYPES.MethodDefinition && + node.parent.accessibility === 'private' + ) { + // don't check private methods as they aren't part of the public signature + return; + } + + if ( + isAllowedName(node.parent) || + isTypedFunctionExpression(node, options) + ) { + return; + } + + checkFunctionExpressionReturnType(node, options, sourceCode, loc => + context.report({ + node, + loc, + messageId: 'missingReturnType', + }), + ); + + checkArguments(node); + } + + /** + * Checks if a function follow the rule + */ + function checkFunction(node: TSESTree.FunctionDeclaration): void { + if (isAllowedName(node.parent)) { + return; + } + + checkFunctionReturnType(node, options, sourceCode, loc => + context.report({ + node, + loc, + messageId: 'missingReturnType', + }), + ); + + checkArguments(node); + } + return { 'ArrowFunctionExpression, FunctionExpression'( node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression, ): void { - if ( - node.parent?.type === AST_NODE_TYPES.MethodDefinition && - node.parent.accessibility === 'private' - ) { - // don't check private methods as they aren't part of the public signature + if (isUnexported(node)) { return; } - if ( - isAllowedName(node.parent) || - isUnexported(node) || - isTypedFunctionExpression(node, options) - ) { + checkFunctionExpression(node); + }, + FunctionDeclaration(node): void { + if (isUnexported(node)) { return; } - checkFunctionExpressionReturnType(node, options, sourceCode, loc => - context.report({ - node, - loc, - messageId: 'missingReturnType', - }), - ); - - checkArguments(node); + checkFunction(node); }, - FunctionDeclaration(node): void { - if (isAllowedName(node.parent) || isUnexported(node)) { + 'ExportDefaultDeclaration, TSExportAssignment'( + node: TSESTree.ExportDefaultDeclaration | TSESTree.TSExportAssignment, + ): void { + if (!options.shouldTrackReferences) { return; } - checkFunctionReturnType(node, options, sourceCode, loc => - context.report({ - node, - loc, - messageId: 'missingReturnType', - }), - ); + let exported: TSESTree.Node; + + if (node.type === AST_NODE_TYPES.ExportDefaultDeclaration) { + exported = node.declaration; + } else { + exported = node.expression; + } - checkArguments(node); + switch (exported.type) { + case AST_NODE_TYPES.Identifier: { + checkWithTrackingReferences(exported); + break; + } + case AST_NODE_TYPES.ArrayExpression: { + for (const element of exported.elements) { + if (element.type === AST_NODE_TYPES.Identifier) { + checkWithTrackingReferences(element); + } + } + break; + } + case AST_NODE_TYPES.ObjectExpression: { + for (const property of exported.properties) { + if ( + property.type === AST_NODE_TYPES.Property && + property.value.type === AST_NODE_TYPES.Identifier + ) { + checkWithTrackingReferences(property.value); + } + } + break; + } + } }, }; }, diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts index 332c706c832c..901d31a8b9fb 100644 --- a/packages/eslint-plugin/src/rules/index.ts +++ b/packages/eslint-plugin/src/rules/index.ts @@ -55,6 +55,7 @@ import noUnnecessaryCondition from './no-unnecessary-condition'; import noUnnecessaryQualifier from './no-unnecessary-qualifier'; import noUnnecessaryTypeArguments from './no-unnecessary-type-arguments'; import noUnnecessaryTypeAssertion from './no-unnecessary-type-assertion'; +import noUnsafeAssignment from './no-unsafe-assignment'; import noUnsafeCall from './no-unsafe-call'; import noUnsafeMemberAccess from './no-unsafe-member-access'; import noUnsafeReturn from './no-unsafe-return'; @@ -74,8 +75,10 @@ import preferNullishCoalescing from './prefer-nullish-coalescing'; import preferOptionalChain from './prefer-optional-chain'; import preferReadonly from './prefer-readonly'; import preferReadonlyParameterTypes from './prefer-readonly-parameter-types'; +import preferReduceTypeParameter from './prefer-reduce-type-parameter'; import preferRegexpExec from './prefer-regexp-exec'; import preferStringStartsEndsWith from './prefer-string-starts-ends-with'; +import preferTsExpectError from './prefer-ts-expect-error'; import promiseFunctionAsync from './promise-function-async'; import quotes from './quotes'; import requireArraySortCompare from './require-array-sort-compare'; @@ -151,6 +154,7 @@ export default { 'no-unnecessary-qualifier': noUnnecessaryQualifier, 'no-unnecessary-type-arguments': noUnnecessaryTypeArguments, 'no-unnecessary-type-assertion': noUnnecessaryTypeAssertion, + 'no-unsafe-assignment': noUnsafeAssignment, 'no-unsafe-call': noUnsafeCall, 'no-unsafe-member-access': noUnsafeMemberAccess, 'no-unsafe-return': noUnsafeReturn, @@ -170,8 +174,10 @@ export default { 'prefer-optional-chain': preferOptionalChain, 'prefer-readonly-parameter-types': preferReadonlyParameterTypes, 'prefer-readonly': preferReadonly, + 'prefer-reduce-type-parameter': preferReduceTypeParameter, 'prefer-regexp-exec': preferRegexpExec, 'prefer-string-starts-ends-with': preferStringStartsEndsWith, + 'prefer-ts-expect-error': preferTsExpectError, 'promise-function-async': promiseFunctionAsync, quotes: quotes, 'require-array-sort-compare': requireArraySortCompare, diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts index 6ef8db5a0c9b..2d6366bbda13 100644 --- a/packages/eslint-plugin/src/rules/method-signature-style.ts +++ b/packages/eslint-plugin/src/rules/method-signature-style.ts @@ -4,11 +4,10 @@ import { } from '@typescript-eslint/experimental-utils'; import * as util from '../util'; -export type Options = ['property' | 'method']; +export type Options = [('property' | 'method')?]; +export type MessageIds = 'errorMethod' | 'errorProperty'; -export type MessageId = 'errorMethod' | 'errorProperty'; - -export default util.createRule({ +export default util.createRule({ name: 'method-signature-style', meta: { type: 'suggestion', @@ -56,10 +55,21 @@ export default util.createRule({ ): string { let params = '()'; if (node.params.length > 0) { + const openingParen = util.nullThrows( + sourceCode.getTokenBefore(node.params[0], util.isOpeningParenToken), + 'Missing opening paren before first parameter', + ); + const closingParen = util.nullThrows( + sourceCode.getTokenAfter( + node.params[node.params.length - 1], + util.isClosingParenToken, + ), + 'Missing closing paren after last parameter', + ); + params = sourceCode.text.substring( - sourceCode.getTokenBefore(node.params[0])!.range[0], - sourceCode.getTokenAfter(node.params[node.params.length - 1])! - .range[1], + openingParen.range[0], + closingParen.range[1], ); } if (node.typeParameters != null) { @@ -75,6 +85,18 @@ export default util.createRule({ return sourceCode.getText(node.returnType!.typeAnnotation); } + function getDelimiter(node: TSESTree.Node): string { + const lastToken = sourceCode.getLastToken(node); + if ( + lastToken && + (util.isSemicolonToken(lastToken) || util.isCommaToken(lastToken)) + ) { + return lastToken.value; + } + + return ''; + } + return { TSMethodSignature(methodNode): void { if (mode === 'method') { @@ -88,9 +110,10 @@ export default util.createRule({ const key = getMethodKey(methodNode); const params = getMethodParams(methodNode); const returnType = getMethodReturnType(methodNode); + const delimiter = getDelimiter(methodNode); return fixer.replaceText( methodNode, - `${key}: ${params} => ${returnType}`, + `${key}: ${params} => ${returnType}${delimiter}`, ); }, }); @@ -112,9 +135,10 @@ export default util.createRule({ const key = getMethodKey(propertyNode); const params = getMethodParams(typeNode); const returnType = getMethodReturnType(typeNode); + const delimiter = getDelimiter(propertyNode); return fixer.replaceText( propertyNode, - `${key}${params}: ${returnType}`, + `${key}${params}: ${returnType}${delimiter}`, ); }, }); diff --git a/packages/eslint-plugin/src/rules/no-base-to-string.ts b/packages/eslint-plugin/src/rules/no-base-to-string.ts index 98a37c740849..47803f8e2aa4 100644 --- a/packages/eslint-plugin/src/rules/no-base-to-string.ts +++ b/packages/eslint-plugin/src/rules/no-base-to-string.ts @@ -12,7 +12,14 @@ enum Usefulness { Sometimes = 'may', } -export default util.createRule({ +type Options = [ + { + ignoreTaggedTemplateExpressions?: boolean; + }, +]; +type MessageIds = 'baseToString'; + +export default util.createRule({ name: 'no-base-to-string', meta: { docs: { @@ -26,11 +33,22 @@ export default util.createRule({ baseToString: "'{{name}} {{certainty}} evaluate to '[object Object]' when stringified.", }, - schema: [], + schema: [ + { + type: 'object', + properties: { + ignoreTaggedTemplateExpressions: { + type: 'boolean', + default: false, + }, + }, + additionalProperties: false, + }, + ], type: 'suggestion', }, - defaultOptions: [], - create(context) { + defaultOptions: [{ ignoreTaggedTemplateExpressions: false }], + create(context, [options]) { const parserServices = util.getParserServices(context); const typeChecker = parserServices.program.getTypeChecker(); @@ -110,8 +128,14 @@ export default util.createRule({ const memberExpr = node.parent as TSESTree.MemberExpression; checkExpression(memberExpr.object); }, - TemplateLiteral(node: TSESTree.TemplateLiteral): void { + if ( + options.ignoreTaggedTemplateExpressions && + node.parent && + node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression + ) { + return; + } for (const expression of node.expressions) { checkExpression(expression); } diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts index 039415ad68f4..d279e9bd4f61 100644 --- a/packages/eslint-plugin/src/rules/no-empty-interface.ts +++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts @@ -1,4 +1,8 @@ import * as util from '../util'; +import { + AST_NODE_TYPES, + TSESLint, +} from '@typescript-eslint/experimental-utils'; type Options = [ { @@ -43,6 +47,7 @@ export default util.createRule({ return { TSInterfaceDeclaration(node): void { const sourceCode = context.getSourceCode(); + const filename = context.getFilename(); if (node.body.body.length !== 0) { // interface contains members --> Nothing to report @@ -58,16 +63,46 @@ export default util.createRule({ } else if (extend.length === 1) { // interface extends exactly 1 interface --> Report depending on rule setting if (!allowSingleExtends) { + const fix = (fixer: TSESLint.RuleFixer): TSESLint.RuleFix => { + let typeParam = ''; + if (node.typeParameters) { + typeParam = sourceCode.getText(node.typeParameters); + } + return fixer.replaceText( + node, + `type ${sourceCode.getText( + node.id, + )}${typeParam} = ${sourceCode.getText(extend[0])}`, + ); + }; + + // Check if interface is within ambient declaration + let useAutoFix = true; + if (util.isDefinitionFile(filename)) { + const scope = context.getScope(); + if ( + scope.block.parent && + scope.block.parent.type === + AST_NODE_TYPES.TSModuleDeclaration && + scope.block.parent.declare + ) { + useAutoFix = false; + } + } + context.report({ node: node.id, messageId: 'noEmptyWithSuper', - fix: fixer => - fixer.replaceText( - node, - `type ${sourceCode.getText(node.id)} = ${sourceCode.getText( - extend[0], - )}`, - ), + ...(useAutoFix + ? { fix } + : { + suggest: [ + { + messageId: 'noEmptyWithSuper', + fix, + }, + ], + }), }); } } diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts index 511b744ee4c0..f89d2ffd08d7 100644 --- a/packages/eslint-plugin/src/rules/no-for-in-array.ts +++ b/packages/eslint-plugin/src/rules/no-for-in-array.ts @@ -25,11 +25,13 @@ export default util.createRule({ const checker = parserServices.program.getTypeChecker(); const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node); - const type = checker.getTypeAtLocation(originalNode.expression); + const type = util.getConstrainedTypeAtLocation( + checker, + originalNode.expression, + ); if ( - (typeof type.symbol !== 'undefined' && - type.symbol.name === 'Array') || + util.isTypeArrayTypeOrUnionOfArrayTypes(type, checker) || (type.flags & ts.TypeFlags.StringLike) !== 0 ) { context.report({ diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts new file mode 100644 index 000000000000..60f7b78acc08 --- /dev/null +++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts @@ -0,0 +1,370 @@ +import { + TSESTree, + AST_NODE_TYPES, +} from '@typescript-eslint/experimental-utils'; +import * as ts from 'typescript'; +import * as util from '../util'; + +const enum ComparisonType { + /** Do no assignment comparison */ + None, + /** Use the receiver's type for comparison */ + Basic, + /** Use the sender's contextual type for comparison */ + Contextual, +} + +export default util.createRule({ + name: 'no-unsafe-assignment', + meta: { + type: 'problem', + docs: { + description: 'Disallows assigning any to variables and properties', + category: 'Possible Errors', + recommended: false, + requiresTypeChecking: true, + }, + messages: { + anyAssignment: 'Unsafe assignment of an any value', + unsafeArrayPattern: 'Unsafe array destructuring of an any array value', + unsafeArrayPatternFromTuple: + 'Unsafe array destructuring of a tuple element with an any value', + unsafeAssignment: + 'Unsafe asignment of type {{sender}} to a variable of type {{receiver}}', + unsafeArraySpread: 'Unsafe spread of an any value in an array', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const { program, esTreeNodeToTSNodeMap } = util.getParserServices(context); + const checker = program.getTypeChecker(); + + // returns true if the assignment reported + function checkArrayDestructureHelper( + receiverNode: TSESTree.Node, + senderNode: TSESTree.Node, + ): boolean { + if (receiverNode.type !== AST_NODE_TYPES.ArrayPattern) { + return false; + } + + const senderTsNode = esTreeNodeToTSNodeMap.get(senderNode); + const senderType = checker.getTypeAtLocation(senderTsNode); + + return checkArrayDestructure(receiverNode, senderType, senderTsNode); + } + + // returns true if the assignment reported + function checkArrayDestructure( + receiverNode: TSESTree.ArrayPattern, + senderType: ts.Type, + senderNode: ts.Node, + ): boolean { + // any array + // const [x] = ([] as any[]); + if (util.isTypeAnyArrayType(senderType, checker)) { + context.report({ + node: receiverNode, + messageId: 'unsafeArrayPattern', + }); + return false; + } + + if (!checker.isTupleType(senderType)) { + return true; + } + + const tupleElements = util.getTypeArguments(senderType, checker); + + // tuple with any + // const [x] = [1 as any]; + let didReport = false; + for ( + let receiverIndex = 0; + receiverIndex < receiverNode.elements.length; + receiverIndex += 1 + ) { + const receiverElement = receiverNode.elements[receiverIndex]; + if (!receiverElement) { + continue; + } + + if (receiverElement.type === AST_NODE_TYPES.RestElement) { + // don't handle rests as they're not a 1:1 assignment + continue; + } + + const senderType = tupleElements[receiverIndex] as ts.Type | undefined; + if (!senderType) { + continue; + } + + // check for the any type first so we can handle [[[x]]] = [any] + if (util.isTypeAnyType(senderType)) { + context.report({ + node: receiverElement, + messageId: 'unsafeArrayPatternFromTuple', + }); + // we want to report on every invalid element in the tuple + didReport = true; + } else if (receiverElement.type === AST_NODE_TYPES.ArrayPattern) { + didReport = checkArrayDestructure( + receiverElement, + senderType, + senderNode, + ); + } else if (receiverElement.type === AST_NODE_TYPES.ObjectPattern) { + didReport = checkObjectDestructure( + receiverElement, + senderType, + senderNode, + ); + } + } + + return didReport; + } + + // returns true if the assignment reported + function checkObjectDestructureHelper( + receiverNode: TSESTree.Node, + senderNode: TSESTree.Node, + ): boolean { + if (receiverNode.type !== AST_NODE_TYPES.ObjectPattern) { + return false; + } + + const senderTsNode = esTreeNodeToTSNodeMap.get(senderNode); + const senderType = checker.getTypeAtLocation(senderTsNode); + + return checkObjectDestructure(receiverNode, senderType, senderTsNode); + } + + // returns true if the assignment reported + function checkObjectDestructure( + receiverNode: TSESTree.ObjectPattern, + senderType: ts.Type, + senderNode: ts.Node, + ): boolean { + const properties = new Map( + senderType + .getProperties() + .map(property => [ + property.getName(), + checker.getTypeOfSymbolAtLocation(property, senderNode), + ]), + ); + + let didReport = false; + for ( + let receiverIndex = 0; + receiverIndex < receiverNode.properties.length; + receiverIndex += 1 + ) { + const receiverProperty = receiverNode.properties[receiverIndex]; + if (receiverProperty.type === AST_NODE_TYPES.RestElement) { + // don't bother checking rest + continue; + } + + let key: string; + if (receiverProperty.computed === false) { + key = + receiverProperty.key.type === AST_NODE_TYPES.Identifier + ? receiverProperty.key.name + : String(receiverProperty.key.value); + } else if (receiverProperty.key.type === AST_NODE_TYPES.Literal) { + key = String(receiverProperty.key.value); + } else if ( + receiverProperty.key.type === AST_NODE_TYPES.TemplateLiteral && + receiverProperty.key.quasis.length === 1 + ) { + key = String(receiverProperty.key.quasis[0].value.cooked); + } else { + // can't figure out the name, so skip it + continue; + } + + const senderType = properties.get(key); + if (!senderType) { + continue; + } + + // check for the any type first so we can handle {x: {y: z}} = {x: any} + if (util.isTypeAnyType(senderType)) { + context.report({ + node: receiverProperty.value, + messageId: 'unsafeArrayPatternFromTuple', + }); + didReport = true; + } else if ( + receiverProperty.value.type === AST_NODE_TYPES.ArrayPattern + ) { + didReport = checkArrayDestructure( + receiverProperty.value, + senderType, + senderNode, + ); + } else if ( + receiverProperty.value.type === AST_NODE_TYPES.ObjectPattern + ) { + didReport = checkObjectDestructure( + receiverProperty.value, + senderType, + senderNode, + ); + } + } + + return didReport; + } + + // returns true if the assignment reported + function checkAssignment( + receiverNode: TSESTree.Node, + senderNode: TSESTree.Expression, + reportingNode: TSESTree.Node, + comparisonType: ComparisonType, + ): boolean { + const receiverTsNode = esTreeNodeToTSNodeMap.get(receiverNode); + const receiverType = + comparisonType === ComparisonType.Contextual + ? util.getContextualType(checker, receiverTsNode as ts.Expression) ?? + checker.getTypeAtLocation(receiverTsNode) + : checker.getTypeAtLocation(receiverTsNode); + const senderType = checker.getTypeAtLocation( + esTreeNodeToTSNodeMap.get(senderNode), + ); + + if (util.isTypeAnyType(senderType)) { + context.report({ + node: reportingNode, + messageId: 'anyAssignment', + }); + return true; + } + + if (comparisonType === ComparisonType.None) { + return false; + } + + const result = util.isUnsafeAssignment(senderType, receiverType, checker); + if (!result) { + return false; + } + + const { sender, receiver } = result; + context.report({ + node: reportingNode, + messageId: 'unsafeAssignment', + data: { + sender: checker.typeToString(sender), + receiver: checker.typeToString(receiver), + }, + }); + return true; + } + + function getComparisonType( + typeAnnotation: TSESTree.TSTypeAnnotation | undefined, + ): ComparisonType { + return typeAnnotation + ? // if there's a type annotation, we can do a comparison + ComparisonType.Basic + : // no type annotation means the variable's type will just be inferred, thus equal + ComparisonType.None; + } + + return { + 'VariableDeclarator[init != null]'( + node: TSESTree.VariableDeclarator, + ): void { + const init = util.nullThrows( + node.init, + util.NullThrowsReasons.MissingToken(node.type, 'init'), + ); + let didReport = checkAssignment( + node.id, + init, + node, + getComparisonType(node.id.typeAnnotation), + ); + + if (!didReport) { + didReport = checkArrayDestructureHelper(node.id, init); + } + if (!didReport) { + checkObjectDestructureHelper(node.id, init); + } + }, + 'ClassProperty[value != null]'(node: TSESTree.ClassProperty): void { + checkAssignment( + node.key, + node.value!, + node, + getComparisonType(node.typeAnnotation), + ); + }, + 'AssignmentExpression[operator = "="], AssignmentPattern'( + node: TSESTree.AssignmentExpression | TSESTree.AssignmentPattern, + ): void { + let didReport = checkAssignment( + node.left, + node.right, + node, + // the variable already has some form of a type to compare against + ComparisonType.Basic, + ); + + if (!didReport) { + didReport = checkArrayDestructureHelper(node.left, node.right); + } + if (!didReport) { + checkObjectDestructureHelper(node.left, node.right); + } + }, + // object pattern props are checked via assignments + ':not(ObjectPattern) > Property'(node: TSESTree.Property): void { + if (node.value.type === AST_NODE_TYPES.AssignmentPattern) { + // handled by other selector + return; + } + + checkAssignment(node.key, node.value, node, ComparisonType.Contextual); + }, + 'ArrayExpression > SpreadElement'(node: TSESTree.SpreadElement): void { + const resetNode = esTreeNodeToTSNodeMap.get(node.argument); + const restType = checker.getTypeAtLocation(resetNode); + if ( + util.isTypeAnyType(restType) || + util.isTypeAnyArrayType(restType, checker) + ) { + context.report({ + node: node, + messageId: 'unsafeArraySpread', + }); + } + }, + 'JSXAttribute[value != null]'(node: TSESTree.JSXAttribute): void { + const value = util.nullThrows( + node.value, + util.NullThrowsReasons.MissingToken(node.type, 'value'), + ); + if ( + value.type !== AST_NODE_TYPES.JSXExpressionContainer || + value.expression.type === AST_NODE_TYPES.JSXEmptyExpression + ) { + return; + } + + checkAssignment( + node.name, + value.expression, + value.expression, + ComparisonType.Contextual, + ); + }, + }; + }, +}); diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts index 66f66448c28b..3661bd44f16d 100644 --- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts +++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts @@ -31,7 +31,8 @@ export default util.createRule<[], MessageIds>({ messageId: MessageIds, ): void { const tsNode = esTreeNodeToTSNodeMap.get(node); - const type = checker.getTypeAtLocation(tsNode); + const type = util.getConstrainedTypeAtLocation(checker, tsNode); + if (util.isTypeAnyType(type)) { context.report({ node: reportingNode, diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts index fef04cd6365f..5fbbfac9b908 100644 --- a/packages/eslint-plugin/src/rules/no-unsafe-return.ts +++ b/packages/eslint-plugin/src/rules/no-unsafe-return.ts @@ -74,7 +74,8 @@ export default util.createRule({ } // function has an explicit return type, so ensure it's a safe return - const returnNodeType = checker.getTypeAtLocation( + const returnNodeType = util.getConstrainedTypeAtLocation( + checker, esTreeNodeToTSNodeMap.get(returnNode), ); const functionTSNode = esTreeNodeToTSNodeMap.get(functionNode); diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts new file mode 100644 index 000000000000..7b63125e7430 --- /dev/null +++ b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts @@ -0,0 +1,104 @@ +import { + AST_NODE_TYPES, + TSESTree, +} from '@typescript-eslint/experimental-utils'; +import * as util from '../util'; + +type MemberExpressionWithCallExpressionParent = ( + | TSESTree.MemberExpression + | TSESTree.OptionalMemberExpression +) & { parent: TSESTree.CallExpression | TSESTree.OptionalCallExpression }; + +const getMemberExpressionName = ( + member: TSESTree.MemberExpression | TSESTree.OptionalMemberExpression, +): string | null => { + if (!member.computed) { + return member.property.name; + } + + if ( + member.property.type === AST_NODE_TYPES.Literal && + typeof member.property.value === 'string' + ) { + return member.property.value; + } + + return null; +}; + +export default util.createRule({ + name: 'prefer-reduce-type-parameter', + meta: { + type: 'problem', + docs: { + category: 'Best Practices', + recommended: false, + description: + 'Prefer using type parameter when calling `Array#reduce` instead of casting', + requiresTypeChecking: true, + }, + messages: { + preferTypeParameter: + 'Unnecessary cast: Array#reduce accepts a type parameter for the default value.', + }, + fixable: 'code', + schema: [], + }, + defaultOptions: [], + create(context) { + const service = util.getParserServices(context); + const checker = service.program.getTypeChecker(); + + return { + ':matches(CallExpression, OptionalCallExpression) > :matches(MemberExpression, OptionalMemberExpression).callee'( + callee: MemberExpressionWithCallExpressionParent, + ): void { + if (getMemberExpressionName(callee) !== 'reduce') { + return; + } + + const [, secondArg] = callee.parent.arguments; + + if ( + callee.parent.arguments.length < 2 || + !util.isTypeAssertion(secondArg) + ) { + return; + } + + // Get the symbol of the `reduce` method. + const tsNode = service.esTreeNodeToTSNodeMap.get(callee.object); + const calleeObjType = util.getConstrainedTypeAtLocation( + checker, + tsNode, + ); + + // Check the owner type of the `reduce` method. + if (checker.isArrayType(calleeObjType)) { + context.report({ + messageId: 'preferTypeParameter', + node: secondArg, + fix: fixer => [ + fixer.removeRange([ + secondArg.range[0], + secondArg.expression.range[0], + ]), + fixer.removeRange([ + secondArg.expression.range[1], + secondArg.range[1], + ]), + fixer.insertTextAfter( + callee, + `<${context + .getSourceCode() + .getText(secondArg.typeAnnotation)}>`, + ), + ], + }); + + return; + } + }, + }; + }, +}); diff --git a/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts new file mode 100644 index 000000000000..1b87b1327861 --- /dev/null +++ b/packages/eslint-plugin/src/rules/prefer-ts-expect-error.ts @@ -0,0 +1,55 @@ +import { AST_TOKEN_TYPES } from '@typescript-eslint/experimental-utils'; +import * as util from '../util'; + +type MessageIds = 'preferExpectErrorComment'; + +export default util.createRule<[], MessageIds>({ + name: 'prefer-ts-expect-error', + meta: { + type: 'problem', + docs: { + description: + 'Recommends using `// @ts-expect-error` over `// @ts-ignore`', + category: 'Best Practices', + recommended: false, + }, + fixable: 'code', + messages: { + preferExpectErrorComment: + 'Use "// @ts-expect-error" to ensure an error is actually being suppressed.', + }, + schema: [], + }, + defaultOptions: [], + create(context) { + const tsIgnoreRegExp = /^\/*\s*@ts-ignore/; + const sourceCode = context.getSourceCode(); + + return { + Program(): void { + const comments = sourceCode.getAllComments(); + + comments.forEach(comment => { + if (comment.type !== AST_TOKEN_TYPES.Line) { + return; + } + + if (tsIgnoreRegExp.test(comment.value)) { + context.report({ + node: comment, + messageId: 'preferExpectErrorComment', + fix: fixer => + fixer.replaceText( + comment, + `//${comment.value.replace( + '@ts-ignore', + '@ts-expect-error', + )}`, + ), + }); + } + }); + }, + }; + }, +}); diff --git a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts index 25c4c2e57475..2f388d364dd7 100644 --- a/packages/eslint-plugin/src/rules/require-array-sort-compare.ts +++ b/packages/eslint-plugin/src/rules/require-array-sort-compare.ts @@ -1,5 +1,4 @@ import { TSESTree } from '@typescript-eslint/experimental-utils'; -import * as ts from 'typescript'; import * as util from '../util'; export default util.createRule({ @@ -27,26 +26,16 @@ export default util.createRule({ return { ":matches(CallExpression, OptionalCallExpression)[arguments.length=0] > :matches(MemberExpression, OptionalMemberExpression)[property.name='sort'][computed=false]"( - node: TSESTree.MemberExpression | TSESTree.OptionalMemberExpression, + callee: TSESTree.MemberExpression | TSESTree.OptionalMemberExpression, ): void { - // Get the symbol of the `sort` method. - const tsNode = service.esTreeNodeToTSNodeMap.get(node); - const sortSymbol = checker.getSymbolAtLocation(tsNode); - if (sortSymbol == null) { - return; - } + const tsNode = service.esTreeNodeToTSNodeMap.get(callee.object); + const calleeObjType = util.getConstrainedTypeAtLocation( + checker, + tsNode, + ); - // Check the owner type of the `sort` method. - for (const methodDecl of sortSymbol.declarations) { - const typeDecl = methodDecl.parent; - if ( - ts.isInterfaceDeclaration(typeDecl) && - ts.isSourceFile(typeDecl.parent) && - typeDecl.name.escapedText === 'Array' - ) { - context.report({ node: node.parent!, messageId: 'requireCompare' }); - return; - } + if (util.isTypeArrayTypeOrUnionOfArrayTypes(calleeObjType, checker)) { + context.report({ node: callee.parent!, messageId: 'requireCompare' }); } }, }; diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts index a833825a207c..2702009046ff 100644 --- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts +++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts @@ -54,16 +54,6 @@ export default util.createRule({ * Helper function to get base type of node */ function getBaseTypeOfLiteralType(type: ts.Type): BaseLiteral { - const constraint = type.getConstraint(); - if ( - constraint && - // for generic types with union constraints, it will return itself from getConstraint - // so we have to guard against infinite recursion... - constraint !== type - ) { - return getBaseTypeOfLiteralType(constraint); - } - if (type.isNumberLiteral()) { return 'number'; } @@ -98,7 +88,7 @@ export default util.createRule({ */ function getNodeType(node: TSESTree.Expression): BaseLiteral { const tsNode = service.esTreeNodeToTSNodeMap.get(node); - const type = typeChecker.getTypeAtLocation(tsNode); + const type = util.getConstrainedTypeAtLocation(typeChecker, tsNode); return getBaseTypeOfLiteralType(type); } diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts index 6ff1627daf50..d73d8d98a254 100644 --- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts +++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts @@ -10,6 +10,7 @@ type Options = [ allowNullable?: boolean; allowNumber?: boolean; allowBoolean?: boolean; + allowAny?: boolean; }, ]; @@ -32,6 +33,7 @@ export default util.createRule({ { type: 'object', properties: { + allowAny: { type: 'boolean' }, allowBoolean: { type: 'boolean' }, allowNullable: { type: 'boolean' }, allowNumber: { type: 'boolean' }, @@ -51,6 +53,7 @@ export default util.createRule({ | 'boolean' | 'null' | 'undefined' + | 'any' | 'other'; const allowedTypes: BaseType[] = [ @@ -58,6 +61,7 @@ export default util.createRule({ ...(options.allowNumber ? (['number', 'bigint'] as const) : []), ...(options.allowBoolean ? (['boolean'] as const) : []), ...(options.allowNullable ? (['null', 'undefined'] as const) : []), + ...(options.allowAny ? (['any'] as const) : []), ]; function isAllowedType(types: BaseType[]): boolean { @@ -94,21 +98,12 @@ export default util.createRule({ */ function getNodeType(node: TSESTree.Expression): BaseType[] { const tsNode = service.esTreeNodeToTSNodeMap.get(node); - const type = typeChecker.getTypeAtLocation(tsNode); + const type = util.getConstrainedTypeAtLocation(typeChecker, tsNode); return getBaseType(type); } function getBaseType(type: ts.Type): BaseType[] { - const constraint = type.getConstraint(); - if ( - constraint && - // for generic types with union constraints, it will return itself - constraint !== type - ) { - return getBaseType(constraint); - } - if (type.isStringLiteral()) { return ['string']; } @@ -127,6 +122,9 @@ export default util.createRule({ if (type.flags & ts.TypeFlags.Undefined) { return ['undefined']; } + if (type.flags & ts.TypeFlags.Any) { + return ['any']; + } if (type.isUnion()) { return type.types @@ -139,7 +137,8 @@ export default util.createRule({ stringType === 'string' || stringType === 'number' || stringType === 'bigint' || - stringType === 'boolean' + stringType === 'boolean' || + stringType === 'any' ) { return [stringType]; } diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts index 1e9cb9131ada..fde58dc4e6fa 100644 --- a/packages/eslint-plugin/src/rules/unbound-method.ts +++ b/packages/eslint-plugin/src/rules/unbound-method.ts @@ -198,6 +198,11 @@ function isDangerousMethod(symbol: ts.Symbol, ignoreStatic: boolean): boolean { } switch (valueDeclaration.kind) { + case ts.SyntaxKind.PropertyDeclaration: + return ( + (valueDeclaration as ts.PropertyDeclaration).initializer?.kind === + ts.SyntaxKind.FunctionExpression + ); case ts.SyntaxKind.MethodDeclaration: case ts.SyntaxKind.MethodSignature: return !( @@ -241,6 +246,9 @@ function isSafeUse(node: TSESTree.Node): boolean { case AST_NODE_TYPES.BinaryExpression: return ['instanceof', '==', '!=', '===', '!=='].includes(parent.operator); + case AST_NODE_TYPES.AssignmentExpression: + return parent.operator === '=' && node === parent.left; + case AST_NODE_TYPES.TSNonNullExpression: case AST_NODE_TYPES.TSAsExpression: case AST_NODE_TYPES.TSTypeAssertion: diff --git a/packages/eslint-plugin/src/util/types.ts b/packages/eslint-plugin/src/util/types.ts index f602a1e6a27d..261c154361b1 100644 --- a/packages/eslint-plugin/src/util/types.ts +++ b/packages/eslint-plugin/src/util/types.ts @@ -1,6 +1,7 @@ import { isCallExpression, isJsxExpression, + isIdentifier, isNewExpression, isParameterDeclaration, isPropertyDeclaration, @@ -8,9 +9,27 @@ import { isUnionOrIntersectionType, isVariableDeclaration, unionTypeParts, + isPropertyAssignment, } from 'tsutils'; import * as ts from 'typescript'; +/** + * Checks if the given type is either an array type, + * or a union made up solely of array types. + */ +export function isTypeArrayTypeOrUnionOfArrayTypes( + type: ts.Type, + checker: ts.TypeChecker, +): boolean { + for (const t of unionTypeParts(type)) { + if (!checker.isArrayType(t)) { + return false; + } + } + + return true; +} + /** * @param type Type being checked by name. * @param allowedNames Symbol names checking on the type. @@ -297,6 +316,18 @@ export function getEqualsKind(operator: string): EqualsKind | undefined { } } +export function getTypeArguments( + type: ts.TypeReference, + checker: ts.TypeChecker, +): readonly ts.Type[] { + // getTypeArguments was only added in TS3.7 + if (checker.getTypeArguments) { + return checker.getTypeArguments(type); + } + + return type.typeArguments ?? []; +} + /** * @returns true if the type is `any` */ @@ -304,6 +335,22 @@ export function isTypeAnyType(type: ts.Type): boolean { return isTypeFlagSet(type, ts.TypeFlags.Any); } +/** + * @returns true if the type is `any[]` + */ +export function isTypeAnyArrayType( + type: ts.Type, + checker: ts.TypeChecker, +): boolean { + return ( + checker.isArrayType(type) && + isTypeAnyType( + // getTypeArguments was only added in TS3.7 + getTypeArguments(type, checker)[0], + ) + ); +} + export const enum AnyType { Any, AnyArray, @@ -321,15 +368,7 @@ export function isAnyOrAnyArrayTypeDiscriminated( if (isTypeAnyType(type)) { return AnyType.Any; } - if ( - checker.isArrayType(type) && - isTypeAnyType( - // getTypeArguments was only added in TS3.7 - checker.getTypeArguments - ? checker.getTypeArguments(type)[0] - : (type.typeArguments ?? [])[0], - ) - ) { + if (isTypeAnyArrayType(type, checker)) { return AnyType.AnyArray; } return AnyType.Safe; @@ -350,6 +389,10 @@ export function isUnsafeAssignment( receiver: ts.Type, checker: ts.TypeChecker, ): false | { sender: ts.Type; receiver: ts.Type } { + if (isTypeAnyType(type) && !isTypeAnyType(receiver)) { + return { sender: type, receiver }; + } + if (isTypeReference(type) && isTypeReference(receiver)) { // TODO - figure out how to handle cases like this, // where the types are assignable, but not the same type @@ -386,9 +429,6 @@ export function isUnsafeAssignment( return false; } - if (isTypeAnyType(type) && !isTypeAnyType(receiver)) { - return { sender: type, receiver }; - } return false; } @@ -419,6 +459,8 @@ export function getContextualType( return parent.type ? checker.getTypeFromTypeNode(parent.type) : undefined; } else if (isJsxExpression(parent)) { return checker.getContextualType(parent); + } else if (isPropertyAssignment(parent) && isIdentifier(node)) { + return checker.getContextualType(node); } else if ( ![ts.SyntaxKind.TemplateSpan, ts.SyntaxKind.JsxExpression].includes( parent.kind, diff --git a/packages/eslint-plugin/tests/fixtures/class.ts b/packages/eslint-plugin/tests/fixtures/class.ts index 74f222338ff5..044e44e44aec 100644 --- a/packages/eslint-plugin/tests/fixtures/class.ts +++ b/packages/eslint-plugin/tests/fixtures/class.ts @@ -3,3 +3,8 @@ export class Error {} // used by unbound-method test case to test imports export const console = { log() {} }; + +// used by prefer-reduce-type-parameter to test native vs userland check +export class Reducable { + reduce() {} +} diff --git a/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts b/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts index fcbb788a3082..89ff1db4a615 100644 --- a/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts +++ b/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts @@ -5,7 +5,79 @@ const ruleTester = new RuleTester({ parser: '@typescript-eslint/parser', }); -ruleTester.run('ban-ts-comment', rule, { +ruleTester.run('ts-expect-error', rule, { + valid: [ + '// just a comment containing @ts-expect-error somewhere', + '/* @ts-expect-error */', + '/** @ts-expect-error */', + ` +/* +// @ts-expect-error in a block +*/ + `, + { + code: '// @ts-expect-error', + options: [{ 'ts-expect-error': false }], + }, + ], + invalid: [ + { + code: '// @ts-expect-error', + options: [{ 'ts-expect-error': true }], + errors: [ + { + data: { directive: 'expect-error' }, + messageId: 'tsDirectiveComment', + line: 1, + column: 1, + }, + ], + }, + { + code: '// @ts-expect-error: Suppress next line', + options: [{ 'ts-expect-error': true }], + errors: [ + { + data: { directive: 'expect-error' }, + messageId: 'tsDirectiveComment', + line: 1, + column: 1, + }, + ], + }, + { + code: '/////@ts-expect-error: Suppress next line', + options: [{ 'ts-expect-error': true }], + errors: [ + { + data: { directive: 'expect-error' }, + messageId: 'tsDirectiveComment', + line: 1, + column: 1, + }, + ], + }, + { + code: ` +if (false) { + // @ts-expect-error: Unreachable code error + console.log('hello'); +} + `, + options: [{ 'ts-expect-error': true }], + errors: [ + { + data: { directive: 'expect-error' }, + messageId: 'tsDirectiveComment', + line: 3, + column: 3, + }, + ], + }, + ], +}); + +ruleTester.run('ts-ignore', rule, { valid: [ '// just a comment containing @ts-ignore somewhere', '/* @ts-ignore */', diff --git a/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts b/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts index f885d503091f..010bb894ad7a 100644 --- a/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts +++ b/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts @@ -9,14 +9,12 @@ const ANGLE_BRACKET_TESTS = ` const x = new Generic(); const x = b; const x = [1]; -const x = [1]; const x = ('string'); `; const AS_TESTS = ` const x = new Generic() as Foo; const x = b as A; const x = [1] as readonly number[]; -const x = [1] as const; const x = ('string') as a | b; `; const OBJECT_LITERAL_AS_CASTS = ` @@ -98,6 +96,22 @@ ruleTester.run('consistent-type-assertions', rule, { }, ], }), + { + code: 'const x = [1];', + options: [ + { + assertionStyle: 'never', + }, + ], + }, + { + code: 'const x = [1] as const;', + options: [ + { + assertionStyle: 'never', + }, + ], + }, ], invalid: [ ...batchedSingleLineTests({ diff --git a/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts b/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts index 46ab49441858..dd3e38156766 100644 --- a/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts +++ b/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts @@ -366,6 +366,11 @@ new Foo(1, () => {}); }, ], }, + { + filename: 'test.ts', + code: 'const log = (message: string) => void console.log(message);', + options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }], + }, ], invalid: [ { @@ -1037,5 +1042,39 @@ const func = (value: number) => ({ type: 'X', value } as const); }, ], }, + { + filename: 'test.ts', + code: 'const log = (message: string) => void console.log(message);', + options: [ + { allowConciseArrowFunctionExpressionsStartingWithVoid: false }, + ], + errors: [ + { + messageId: 'missingReturnType', + line: 1, + endLine: 1, + column: 13, + endColumn: 33, + }, + ], + }, + { + filename: 'test.ts', + code: ` + const log = (message: string) => { + void console.log(message); + }; + `, + options: [{ allowConciseArrowFunctionExpressionsStartingWithVoid: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + endLine: 2, + column: 21, + endColumn: 41, + }, + ], + }, ], }); diff --git a/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts b/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts index cdff53533b73..5d63e8e1036e 100644 --- a/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts +++ b/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts @@ -348,6 +348,95 @@ export const Foo: JSX.Element = ( ecmaFeatures: { jsx: true }, }, }, + { + code: ` +const test = (): void => { + return; +}; +export default test; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +function test(): void { + return; +} +export default test; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +const test = (): void => { + return; +}; +export default [test]; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +function test(): void { + return; +} +export default [test]; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +const test = (): void => { + return; +}; +export default { test }; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +function test(): void { + return; +} +export default { test }; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +const foo = (arg => arg) as Foo; +export default foo; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +let foo = (arg => arg) as Foo; +foo = 3; +export default foo; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +class Foo { + bar = (arg: string): string => arg; +} +export default { Foo }; + `, + options: [{ shouldTrackReferences: true }], + }, + { + code: ` +class Foo { + bar(): void { + return; + } +} +export default { Foo }; + `, + options: [{ shouldTrackReferences: true }], + }, ], invalid: [ { @@ -925,5 +1014,271 @@ export function fn(test): string { }, ], }, + { + code: ` +const foo = arg => arg; +export default foo; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +const foo = arg => arg; +export = foo; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +let foo = (arg: number): number => arg; +foo = arg => arg; +export default foo; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 3, + }, + { + messageId: 'missingArgType', + line: 3, + }, + ], + }, + { + code: ` +const foo = arg => arg; +export default [foo]; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +const foo = arg => arg; +export default { foo }; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +function foo(arg) { + return arg; +} +export default foo; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +function foo(arg) { + return arg; +} +export default [foo]; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +function foo(arg) { + return arg; +} +export default { foo }; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +const bar = function foo(arg) { + return arg; +}; +export default { bar }; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, + { + code: ` +class Foo { + bool(arg) { + return arg; + } +} +export default Foo; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 3, + }, + { + messageId: 'missingArgType', + line: 3, + }, + ], + }, + { + code: ` +class Foo { + bool = arg => { + return arg; + }; +} +export default Foo; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 3, + }, + { + messageId: 'missingArgType', + line: 3, + }, + ], + }, + { + code: ` +class Foo { + bool = function(arg) { + return arg; + }; +} +export default Foo; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 3, + }, + { + messageId: 'missingArgType', + line: 3, + }, + ], + }, + { + code: ` +class Foo { + bool = function(arg) { + return arg; + }; +} +export default [Foo]; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 3, + }, + { + messageId: 'missingArgType', + line: 3, + }, + ], + }, + { + code: ` +let test = arg => argl; +test = (): void => { + return; +}; +export default test; + `, + options: [{ shouldTrackReferences: true }], + errors: [ + { + messageId: 'missingReturnType', + line: 2, + }, + { + messageId: 'missingArgType', + line: 2, + }, + ], + }, ], }); diff --git a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts index 76003e67d84c..dc938ff8cb9a 100644 --- a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts +++ b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts @@ -7,19 +7,36 @@ const ruleTester = new RuleTester({ ruleTester.run('method-signature-style', rule, { valid: [ - ...batchedSingleLineTests({ - code: noFormat` - interface Test { f: (a: string) => number } - interface Test { ['f']: (a: boolean) => void } - interface Test { f: (a: T) => T } - interface Test { ['f']: (a: T, b: T) => T } - interface Test { 'f!': (/* b */ x: any /* c */) => void } - type Test = { readonly f: (a: string) => number } - type Test = { ['f']?: (a: boolean) => void } - type Test = { readonly f?: (a?: T) => T } - type Test = { readonly ['f']?: (a: T, b: T) => T } - `, - }), + ` +interface Test { + f: (a: string) => number; +} + `, + ` +interface Test { + ['f']: (a: boolean) => void; +} + `, + ` +interface Test { + f: (a: T) => T; +} + `, + ` +interface Test { + ['f']: (a: T, b: T) => T; +} + `, + // TODO - requires prettier2 to format correctly + noFormat` +interface Test { + 'f!': (/* b */ x: any /* c */) => void; +} + `, + 'type Test = { readonly f: (a: string) => number };', + "type Test = { ['f']?: (a: boolean) => void };", + 'type Test = { readonly f?: (a?: T) => T };', + "type Test = { readonly ['f']?: (a: T, b: T) => T };", ...batchedSingleLineTests({ options: ['method'], code: noFormat` @@ -107,5 +124,107 @@ ruleTester.run('method-signature-style', rule, { type Test = { readonly ['f']?(a: T, b: T): T } `, }), + { + code: noFormat` +interface Foo { + semi(arg: string): void; + comma(arg: string): void, + none(arg: string): void +} + `, + output: noFormat` +interface Foo { + semi: (arg: string) => void; + comma: (arg: string) => void, + none: (arg: string) => void +} + `, + errors: [ + { + messageId: 'errorMethod', + line: 3, + }, + { + messageId: 'errorMethod', + line: 4, + }, + { + messageId: 'errorMethod', + line: 5, + }, + ], + }, + { + code: noFormat` +interface Foo { + semi: (arg: string) => void; + comma: (arg: string) => void, + none: (arg: string) => void +} + `, + output: noFormat` +interface Foo { + semi(arg: string): void; + comma(arg: string): void, + none(arg: string): void +} + `, + options: ['method'], + errors: [ + { + messageId: 'errorProperty', + line: 3, + }, + { + messageId: 'errorProperty', + line: 4, + }, + { + messageId: 'errorProperty', + line: 5, + }, + ], + }, + // https://github.com/typescript-eslint/typescript-eslint/issues/1857 + { + code: noFormat` +interface Foo { + x( + args: Pick< + Bar, + 'one' | 'two' | 'three' + >, + ): Baz; + y( + foo: string, + bar: number, + ): void; +} + `, + output: noFormat` +interface Foo { + x: ( + args: Pick< + Bar, + 'one' | 'two' | 'three' + >, + ) => Baz; + y: ( + foo: string, + bar: number, + ) => void; +} + `, + errors: [ + { + messageId: 'errorMethod', + line: 3, + }, + { + messageId: 'errorMethod', + line: 9, + }, + ], + }, ], }); diff --git a/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts b/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts index cd2e4b166a90..59abfbb1f602 100644 --- a/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts +++ b/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts @@ -70,6 +70,17 @@ const literalWithToString = { 'let _ = {} ^ {};', 'let _ = {} << {};', 'let _ = {} >> {};', + { + code: ` + function tag() {} + tag\`\${{}}\`; + `, + options: [ + { + ignoreTaggedTemplateExpressions: true, + }, + ], + }, ], invalid: [ { @@ -84,6 +95,21 @@ const literalWithToString = { }, ], }, + { + code: ` + function tag() {} + tag\`\${{}}\`; + `, + errors: [ + { + data: { + certainty: 'will', + name: '{}', + }, + messageId: 'baseToString', + }, + ], + }, { code: '({}.toString());', errors: [ diff --git a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts index 1a69e06f140e..d0281ec77a03 100644 --- a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts +++ b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts @@ -133,5 +133,56 @@ type Foo = R }, ], }, + { + code: ` +interface Foo extends Bar {} + `, + output: noFormat` +type Foo = Bar + `, + errors: [ + { + messageId: 'noEmptyWithSuper', + line: 2, + column: 11, + }, + ], + }, + { + filename: 'test.d.ts', + code: ` +declare module FooBar { + type Baz = typeof baz; + export interface Bar extends Baz {} +} + `.trimRight(), + errors: [ + { + messageId: 'noEmptyWithSuper', + line: 4, + column: 20, + endLine: 4, + endColumn: 23, + suggestions: [ + { + messageId: 'noEmptyWithSuper', + output: noFormat` +declare module FooBar { + type Baz = typeof baz; + export type Bar = Baz +} + `.trimRight(), + }, + ], + }, + ], + // output matches input because a suggestion was made + output: ` +declare module FooBar { + type Baz = typeof baz; + export interface Bar extends Baz {} +} + `.trimRight(), + }, ], }); diff --git a/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts b/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts index 134fd513e877..7c3ec3091859 100644 --- a/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts +++ b/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts @@ -54,5 +54,50 @@ for (const x in z) { }, ], }, + { + code: ` +const fn = (arr: number[]) => { + for (const x in arr) { + console.log(x); + } +}; + `, + errors: [ + { + messageId: 'forInViolation', + type: AST_NODE_TYPES.ForInStatement, + }, + ], + }, + { + code: ` +const fn = (arr: number[] | string[]) => { + for (const x in arr) { + console.log(x); + } +}; + `, + errors: [ + { + messageId: 'forInViolation', + type: AST_NODE_TYPES.ForInStatement, + }, + ], + }, + { + code: ` +const fn = (arr: T) => { + for (const x in arr) { + console.log(x); + } +}; + `, + errors: [ + { + messageId: 'forInViolation', + type: AST_NODE_TYPES.ForInStatement, + }, + ], + }, ], }); diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts new file mode 100644 index 000000000000..708969310edd --- /dev/null +++ b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts @@ -0,0 +1,327 @@ +import { TSESLint } from '@typescript-eslint/experimental-utils'; +import rule from '../../src/rules/no-unsafe-assignment'; +import { + RuleTester, + batchedSingleLineTests, + getFixturesRootDir, + noFormat, +} from '../RuleTester'; +import { + InferMessageIdsTypeFromRule, + InferOptionsTypeFromRule, +} from '../../src/util'; + +type Options = InferOptionsTypeFromRule; +type MessageIds = InferMessageIdsTypeFromRule; +type InvalidTest = TSESLint.InvalidTestCase; + +function assignmentTest( + tests: [string, number, number, boolean?][], +): InvalidTest[] { + return tests.reduce( + (acc, [assignment, column, endColumn, skipAssignmentExpression]) => { + // VariableDeclaration + acc.push({ + code: `const ${assignment}`, + errors: [ + { + messageId: 'unsafeArrayPatternFromTuple', + line: 1, + column: column + 6, + endColumn: endColumn + 6, + }, + ], + }); + // AssignmentPattern + acc.push({ + code: `function foo(${assignment}) {}`, + errors: [ + { + messageId: 'unsafeArrayPatternFromTuple', + line: 1, + column: column + 13, + endColumn: endColumn + 13, + }, + ], + }); + // AssignmentExpression + if (skipAssignmentExpression !== true) { + acc.push({ + code: `(${assignment})`, + errors: [ + { + messageId: 'unsafeArrayPatternFromTuple', + line: 1, + column: column + 1, + endColumn: endColumn + 1, + }, + ], + }); + } + + return acc; + }, + [], + ); +} + +const ruleTester = new RuleTester({ + parser: '@typescript-eslint/parser', + parserOptions: { + project: './tsconfig.json', + tsconfigRootDir: getFixturesRootDir(), + }, +}); + +ruleTester.run('no-unsafe-assignment', rule, { + valid: [ + 'const x = 1;', + 'const x: number = 1;', + ` +const x = 1, + y = 1; + `, + 'let x;', + ` +let x = 1, + y; + `, + 'function foo(a = 1) {}', + ` +class Foo { + constructor(private a = 1) {} +} + `, + ` +class Foo { + private a = 1; +} + `, + 'const x: Set = new Set();', + 'const x: Set = new Set();', + 'const [x] = [1];', + 'const [x, ...y] = [1, 2, 3, 4, 5];', + 'const [x, ...y] = [1];', + 'function foo(x = 1) {}', + 'function foo([x] = [1]) {}', + 'function foo([x, ...y] = [1, 2, 3, 4, 5]) {}', + 'function foo([x, ...y] = [1]) {}', + // this is not checked, because there's no annotation to compare it with + 'const x = new Set();', + 'const x = { y: 1 };', + 'const x: { y: number } = { y: 1 };', + 'const x = [...[1, 2, 3]];', + { + code: ` +type Props = { a: string }; +declare function Foo(props: Props): never; +; + `, + filename: 'react.tsx', + }, + ], + invalid: [ + ...batchedSingleLineTests({ + code: noFormat` +const x = (1 as any); +const x = (1 as any), y = 1; +function foo(a = (1 as any)) {} +class Foo { constructor(private a = (1 as any)) {} } +class Foo { private a = (1 as any) } + `, + errors: [ + { + messageId: 'anyAssignment', + line: 2, + column: 7, + endColumn: 21, + }, + { + messageId: 'anyAssignment', + line: 3, + column: 7, + endColumn: 21, + }, + { + messageId: 'anyAssignment', + line: 4, + column: 14, + endColumn: 28, + }, + { + messageId: 'anyAssignment', + line: 5, + column: 33, + endColumn: 47, + }, + { + messageId: 'anyAssignment', + line: 6, + column: 13, + endColumn: 35, + }, + ], + }), + ...batchedSingleLineTests({ + code: ` +const [x] = 1 as any; +const [x] = [] as any[]; + `, + errors: [ + { + messageId: 'anyAssignment', + line: 2, + column: 7, + endColumn: 21, + }, + { + messageId: 'unsafeArrayPattern', + line: 3, + column: 7, + endColumn: 10, + }, + ], + }), + ...batchedSingleLineTests({ + code: noFormat` +const x: Set = new Set(); +const x: Map = new Map(); +const x: Set = new Set(); +const x: Set>> = new Set>>(); + `, + errors: [ + { + messageId: 'unsafeAssignment', + data: { + sender: 'Set', + receiver: 'Set', + }, + line: 2, + }, + { + messageId: 'unsafeAssignment', + data: { + sender: 'Map', + receiver: 'Map', + }, + line: 3, + }, + { + messageId: 'unsafeAssignment', + data: { + sender: 'Set', + receiver: 'Set', + }, + line: 4, + }, + { + messageId: 'unsafeAssignment', + data: { + sender: 'Set>>', + receiver: 'Set>>', + }, + line: 5, + }, + ], + }), + ...assignmentTest([ + ['[x] = [1] as [any]', 2, 3], + ['[[[[x]]]] = [[[[1 as any]]]]', 5, 6], + ['[[[[x]]]] = [1 as any]', 2, 9, true], + ['[{x}] = [{x: 1}] as [{x: any}]', 3, 4], + ]), + { + // TS treats the assignment pattern weirdly in this case + code: '[[[[x]]]] = [1 as any];', + errors: [ + { + messageId: 'unsafeAssignment', + line: 1, + column: 1, + endColumn: 23, + }, + ], + }, + ...batchedSingleLineTests({ + code: ` +const x = [...(1 as any)]; +const x = [...([] as any[])]; + `, + errors: [ + { + messageId: 'unsafeArraySpread', + line: 2, + column: 12, + endColumn: 25, + }, + { + messageId: 'unsafeArraySpread', + line: 3, + column: 12, + endColumn: 28, + }, + ], + }), + ...assignmentTest([ + ['{x} = {x: 1} as {x: any}', 2, 3], + ['{x: y} = {x: 1} as {x: any}', 5, 6], + ['{x: {y}} = {x: {y: 1}} as {x: {y: any}}', 6, 7], + ['{x: [y]} = {x: {y: 1}} as {x: [any]}', 6, 7], + ]), + ...batchedSingleLineTests({ + code: ` +const x = { y: 1 as any }; +const x = { y: { z: 1 as any } }; +const x: { y: Set>> } = { y: new Set>>() }; +const x = { ...(1 as any) }; + `, + errors: [ + { + messageId: 'anyAssignment', + line: 2, + column: 13, + endColumn: 24, + }, + { + messageId: 'anyAssignment', + line: 3, + column: 18, + endColumn: 29, + }, + { + messageId: 'unsafeAssignment', + line: 4, + column: 43, + endColumn: 70, + data: { + sender: 'Set>>', + receiver: 'Set>>', + }, + }, + { + // spreading an any widens the object type to any + messageId: 'anyAssignment', + line: 5, + column: 7, + endColumn: 28, + }, + ], + }), + { + code: ` +type Props = { a: string }; +declare function Foo(props: Props): never; +; + `, + filename: 'react.tsx', + errors: [ + { + messageId: 'anyAssignment', + line: 4, + column: 9, + endColumn: 17, + }, + ], + }, + ], +}); diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts index 8adb44b9960f..f860410da5c1 100644 --- a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts +++ b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts @@ -47,6 +47,7 @@ function foo(x: any) { x() } function foo(x: any) { x?.() } function foo(x: any) { x.a.b.c.d.e.f.g() } function foo(x: any) { x.a.b.c.d.e.f.g?.() } +function foo(x: T) { x() } `, errors: [ { @@ -73,6 +74,12 @@ function foo(x: any) { x.a.b.c.d.e.f.g?.() } column: 24, endColumn: 39, }, + { + messageId: 'unsafeCall', + line: 6, + column: 37, + endColumn: 38, + }, ], }), ...batchedSingleLineTests({ diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts index b0c1ead90076..42a58734a476 100644 --- a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts +++ b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts @@ -73,6 +73,24 @@ function foo(): Set { `, ], invalid: [ + { + code: ` +function fn(x: T) { + return x; +} + `, + errors: [ + { + messageId: 'unsafeReturnAssignment', + data: { + sender: 'any', + receiver: 'T', + }, + line: 3, + column: 3, + }, + ], + }, ...batchedSingleLineTests({ code: noFormat` function foo() { return (1 as any); } diff --git a/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts b/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts new file mode 100644 index 000000000000..a683a4ab0dc4 --- /dev/null +++ b/packages/eslint-plugin/tests/rules/prefer-reduce-type-parameter.test.ts @@ -0,0 +1,191 @@ +import rule from '../../src/rules/prefer-reduce-type-parameter'; +import { RuleTester, getFixturesRootDir } from '../RuleTester'; + +const rootPath = getFixturesRootDir(); + +const ruleTester = new RuleTester({ + parser: '@typescript-eslint/parser', + parserOptions: { + sourceType: 'module', + tsconfigRootDir: rootPath, + project: './tsconfig.json', + }, +}); + +ruleTester.run('prefer-reduce-type-parameter', rule, { + valid: [ + ` + new (class Mine { + reduce() {} + })().reduce(() => {}, 1 as any); + `, + ` + class Mine { + reduce() {} + } + + new Mine().reduce(() => {}, 1 as any); + `, + ` + import { Reducable } from './class'; + + new Reducable().reduce(() => {}, 1 as any); + `, + "[1, 2, 3]['reduce']((sum, num) => sum + num, 0);", + '[1, 2, 3][null]((sum, num) => sum + num, 0);', + '[1, 2, 3]?.[null]((sum, num) => sum + num, 0);', + '[1, 2, 3].reduce((sum, num) => sum + num, 0);', + '[1, 2, 3].reduce((a, s) => a.concat(s * 2), []);', + '[1, 2, 3]?.reduce((a, s) => a.concat(s * 2), []);', + ], + invalid: [ + { + code: '[1, 2, 3].reduce((a, s) => a.concat(s * 2), [] as number[]);', + output: '[1, 2, 3].reduce((a, s) => a.concat(s * 2), []);', + errors: [ + { + messageId: 'preferTypeParameter', + column: 45, + line: 1, + }, + ], + }, + { + code: '[1, 2, 3].reduce((a, s) => a.concat(s * 2), []);', + output: '[1, 2, 3].reduce((a, s) => a.concat(s * 2), []);', + errors: [ + { + messageId: 'preferTypeParameter', + column: 45, + line: 1, + }, + ], + }, + { + code: '[1, 2, 3]?.reduce((a, s) => a.concat(s * 2), [] as number[]);', + output: '[1, 2, 3]?.reduce((a, s) => a.concat(s * 2), []);', + errors: [ + { + messageId: 'preferTypeParameter', + column: 46, + line: 1, + }, + ], + }, + { + code: '[1, 2, 3]?.reduce((a, s) => a.concat(s * 2), []);', + output: '[1, 2, 3]?.reduce((a, s) => a.concat(s * 2), []);', + errors: [ + { + messageId: 'preferTypeParameter', + column: 46, + line: 1, + }, + ], + }, + { + code: ` +const names = ['a', 'b', 'c']; + +names.reduce( + (accum, name) => ({ + ...accum, + [name]: true, + }), + {} as Record, +); + `, + output: ` +const names = ['a', 'b', 'c']; + +names.reduce>( + (accum, name) => ({ + ...accum, + [name]: true, + }), + {}, +); + `, + errors: [ + { + messageId: 'preferTypeParameter', + column: 3, + line: 9, + }, + ], + }, + { + code: ` +['a', 'b'].reduce( + (accum, name) => ({ + ...accum, + [name]: true, + }), + >{}, +); + `, + output: ` +['a', 'b'].reduce>( + (accum, name) => ({ + ...accum, + [name]: true, + }), + {}, +); + `, + errors: [ + { + messageId: 'preferTypeParameter', + column: 3, + line: 7, + }, + ], + }, + { + code: ` +['a', 'b']['reduce']( + (accum, name) => ({ + ...accum, + [name]: true, + }), + {} as Record, +); + `, + output: ` +['a', 'b']['reduce']>( + (accum, name) => ({ + ...accum, + [name]: true, + }), + {}, +); + `, + errors: [ + { + messageId: 'preferTypeParameter', + column: 3, + line: 7, + }, + ], + }, + { + code: ` +function f(a: U) { + return a.reduce(() => {}, {} as Record); +} + `, + output: ` +function f(a: U) { + return a.reduce>(() => {}, {}); +} + `, + errors: [ + { + messageId: 'preferTypeParameter', + column: 29, + line: 3, + }, + ], + }, + ], +}); diff --git a/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts b/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts new file mode 100644 index 000000000000..8e9c04f09ed6 --- /dev/null +++ b/packages/eslint-plugin/tests/rules/prefer-ts-expect-error.test.ts @@ -0,0 +1,85 @@ +import rule from '../../src/rules/prefer-ts-expect-error'; +import { RuleTester } from '../RuleTester'; + +const ruleTester = new RuleTester({ + parser: '@typescript-eslint/parser', +}); + +ruleTester.run('prefer-ts-expect-error', rule, { + valid: [ + '// @ts-nocheck', + '// @ts-check', + '// just a comment containing @ts-ignore somewhere', + '/* @ts-ignore */', + '/** @ts-ignore */', + ` +/* +// @ts-ignore in a block +*/ + `, + '// @ts-expect-error', + ` +if (false) { + // @ts-expect-error: Unreachable code error + console.log('hello'); +} + `, + ], + invalid: [ + { + code: '// @ts-ignore', + output: '// @ts-expect-error', + errors: [ + { + messageId: 'preferExpectErrorComment', + line: 1, + column: 1, + }, + ], + }, + { + code: '// @ts-ignore: Suppress next line', + output: '// @ts-expect-error: Suppress next line', + + errors: [ + { + messageId: 'preferExpectErrorComment', + line: 1, + column: 1, + }, + ], + }, + { + code: '/////@ts-ignore: Suppress next line', + output: '/////@ts-expect-error: Suppress next line', + errors: [ + { + messageId: 'preferExpectErrorComment', + line: 1, + column: 1, + }, + ], + }, + { + code: ` +if (false) { + // @ts-ignore: Unreachable code error + console.log('hello'); +} + `, + output: ` +if (false) { + // @ts-expect-error: Unreachable code error + console.log('hello'); +} + `, + errors: [ + { + messageId: 'preferExpectErrorComment', + line: 3, + column: 3, + }, + ], + }, + ], +}); diff --git a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts index 3e18e7ac1b1e..6a2861efa323 100644 --- a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts +++ b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts @@ -115,6 +115,43 @@ ruleTester.run('restrict-template-expressions', rule, { } `, }, + // allowAny + { + options: [{ allowAny: true }], + code: ` + const arg: any = 123; + const msg = \`arg = \${arg}\`; + `, + }, + { + options: [{ allowAny: true }], + code: ` + const arg: any = undefined; + const msg = \`arg = \${arg || 'some-default'}\`; + `, + }, + { + options: [{ allowAny: true }], + code: ` + const user = JSON.parse('{ "name": "foo" }'); + const msg = \`arg = \${user.name}\`; + `, + }, + { + options: [{ allowAny: true }], + code: ` + const user = JSON.parse('{ "name": "foo" }'); + const msg = \`arg = \${user.name || 'the user with no name'}\`; + `, + }, + { + options: [{ allowAny: true }], + code: ` + function test(arg: T) { + return \`arg = \${arg}\`; + } + `, + }, // allowNullable { options: [{ allowNullable: true }], @@ -208,5 +245,14 @@ ruleTester.run('restrict-template-expressions', rule, { `, errors: [{ messageId: 'invalidType', line: 3, column: 27 }], }, + { + options: [{ allowNumber: true, allowBoolean: true, allowNullable: true }], + code: ` + function test(arg: any) { + return \`arg = \${arg}\`; + } + `, + errors: [{ messageId: 'invalidType', line: 3, column: 27 }], + }, ], }); diff --git a/packages/eslint-plugin/tests/rules/unbound-method.test.ts b/packages/eslint-plugin/tests/rules/unbound-method.test.ts index 10f0b5497621..df1d50ac1369 100644 --- a/packages/eslint-plugin/tests/rules/unbound-method.test.ts +++ b/packages/eslint-plugin/tests/rules/unbound-method.test.ts @@ -147,6 +147,9 @@ ruleTester.run('unbound-method', rule, { "typeof ContainsMethods.boundStatic === 'function';", "typeof ContainsMethods.unboundStatic === 'function';", + + 'instance.unbound = () => {};', + 'instance.unbound = instance.unbound.bind(instance);', ].map(addContainsMethodsClass), ` interface RecordA { @@ -211,6 +214,15 @@ const x: OptionalMethod = {}; declare const myCondition: boolean; if (myCondition || x.mightBeDefined) { console.log('hello world'); +} + `, + // https://github.com/typescript-eslint/typescript-eslint/issues/1256 + ` +class A { + unbound(): void { + this.unbound = undefined; + this.unbound = this.unbound.bind(this); + } } `, ], @@ -336,5 +348,38 @@ const x = CommunicationError.prototype.foo; }, ], }, + { + code: ` +class Foo { + unbound() {} +} +const instance = new Foo(); + +let x; + +x = instance.unbound; // THIS SHOULD ERROR +instance.unbound = x; // THIS SHOULD NOT + `, + errors: [ + { + line: 9, + messageId: 'unbound', + }, + ], + }, + { + code: ` +class Foo { + unbound = function() {}; +} +const unbound = new Foo().unbound; + `, + errors: [ + { + line: 5, + messageId: 'unbound', + }, + ], + }, ], }); diff --git a/packages/experimental-utils/CHANGELOG.md b/packages/experimental-utils/CHANGELOG.md index b874b0c440ac..ece5fcbb544c 100644 --- a/packages/experimental-utils/CHANGELOG.md +++ b/packages/experimental-utils/CHANGELOG.md @@ -3,6 +3,17 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + + +### Features + +* **eslint-plugin:** add rule `prefer-reduce-type-parameter` ([#1707](https://github.com/typescript-eslint/typescript-eslint/issues/1707)) ([c92d240](https://github.com/typescript-eslint/typescript-eslint/commit/c92d240e49113779053eac32038382b282812afc)) + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) diff --git a/packages/experimental-utils/README.md b/packages/experimental-utils/README.md index 97d9d5c057b2..cba85c84d6e4 100644 --- a/packages/experimental-utils/README.md +++ b/packages/experimental-utils/README.md @@ -14,17 +14,17 @@ Once it is stable, it will be renamed to `@typescript-eslint/util` for a `3.0.0` ## Exports -| Name | Description | -| ---------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| [`ASTUtils`](./src/ast-utils) | Tools for operating on the ESTree AST. Also includes the [`eslint-utils`](https://www.npmjs.com/package/eslint-utils) package, correctly typed to work with the types found in `TSESTree` | -| [`ESLintUtils`](./src/eslint-utils) | Tools for creating ESLint rules with TypeScript. | -| `JSONSchema` | Types from the [`@types/json-schema`](https://www.npmjs.com/package/@types/json-schema) package, re-exported to save you having to manually import them. Also ensures you're using the same version of the types as this package. | -| [`TSESLint`](./src/ts-eslint) | Types for ESLint, correctly typed to work with the types found in `TSESTree`. | -| [`TSESLintScope`](./src/ts-eslint-scope) | The [`eslint-scope`](https://www.npmjs.com/package/eslint-scope) package, correctly typed to work with the types found in both `TSESTree` and `TSESLint` | -| [`TSESTree`](../packages/typescript-estree/src/ts-estree/ts-estree.ts) | Types for the TypeScript flavor of ESTree created by `@typescript-eslint/typescript-estree`. | -| [`AST_NODE_TYPES`](../packages/typescript-estree/src/ts-estree/ast-node-types.ts) | An enum with the names of every single _node_ found in `TSESTree`. | -| [`AST_TOKEN_TYPES`](../packages/typescript-estree/src/ts-estree/ast-node-types.ts) | An enum with the names of every single _token_ found in `TSESTree`. | -| [`ParserServices`](../packages/typescript-estree/src/ts-estree/parser.ts) | Typing for the parser services provided when parsing a file using `@typescript-eslint/typescript-estree`. | +| Name | Description | +| ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| [`ASTUtils`](./src/ast-utils) | Tools for operating on the ESTree AST. Also includes the [`eslint-utils`](https://www.npmjs.com/package/eslint-utils) package, correctly typed to work with the types found in `TSESTree` | +| [`ESLintUtils`](./src/eslint-utils) | Tools for creating ESLint rules with TypeScript. | +| `JSONSchema` | Types from the [`@types/json-schema`](https://www.npmjs.com/package/@types/json-schema) package, re-exported to save you having to manually import them. Also ensures you're using the same version of the types as this package. | +| [`TSESLint`](./src/ts-eslint) | Types for ESLint, correctly typed to work with the types found in `TSESTree`. | +| [`TSESLintScope`](./src/ts-eslint-scope) | The [`eslint-scope`](https://www.npmjs.com/package/eslint-scope) package, correctly typed to work with the types found in both `TSESTree` and `TSESLint` | +| [`TSESTree`](../typescript-estree/src/ts-estree/ts-estree.ts) | Types for the TypeScript flavor of ESTree created by `@typescript-eslint/typescript-estree`. | +| [`AST_NODE_TYPES`](../typescript-estree/src/ts-estree/ast-node-types.ts) | An enum with the names of every single _node_ found in `TSESTree`. | +| [`AST_TOKEN_TYPES`](../typescript-estree/src/ts-estree/ast-node-types.ts) | An enum with the names of every single _token_ found in `TSESTree`. | +| [`ParserServices`](../typescript-estree/src/parser-options.ts) | Typing for the parser services provided when parsing a file using `@typescript-eslint/typescript-estree`. | ## Contributing diff --git a/packages/experimental-utils/package.json b/packages/experimental-utils/package.json index d1550271300a..b623c12ed314 100644 --- a/packages/experimental-utils/package.json +++ b/packages/experimental-utils/package.json @@ -1,6 +1,6 @@ { "name": "@typescript-eslint/experimental-utils", - "version": "2.27.0", + "version": "2.28.0", "description": "(Experimental) Utilities for working with TypeScript + ESLint together", "keywords": [ "eslint", @@ -37,7 +37,7 @@ }, "dependencies": { "@types/json-schema": "^7.0.3", - "@typescript-eslint/typescript-estree": "2.27.0", + "@typescript-eslint/typescript-estree": "2.28.0", "eslint-scope": "^5.0.0", "eslint-utils": "^2.0.0" }, diff --git a/packages/experimental-utils/src/eslint-utils/deepMerge.ts b/packages/experimental-utils/src/eslint-utils/deepMerge.ts index 5ac6509203f9..9b7baee5ebb4 100644 --- a/packages/experimental-utils/src/eslint-utils/deepMerge.ts +++ b/packages/experimental-utils/src/eslint-utils/deepMerge.ts @@ -25,7 +25,7 @@ export function deepMerge( // get the unique set of keys across both objects const keys = new Set(Object.keys(first).concat(Object.keys(second))); - return Array.from(keys).reduce((acc, key) => { + return Array.from(keys).reduce((acc, key) => { const firstHasKey = key in first; const secondHasKey = key in second; const firstValue = first[key]; @@ -46,7 +46,7 @@ export function deepMerge( } return acc; - }, {} as ObjectLike); + }, {}); } export { isObjectNotArray }; diff --git a/packages/parser/CHANGELOG.md b/packages/parser/CHANGELOG.md index c13d0782a4bf..c99a618a07ef 100644 --- a/packages/parser/CHANGELOG.md +++ b/packages/parser/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + +**Note:** Version bump only for package @typescript-eslint/parser + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) **Note:** Version bump only for package @typescript-eslint/parser diff --git a/packages/parser/README.md b/packages/parser/README.md index 70cb1cb2ca29..594f89dd6c29 100644 --- a/packages/parser/README.md +++ b/packages/parser/README.md @@ -67,7 +67,7 @@ Default `false`. Enable parsing JSX when `true`. More details can be found [here](https://www.typescriptlang.org/docs/handbook/jsx.html). -**NOTE:** this setting does not affect known file types (`.js`, `.jsx`, `.ts`, `.tsx`, `.json`) because the typescript compiler has its own internal handling for known file extensions. The exact behavior is as follows: +**NOTE:** this setting does not affect known file types (`.js`, `.jsx`, `.ts`, `.tsx`, `.json`) because the TypeScript compiler has its own internal handling for known file extensions. The exact behavior is as follows: - if `parserOptions.project` is _not_ provided: - `.js`, `.jsx`, `.tsx` files are parsed as if this is true. diff --git a/packages/parser/package.json b/packages/parser/package.json index d59732165ac7..a36625794ad1 100644 --- a/packages/parser/package.json +++ b/packages/parser/package.json @@ -1,6 +1,6 @@ { "name": "@typescript-eslint/parser", - "version": "2.27.0", + "version": "2.28.0", "description": "An ESLint custom parser which leverages TypeScript ESTree", "main": "dist/parser.js", "types": "dist/parser.d.ts", @@ -43,13 +43,13 @@ }, "dependencies": { "@types/eslint-visitor-keys": "^1.0.0", - "@typescript-eslint/experimental-utils": "2.27.0", - "@typescript-eslint/typescript-estree": "2.27.0", + "@typescript-eslint/experimental-utils": "2.28.0", + "@typescript-eslint/typescript-estree": "2.28.0", "eslint-visitor-keys": "^1.1.0" }, "devDependencies": { "@types/glob": "^7.1.1", - "@typescript-eslint/shared-fixtures": "2.27.0", + "@typescript-eslint/shared-fixtures": "2.28.0", "glob": "*" }, "peerDependenciesMeta": { diff --git a/packages/shared-fixtures/CHANGELOG.md b/packages/shared-fixtures/CHANGELOG.md index 8ac0c5e53683..f460b702eb95 100644 --- a/packages/shared-fixtures/CHANGELOG.md +++ b/packages/shared-fixtures/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + +**Note:** Version bump only for package @typescript-eslint/shared-fixtures + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) **Note:** Version bump only for package @typescript-eslint/shared-fixtures diff --git a/packages/shared-fixtures/package.json b/packages/shared-fixtures/package.json index c36d658dad53..e843de63a56b 100644 --- a/packages/shared-fixtures/package.json +++ b/packages/shared-fixtures/package.json @@ -1,6 +1,6 @@ { "name": "@typescript-eslint/shared-fixtures", - "version": "2.27.0", + "version": "2.28.0", "private": true, "scripts": { "build": "tsc -b tsconfig.build.json", diff --git a/packages/typescript-estree/CHANGELOG.md b/packages/typescript-estree/CHANGELOG.md index 0d46bcbc15d1..8750d8a65ed5 100644 --- a/packages/typescript-estree/CHANGELOG.md +++ b/packages/typescript-estree/CHANGELOG.md @@ -3,6 +3,18 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [2.28.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.27.0...v2.28.0) (2020-04-13) + + +### Features + +* **eslint-plugin:** add rule `prefer-ts-expect-error` ([#1705](https://github.com/typescript-eslint/typescript-eslint/issues/1705)) ([7021f21](https://github.com/typescript-eslint/typescript-eslint/commit/7021f2151a25db2a8edf17e06cd6f21e90761ec8)) +* **eslint-plugin:** add rule no-unsafe-assignment ([#1694](https://github.com/typescript-eslint/typescript-eslint/issues/1694)) ([a49b860](https://github.com/typescript-eslint/typescript-eslint/commit/a49b860cbbb2c7d718b99f561e2fb6eaadf16f17)) + + + + + # [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06) diff --git a/packages/typescript-estree/package.json b/packages/typescript-estree/package.json index 7667f3403141..bc75ebdf786c 100644 --- a/packages/typescript-estree/package.json +++ b/packages/typescript-estree/package.json @@ -1,6 +1,6 @@ { "name": "@typescript-eslint/typescript-estree", - "version": "2.27.0", + "version": "2.28.0", "description": "A parser that converts TypeScript source code into an ESTree compatible form", "main": "dist/parser.js", "types": "dist/parser.d.ts", @@ -58,7 +58,7 @@ "@types/lodash": "^4.14.149", "@types/semver": "^6.2.0", "@types/tmp": "^0.1.0", - "@typescript-eslint/shared-fixtures": "2.27.0", + "@typescript-eslint/shared-fixtures": "2.28.0", "tmp": "^0.1.0", "typescript": "*" }, diff --git a/packages/typescript-estree/src/ts-estree/ts-estree.ts b/packages/typescript-estree/src/ts-estree/ts-estree.ts index 24486b974b30..5792ebc02058 100644 --- a/packages/typescript-estree/src/ts-estree/ts-estree.ts +++ b/packages/typescript-estree/src/ts-estree/ts-estree.ts @@ -115,6 +115,7 @@ export interface LineComment extends BaseToken { export type Comment = BlockComment | LineComment; export type Token = | BooleanToken + | Comment | IdentifierToken | JSXIdentifierToken | JSXTextToken @@ -764,7 +765,7 @@ export interface AssignmentExpression extends BinaryExpressionBase { export interface AssignmentPattern extends BaseNode { type: AST_NODE_TYPES.AssignmentPattern; left: BindingName; - right?: Expression; + right: Expression; typeAnnotation?: TSTypeAnnotation; optional?: boolean; decorators?: Decorator[]; diff --git a/yarn.lock b/yarn.lock index 8fb6fd0a838d..04ba7af56f04 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2340,6 +2340,13 @@ commander@^2.12.1, commander@^2.20.0, commander@^2.20.3, commander@~2.20.0: resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33" integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ== +commander@~2.9.0: + version "2.9.0" + resolved "https://registry.yarnpkg.com/commander/-/commander-2.9.0.tgz#9c99094176e12240cb22d6c5146098400fe0f7d4" + integrity sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q= + dependencies: + graceful-readlink ">= 1.0.0" + comment-json@^1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/comment-json/-/comment-json-1.1.3.tgz#6986c3330fee0c4c9e00c2398cd61afa5d8f239e" @@ -3006,6 +3013,16 @@ dedent@0.7.0, dedent@^0.7.0: resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c" integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw= +deep-extend@^0.6.0: + version "0.6.0" + resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac" + integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA== + +deep-extend@~0.5.1: + version "0.5.1" + resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.5.1.tgz#b894a9dd90d3023fbf1c55a394fb858eb2066f1f" + integrity sha512-N8vBdOa+DF7zkRrDCsaOXoCs/E2fJfx9B9MrKnnSiHNh4ws7eSys6YQE4KvT1cecKmOASYQBhbKjeuDD9lT81w== + deep-is@~0.1.3: version "0.1.3" resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34" @@ -3228,6 +3245,11 @@ end-of-stream@^1.0.0, end-of-stream@^1.1.0: dependencies: once "^1.4.0" +entities@~2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/entities/-/entities-2.0.0.tgz#68d6084cab1b079767540d80e56a39b423e4abf4" + integrity sha512-D9f7V0JSRwIxlRI2mjMqufDrRDnx8p+eEOz7aUM9SuvF8gsBzra0/6tbjl1m8eQHrZlYj6PxqE00hZ1SAIKPLw== + env-paths@^2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-2.2.0.tgz#cdca557dc009152917d6166e2febe1f039685e43" @@ -3939,6 +3961,11 @@ get-stdin@^4.0.1: resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe" integrity sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4= +get-stdin@~5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-5.0.1.tgz#122e161591e21ff4c52530305693f20e6393a398" + integrity sha1-Ei4WFZHiH/TFJTAwVpPyDmOTo5g= + get-stream@^4.0.0, get-stream@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5" @@ -4045,7 +4072,7 @@ glob-to-regexp@^0.3.0: resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.3.0.tgz#8c5a1494d2066c570cc3bfe4496175acc4d502ab" integrity sha1-jFoUlNIGbFcMw7/kSWF1rMTVAqs= -glob@*, glob@^7.0.0, glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4, glob@^7.1.6: +glob@*, glob@^7.0.0, glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4, glob@^7.1.6, glob@~7.1.2: version "7.1.6" resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6" integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA== @@ -4141,6 +4168,11 @@ graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.3 resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.3.tgz#4a12ff1b60376ef09862c2093edd908328be8423" integrity sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ== +"graceful-readlink@>= 1.0.0": + version "1.0.1" + resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725" + integrity sha1-TK+tdrxi8C+gObL5Tpo906ORpyU= + growly@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/growly/-/growly-1.3.0.tgz#f10748cbe76af964b7c96c93c6bcc28af120c081" @@ -4342,7 +4374,7 @@ ignore@^4.0.3, ignore@^4.0.6: resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc" integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg== -ignore@^5.0.5, ignore@^5.1.1: +ignore@^5.0.5, ignore@^5.1.1, ignore@~5.1.4: version "5.1.4" resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.4.tgz#84b7b3dbe64552b6ef0eca99f6743dbec6d97adf" integrity sha512-MzbUSahkTW1u7JpKKjY7LCARd1fU5W2rLdxlM4kdkayuCwZImjkpluF9CM1aLewYJguPDqewLam18Y6AU69A8A== @@ -4426,7 +4458,7 @@ inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.3: resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== -ini@^1.3.2, ini@^1.3.4: +ini@^1.3.2, ini@^1.3.4, ini@~1.3.0: version "1.3.5" resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.5.tgz#eee25f56db1c9ec6085e0c22778083f596abf927" integrity sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw== @@ -5223,7 +5255,7 @@ js-tokens@^4.0.0: resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== -js-yaml@^3.13.1: +js-yaml@^3.13.1, js-yaml@~3.13.1: version "3.13.1" resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.13.1.tgz#aff151b30bfdfa8e49e05da22e7415e9dfa37847" integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw== @@ -5321,6 +5353,11 @@ json5@2.x, json5@^2.1.0: dependencies: minimist "^1.2.0" +jsonc-parser@~2.2.0: + version "2.2.1" + resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-2.2.1.tgz#db73cd59d78cce28723199466b2a03d1be1df2bc" + integrity sha512-o6/yDBYccGvTz1+QFevz6l6OBZ2+fMVu2JZ9CIhzsYRX4mjaK5IyX9eldUdCmga16zlgQxyrj5pt9kzuj2C02w== + jsonfile@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb" @@ -5414,6 +5451,13 @@ lines-and-columns@^1.1.6: resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.1.6.tgz#1c00c743b433cd0a4e80758f7b64a57440d9ff00" integrity sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA= +linkify-it@^2.0.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/linkify-it/-/linkify-it-2.2.0.tgz#e3b54697e78bf915c70a38acd78fd09e0058b1cf" + integrity sha512-GnAl/knGn+i1U/wjBz3akz2stz+HrHLsxMwHQGofCDfPvlf+gDKN58UtfmUquTY4/MXeE2x7k19KQmeoZi94Iw== + dependencies: + uc.micro "^1.0.1" + lint-staged@^9.4.3: version "9.4.3" resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-9.4.3.tgz#f55ad5f94f6e105294bfd6499b23142961f7b982" @@ -5553,6 +5597,16 @@ lodash.clonedeep@^4.5.0: resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef" integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8= +lodash.differencewith@~4.5.0: + version "4.5.0" + resolved "https://registry.yarnpkg.com/lodash.differencewith/-/lodash.differencewith-4.5.0.tgz#bafafbc918b55154e179176a00bb0aefaac854b7" + integrity sha1-uvr7yRi1UVTheRdqALsK76rIVLc= + +lodash.flatten@~4.4.0: + version "4.4.0" + resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f" + integrity sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8= + lodash.get@^4.4.2: version "4.4.2" resolved "https://registry.yarnpkg.com/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99" @@ -5736,11 +5790,58 @@ map-visit@^1.0.0: dependencies: object-visit "^1.0.0" +markdown-it@10.0.0: + version "10.0.0" + resolved "https://registry.yarnpkg.com/markdown-it/-/markdown-it-10.0.0.tgz#abfc64f141b1722d663402044e43927f1f50a8dc" + integrity sha512-YWOP1j7UbDNz+TumYP1kpwnP0aEa711cJjrAQrzd0UXlbJfc5aAq0F/PZHjiioqDC1NKgvIMX+o+9Bk7yuM2dg== + dependencies: + argparse "^1.0.7" + entities "~2.0.0" + linkify-it "^2.0.0" + mdurl "^1.0.1" + uc.micro "^1.0.5" + +markdownlint-cli@^0.22.0: + version "0.22.0" + resolved "https://registry.yarnpkg.com/markdownlint-cli/-/markdownlint-cli-0.22.0.tgz#e5e3251ae6207a41eeb01640363fe2aa0f663a51" + integrity sha512-qRg6tK5dXWqkaFvEstz9YSQal1ECMgofrSZgdBOaPWG8cD50pk8Hs0ZpBCJ6SCHPKF71pCdtuSL2u82sIx2XWA== + dependencies: + commander "~2.9.0" + deep-extend "~0.5.1" + get-stdin "~5.0.1" + glob "~7.1.2" + ignore "~5.1.4" + js-yaml "~3.13.1" + jsonc-parser "~2.2.0" + lodash.differencewith "~4.5.0" + lodash.flatten "~4.4.0" + markdownlint "~0.19.0" + markdownlint-rule-helpers "~0.7.0" + minimatch "~3.0.4" + rc "~1.2.7" + +markdownlint-rule-helpers@~0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/markdownlint-rule-helpers/-/markdownlint-rule-helpers-0.7.0.tgz#66476c373fcad6727ac5b64cb662e900cbe46bfe" + integrity sha512-xZByWJNBaCMHo7nYPv/5aO8Jt68YcMvyouFXhuXmJzbqCsQy8rfCj0kYcv22kdK5PwAgMdbHg0hyTdURbUZtJw== + +markdownlint@~0.19.0: + version "0.19.0" + resolved "https://registry.yarnpkg.com/markdownlint/-/markdownlint-0.19.0.tgz#a692c7b5c077874d4ee8b74e188d6c464ccce81e" + integrity sha512-+MsWOnYVUH4klcKM7iRx5cno9FQMDAb6FC6mWlZkeXPwIaK6Z5Vd9VkXkykPidRqmLHU2wI+MNyfUMnUCBw3pQ== + dependencies: + markdown-it "10.0.0" + marked@^0.7.0: version "0.7.0" resolved "https://registry.yarnpkg.com/marked/-/marked-0.7.0.tgz#b64201f051d271b1edc10a04d1ae9b74bb8e5c0e" integrity sha512-c+yYdCZJQrsRjTPhUx7VKkApw9bwDkNbHUKo1ovgcfDjb2kc8rLuRbIFyXL5WOEUwzSSKo3IXpph2K6DqB/KZg== +mdurl@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/mdurl/-/mdurl-1.0.1.tgz#fe85b2ec75a59037f2adfec100fd6c601761152e" + integrity sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4= + meow@5.0.0, meow@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/meow/-/meow-5.0.0.tgz#dfc73d63a9afc714a5e371760eb5c88b91078aa4" @@ -5851,7 +5952,7 @@ mimic-fn@^2.1.0: resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== -minimatch@^3.0.4: +minimatch@^3.0.4, minimatch@~3.0.4: version "3.0.4" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083" integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA== @@ -6828,6 +6929,16 @@ quick-lru@^1.0.0: resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-1.1.0.tgz#4360b17c61136ad38078397ff11416e186dcfbb8" integrity sha1-Q2CxfGETatOAeDl/8RQW4Ybc+7g= +rc@~1.2.7: + version "1.2.8" + resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed" + integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw== + dependencies: + deep-extend "^0.6.0" + ini "~1.3.0" + minimist "^1.2.0" + strip-json-comments "~2.0.1" + react-is@^16.12.0: version "16.12.0" resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.12.0.tgz#2cc0fe0fba742d97fd527c42a13bec4eeb06241c" @@ -7783,6 +7894,11 @@ strip-json-comments@3.0.1, strip-json-comments@^3.0.1: resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.0.1.tgz#85713975a91fb87bf1b305cca77395e40d2a64a7" integrity sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw== +strip-json-comments@~2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a" + integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo= + strong-log-transformer@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/strong-log-transformer/-/strong-log-transformer-2.1.0.tgz#0f5ed78d325e0421ac6f90f7f10e691d6ae3ae10" @@ -8169,6 +8285,11 @@ typescript@*, "typescript@>=3.2.1 <3.9.0", typescript@^3.8.3: resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.8.3.tgz#409eb8544ea0335711205869ec458ab109ee1061" integrity sha512-MYlEfn5VrLNsgudQTVJeNaQFUAI7DkhnOjdpAp4T+ku1TfQClewlbSuTVHiA+8skNBgaf02TL/kLOvig4y3G8w== +uc.micro@^1.0.1, uc.micro@^1.0.5: + version "1.0.6" + resolved "https://registry.yarnpkg.com/uc.micro/-/uc.micro-1.0.6.tgz#9c411a802a409a91fc6cf74081baba34b24499ac" + integrity sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA== + uglify-js@^3.1.4: version "3.6.0" resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.6.0.tgz#704681345c53a8b2079fb6cec294b05ead242ff5"