@typescript-eslint/eslint-plugin 8.70.1-alpha.17 → 8.70.1-alpha.19

package/dist/rules/no-unnecessary-condition.js

@@ -55,6 +55,15 @@ function isPossiblyNullish(type) {
         .unionConstituents(type)
         .some(t => isNullishType(t) || (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
 }
+/**
+ * Note that this differs from {@link isNullableType} in that it doesn't consider
+ * `any` or `unknown` to be nullable.
+ */
+function isPossiblyNonNullish(type) {
+    return tsutils
+        .unionConstituents(type)
+        .some(t => !isNullishType(t) && !(0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Void));
+}
 function toStaticValue(type) {
     // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
     if (tsutils.isBooleanLiteralType(type)) {
@@ -262,11 +271,48 @@ exports.default = (0, util_1.createRule)({
             const propertyType = objectType
                 .getProperties()
                 .find(prop => prop.name === propertyName);
-            if (propertyType &&
-                tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional)) {
-                return true;
+            return (propertyType != null &&
+                tsutils.isSymbolFlagSet(propertyType, ts.SymbolFlags.Optional));
+        }
+        /**
+         * Obtains the property types of the computed member expression
+         * @param node The member expression
+         * @returns The property types, unless the node isn't computed.
+         */
+        function getComputedMemberPropertyTypes(node) {
+            if (!node.computed) {
+                return undefined;
+            }
+            const objectType = (0, util_1.getConstrainedTypeAtLocation)(services, node.object);
+            const propertyType = (0, util_1.getConstrainedTypeAtLocation)(services, node.property);
+            const propertyTypes = [];
+            for (const keyType of tsutils.unionConstituents(propertyType)) {
+                if (!keyType.isStringLiteral() && !keyType.isNumberLiteral()) {
+                    return undefined;
+                }
+                const selectedType = (0, util_1.getTypeOfPropertyOfName)(checker, objectType, String(keyType.value));
+                if (!selectedType) {
+                    return undefined;
+                }
+                propertyTypes.push(selectedType);
             }
-            return false;
+            return propertyTypes;
+        }
+        /**
+         * Verify if the node may have non-nullish properties
+         * @param node The node to verify
+         * @returns If it may have non-nullish properties, unless the node isn't a
+         * MemberExpression
+         */
+        function hasPossiblyNonNullishComputedMemberProperty(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            const propertyTypes = getComputedMemberPropertyTypes(node);
+            if (propertyTypes == null) {
+                return false;
+            }
+            return propertyTypes.some(isPossiblyNonNullish);
         }
         /**
          * Checks if a conditional node is necessary:
@@ -344,7 +390,8 @@ exports.default = (0, util_1.createRule)({
                     messageId = 'neverNullish';
                 }
             }
-            else if (isAlwaysNullish(type)) {
+            else if (isAlwaysNullish(type) &&
+                !hasPossiblyNonNullishComputedMemberProperty(node)) {
                 messageId = 'alwaysNullish';
             }
             if (messageId) {

package/dist/rules/no-unnecessary-parameter-property-assignment.js

@@ -101,10 +101,6 @@ exports.default = (0, util_1.createRule)({
                 });
             },
             "MethodDefinition[kind='constructor'] > FunctionExpression AssignmentExpression"(node) {
-                const leftName = getPropertyName(node.left);
-                if (!leftName) {
-                    return;
-                }
                 let functionNode = findParentFunction(node);
                 if (functionNode && isArrowIIFE(functionNode)) {
                     functionNode = findParentFunction(functionNode.parent);
@@ -113,6 +109,18 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const { assignedBeforeUnnecessary, unnecessaryAssignments } = (0, util_1.nullThrows)(reportInfoStack.at(reportInfoStack.length - 1), 'The top of stack should exist');
+                // A prior write to the parameter binding means a later `this.x = x`
+                // may copy a different value than the parameter property initialized.
+                if (node.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    if (isReferenceFromParameter(node.left)) {
+                        assignedBeforeUnnecessary.add(node.left.name);
+                    }
+                    return;
+                }
+                const leftName = getPropertyName(node.left);
+                if (!leftName) {
+                    return;
+                }
                 if (!UNNECESSARY_OPERATORS.has(node.operator)) {
                     assignedBeforeUnnecessary.add(leftName);
                     return;

package/dist/rules/unbound-method.js

@@ -90,6 +90,19 @@ const SUPPORTED_GLOBAL_TYPES = [
     'Math',
     'JSON',
 ];
+/**
+ * Methods on instances of built-in classes that are defined by the ECMAScript
+ * spec as *bound* to their instance (i.e. they are safe to call without their
+ * receiver), but whose TypeScript declarations don't model that binding - they
+ * are declared as plain methods that would require a `this` value.
+ *
+ * For example, `Intl.Collator.prototype.compare` is defined as a bound getter
+ * function per the ECMA-402 spec:
+ * https://tc39.es/ecma402/#sec-intl.collator.prototype.compare
+ * ...but `lib.es5.d.ts` declares it as a regular method, so this rule would
+ * otherwise incorrectly flag usages such as `array.sort(collator.compare)`.
+ */
+const nativelyBoundInstanceMethods = new Set(['Collator.compare']);
 const isNotImported = (symbol, currentSourceFile) => {
     const { valueDeclaration } = symbol;
     if (!valueDeclaration) {
@@ -99,6 +112,18 @@ const isNotImported = (symbol, currentSourceFile) => {
     return (!!currentSourceFile &&
         currentSourceFile !== valueDeclaration.getSourceFile());
 };
+/**
+ * Returns `true` if `propertyName` is a member of a built-in class instance
+ * that is defined by the spec as bound to that instance (see
+ * `nativelyBoundInstanceMethods` above).
+ */
+function isSpecBoundBuiltinMethod(program, objectType, propertyName) {
+    const symbol = objectType.getSymbol();
+    if (!symbol || !(0, util_1.isSymbolFromDefaultLibrary)(program, symbol)) {
+        return false;
+    }
+    return nativelyBoundInstanceMethods.has(`${symbol.getName()}.${propertyName}`);
+}
 const BASE_MESSAGE = [
     `A method that is not declared with \`this: void\` may cause unintentional scoping of \`this\` when separated from its object.`,
     `Consider using an arrow function or explicitly \`.bind()\`ing the method to avoid calling the method with an unintended \`this\` value. `,
@@ -196,6 +221,12 @@ exports.default = (0, util_1.createRule)({
                     return true;
                 }
             }
+            if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const objectType = services.getTypeAtLocation(object);
+                if (isSpecBoundBuiltinMethod(services.program, objectType, property.name)) {
+                    return true;
+                }
+            }
             // if `${object.name}.${property.name}` doesn't match any of
             // the nativelyBoundMembers, then we fallback to type-level checks
             return ((0, util_1.isBuiltinSymbolLike)(services.program, services.getTypeAtLocation(object), SUPPORTED_GLOBAL_TYPES) &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.70.1-alpha.17",
+  "version": "8.70.1-alpha.19",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -47,10 +47,10 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.70.1-alpha.17",
-    "@typescript-eslint/type-utils": "8.70.1-alpha.17",
-    "@typescript-eslint/utils": "8.70.1-alpha.17",
-    "@typescript-eslint/visitor-keys": "8.70.1-alpha.17",
+    "@typescript-eslint/scope-manager": "8.70.1-alpha.19",
+    "@typescript-eslint/type-utils": "8.70.1-alpha.19",
+    "@typescript-eslint/utils": "8.70.1-alpha.19",
+    "@typescript-eslint/visitor-keys": "8.70.1-alpha.19",
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0"
@@ -60,8 +60,8 @@
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "^1.4.3",
     "@types/react": "^18.3.21",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.70.1-alpha.17",
-    "@typescript-eslint/rule-tester": "8.70.1-alpha.17",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.70.1-alpha.19",
+    "@typescript-eslint/rule-tester": "8.70.1-alpha.19",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
@@ -81,7 +81,7 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.70.1-alpha.17",
+    "@typescript-eslint/parser": "^8.70.1-alpha.19",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },