@typescript-eslint/eslint-plugin 8.26.2-alpha.0 → 8.26.2-alpha.1

package/docs/rules/no-unnecessary-condition.mdx

@@ -218,26 +218,75 @@ You should be using `strictNullChecks` to ensure complete type-safety in your co
 
 If for some reason you cannot turn on `strictNullChecks`, but still want to use this rule - you can use this option to allow it - but know that the behavior of this rule is _undefined_ with the compiler option turned off. We will not accept bug reports if you are using this option.
 
-## When Not To Use It
+## Limitations
 
-If your project is not accurately typed, such as if it's in the process of being converted to TypeScript or is susceptible to [trade-offs in control flow analysis](https://github.com/Microsoft/TypeScript/issues/9998), it may be difficult to enable this rule for particularly non-type-safe areas of code.
-You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.
+This rule is powered by TypeScript types, therefore, if the types do not match match the runtime behavior, the rule may report inaccurately.
+This can happen in several commonplace scenarios.
 
-This rule has a known edge case of triggering on conditions that were modified within function calls (as side effects).
-It is due to limitations of TypeScript's type narrowing.
-See [#9998](https://github.com/microsoft/TypeScript/issues/9998) for details.
-We recommend using a [type assertion](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-assertions) in those cases.
+### Possibly-undefined indexed access
 
-```ts
+By default, TypeScript optimistically assumes that indexed access will always return a value.
+This means that cases like the following will be erroneously flagged as unnecessary conditions:
+
+```ts showPlaygroundButton
+const array: string[] = [];
+const firstElement = array[0];
+// false positive
+if (firstElement != null) {
+  // ...
+}
+
+const record: Record<string, string> = {};
+const someValue = record.someKey;
+// false positive
+if (someValue != null) {
+  // ...
+}
+```
+
+To get pessimistic, but correct, types for these cases, you can use TypeScript's [`noUncheckedIndexedAccess` compiler option](https://www.typescriptlang.org/tsconfig/#noUncheckedIndexedAccess), though this is often unwieldy in real-world usage.
+Another workaround is to use `array.at(0)` (which is always possibly-undefined) to indicate array access that may be out-of-bounds.
+Otherwise, a disable comment will often make sense for these kinds of cases.
+
+### Values modified within function calls
+
+The following code will be erroneously flagged as unnecessary, even though the condition is modified within the function call.
+
+```ts showPlaygroundButton
+let condition = false;
+
+const f = () => {
+  condition = Math.random() > 0.5;
+};
+f();
+
+if (condition) {
+  // ...
+}
+```
+
+This occurs due to limitations of TypeScript's type narrowing.
+See [microsoft/TypeScript#9998](https://github.com/microsoft/TypeScript/issues/9998) for details.
+We recommend using a [type assertion](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-assertions) in these cases, like so:
+
+```ts showPlaygroundButton
 let condition = false as boolean;
 
-const f = () => (condition = true);
+const f = () => {
+  condition = Math.random() > 0.5;
+};
 f();
 
 if (condition) {
+  // ...
 }
 ```
 
+## When Not To Use It
+
+If your project is not accurately typed, such as if it's in the process of being converted to TypeScript or is susceptible to [trade-offs in control flow analysis](https://github.com/Microsoft/TypeScript/issues/9998), it may be difficult to enable this rule for particularly non-type-safe areas of code.
+You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.
+
 ## Related To
 
 - ESLint: [no-constant-condition](https://eslint.org/docs/rules/no-constant-condition) - `no-unnecessary-condition` is essentially a stronger version of `no-constant-condition`, but requires type information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.26.2-alpha.0",
+  "version": "8.26.2-alpha.1",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -62,10 +62,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.26.2-alpha.0",
-    "@typescript-eslint/type-utils": "8.26.2-alpha.0",
-    "@typescript-eslint/utils": "8.26.2-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.26.2-alpha.0",
+    "@typescript-eslint/scope-manager": "8.26.2-alpha.1",
+    "@typescript-eslint/type-utils": "8.26.2-alpha.1",
+    "@typescript-eslint/utils": "8.26.2-alpha.1",
+    "@typescript-eslint/visitor-keys": "8.26.2-alpha.1",
     "graphemer": "^1.4.0",
     "ignore": "^5.3.1",
     "natural-compare": "^1.4.0",
@@ -76,8 +76,8 @@
     "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.26.2-alpha.0",
-    "@typescript-eslint/rule-tester": "8.26.2-alpha.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.26.2-alpha.1",
+    "@typescript-eslint/rule-tester": "8.26.2-alpha.1",
     "ajv": "^6.12.6",
     "cross-env": "^7.0.3",
     "cross-fetch": "*",