typescript-eslint · OleksandraKordonets · Dec 10, 2025 · Dec 10, 2025 · Dec 10, 2025 · Dec 12, 2025
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -302,6 +302,14 @@ export default createRule({
         return false;
       }
 
+      if (
+        result.deep &&
+        comparisonType === ComparisonType.Basic &&
+        senderNode.type === AST_NODE_TYPES.ObjectExpression
+      ) {
+        return false;
+      }
+
       const { receiver, sender } = result;
       context.report({
         node: reportingNode,

diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-argument.test.ts
@@ -45,6 +45,11 @@ const x = [1, 2] as const;
 foo(...x);
     `,
     `
+declare const fromLib: { foo: number };
+declare function fn(x: { foo: number }): string;
+fn(fromLib);
+    `,
+    `
 declare function foo(arg: any, arg2: number): void;
 const x = [1 as any, 2] as const;
 foo(...x);
@@ -131,6 +136,18 @@ foo(1 as any);
     },
     {
       code: `
+declare const fromLib: { foo: any };
+declare function fn(x: { foo: number }): string;
+fn(fromLib);
+      `,
+      errors: [
+        {
+          messageId: 'unsafeArgument',
+        },
+      ],
+    },
+    {
+      code: `
 declare function foo(arg: number): void;
 foo(error);
       `,

diff --git a/packages/scope-manager/tests/lib.test.ts b/packages/scope-manager/tests/lib.test.ts
@@ -1,3 +1,5 @@
+import type { AnalyzeOptions } from '../src/analyze';
+
 import { ImplicitLibVariable } from '../src';
 import { parseAndAnalyze } from './test-utils';
 
@@ -121,8 +123,7 @@ describe('implicit lib definitions', () => {
   it('should throw if passed an unrecognized lib name', () => {
     expect(() => {
       parseAndAnalyze('var f = (a: Symbol) => a;', {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        lib: ['invalid+lib' as any],
+        lib: ['invalid+lib'] as unknown as AnalyzeOptions['lib'],
       });
     }).toThrowError('invalid+lib');
   });

diff --git a/packages/type-utils/src/isUnsafeAssignment.ts b/packages/type-utils/src/isUnsafeAssignment.ts
@@ -1,10 +1,67 @@
 import type { TSESTree } from '@typescript-eslint/utils';
-import type * as ts from 'typescript';
 
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
+import * as ts from 'typescript';
 
 import { isTypeAnyType, isTypeUnknownType } from './predicates';
+import { getTypeOfPropertyOfName } from './propertyTypes';
+
+function typeContainsAny(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+  seen = new Set<ts.Type>(),
+): boolean {
+  if (seen.has(type)) {
+    return false;
+  }
+  seen.add(type);
+
+  if (isTypeAnyType(type)) {
+    return true;
+  }
+
+  if (tsutils.isUnionOrIntersectionType(type)) {
+    return type.types.some(t => typeContainsAny(t, checker, seen));
+  }
+
+  if (tsutils.isTypeReference(type)) {
+    const args = type.typeArguments ?? [];
+    return args.some(arg => typeContainsAny(arg, checker, seen));
+  }
+
+  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+    return checker
+      .getTypeArguments(type)
+      .some(arg => typeContainsAny(arg, checker, seen));
+  }
+
+  if (tsutils.isObjectType(type)) {
+    const stringIndex = checker.getIndexInfoOfType(type, ts.IndexKind.String);
+    if (stringIndex && typeContainsAny(stringIndex.type, checker, seen)) {
+      return true;
+    }
+
+    const numberIndex = checker.getIndexInfoOfType(type, ts.IndexKind.Number);
+    if (numberIndex && typeContainsAny(numberIndex.type, checker, seen)) {
+      return true;
+    }
+
+    for (const property of type.getProperties()) {
+      const propertyType = getTypeOfPropertyOfName(
+        checker,
+        type,
+        property.getName(),
+        property.getEscapedName(),
+      );
+      if (propertyType && typeContainsAny(propertyType, checker, seen)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
 
 /**
  * Does a simple check to see if there is an any being assigned to a non-any type.
@@ -21,7 +78,7 @@ export function isUnsafeAssignment(
   receiver: ts.Type,
   checker: ts.TypeChecker,
   senderNode: TSESTree.Node | null,
-): false | { receiver: ts.Type; sender: ts.Type } {
+): false | { receiver: ts.Type; sender: ts.Type; deep?: boolean } {
   return isUnsafeAssignmentWorker(
     type,
     receiver,
@@ -37,15 +94,36 @@ function isUnsafeAssignmentWorker(
   checker: ts.TypeChecker,
   senderNode: TSESTree.Node | null,
   visited: Map<ts.Type, Set<ts.Type>>,
-): false | { receiver: ts.Type; sender: ts.Type } {
+): false | { receiver: ts.Type; sender: ts.Type; deep?: boolean } {
+  function isFromDefaultLibrary(t: ts.Type): boolean {
+    const declarations = t.getSymbol()?.getDeclarations();
+    return (
+      declarations?.some(decl => {
+        const fileName = decl.getSourceFile().fileName;
+        return (
+          decl.getSourceFile().hasNoDefaultLib ||
+          fileName.includes('typescript/lib')
+        );
+      }) ?? false
+    );
+  }
+
+  if (type === receiver) {
+    return false;
+  }
+
+  if (!typeContainsAny(type, checker)) {
+    return false;
+  }
+
   if (isTypeAnyType(type)) {
     // Allow assignment of any ==> unknown.
     if (isTypeUnknownType(receiver)) {
       return false;
     }
 
     if (!isTypeAnyType(receiver)) {
-      return { receiver, sender: type };
+      return { deep: true, receiver, sender: type };
     }
   }
 
@@ -60,6 +138,46 @@ function isUnsafeAssignmentWorker(
     visited.set(type, new Set([receiver]));
   }
 
+  if (checker.isTupleType(type) && checker.isTupleType(receiver)) {
+    const senderElements = checker.getTypeArguments(type);
+    const receiverElements = checker.getTypeArguments(receiver);
+    const length = Math.min(senderElements.length, receiverElements.length);
+
+    for (let i = 0; i < length; i += 1) {
+      const unsafe = isUnsafeAssignmentWorker(
+        senderElements[i],
+        receiverElements[i],
+        checker,
+        senderNode,
+        visited,
+      );
+      if (unsafe) {
+        return { deep: true, receiver, sender: type };
+      }
+    }
+
+    return false;
+  }
+
+  if (checker.isArrayType(type) && checker.isArrayType(receiver)) {
+    const senderElementType = checker.getTypeArguments(type)[0];
+    const receiverElementType = checker.getTypeArguments(receiver)[0];
+
+    const unsafe = isUnsafeAssignmentWorker(
+      senderElementType,
+      receiverElementType,
+      checker,
+      senderNode,
+      visited,
+    );
+
+    if (unsafe) {
+      return { deep: true, receiver, sender: type };
+    }
+
+    return false;
+  }
+
   if (tsutils.isTypeReference(type) && tsutils.isTypeReference(receiver)) {
     // TODO - figure out how to handle cases like this,
     // where the types are assignable, but not the same type
@@ -108,12 +226,130 @@ function isUnsafeAssignmentWorker(
         visited,
       );
       if (unsafe) {
-        return { receiver, sender: type };
+        return { deep: true, receiver, sender: type };
       }
     }
 
     return false;
   }
 
+  if (tsutils.isUnionType(type)) {
+    for (const unionType of tsutils.unionConstituents(type)) {
+      const unsafe = isUnsafeAssignmentWorker(
+        unionType,
+        receiver,
+        checker,
+        senderNode,
+        visited,
+      );
+      if (unsafe) {
+        return { deep: true, receiver, sender: type };
+      }
+    }
+    return false;
+  }
+
+  if (tsutils.isUnionType(receiver)) {
+    for (const receiverType of tsutils.unionConstituents(receiver)) {
+      const unsafe = isUnsafeAssignmentWorker(
+        type,
+        receiverType,
+        checker,
+        senderNode,
+        visited,
+      );
+      if (unsafe) {
+        return { deep: true, receiver, sender: type };
+      }
+    }
+    return false;
+  }
+
+  if (tsutils.isObjectType(type) && tsutils.isObjectType(receiver)) {
+    if (isFromDefaultLibrary(receiver)) {
+      return false;
+    }
+
+    const receiverStringIndex = checker.getIndexInfoOfType(
+      receiver,
+      ts.IndexKind.String,
+    );
+    if (receiverStringIndex) {
+      const senderStringIndex = checker.getIndexInfoOfType(
+        type,
+        ts.IndexKind.String,
+      );
+      if (senderStringIndex) {
+        const unsafe = isUnsafeAssignmentWorker(
+          senderStringIndex.type,
+          receiverStringIndex.type,
+          checker,
+          senderNode,
+          visited,
+        );
+        if (unsafe) {
+          return { deep: true, receiver, sender: type };
+        }
+      }
+    }
+
+    const receiverNumberIndex = checker.getIndexInfoOfType(
+      receiver,
+      ts.IndexKind.Number,
+    );
+    if (receiverNumberIndex) {
+      const senderNumberIndex = checker.getIndexInfoOfType(
+        type,
+        ts.IndexKind.Number,
+      );
+      if (senderNumberIndex) {
+        const unsafe = isUnsafeAssignmentWorker(
+          senderNumberIndex.type,
+          receiverNumberIndex.type,
+          checker,
+          senderNode,
+          visited,
+        );
+        if (unsafe) {
+          return { deep: true, receiver, sender: type };
+        }
+      }
+    }
+
+    for (const receiverProperty of receiver.getProperties()) {
+      const propertyName = receiverProperty.getName();
+      const senderPropertyType = getTypeOfPropertyOfName(
+        checker,
+        type,
+        propertyName,
+        receiverProperty.getEscapedName(),
+      );
+      if (!senderPropertyType) {
+        continue;
+      }
+
+      const receiverPropertyType = getTypeOfPropertyOfName(
+        checker,
+        receiver,
+        propertyName,
+        receiverProperty.getEscapedName(),
+      );
+      if (!receiverPropertyType) {
+        continue;
+      }
+
+      const unsafe = isUnsafeAssignmentWorker(
+        senderPropertyType,
+        receiverPropertyType,
+        checker,
+        senderNode,
+        visited,
+      );
+      if (unsafe) {
+        return { deep: true, receiver, sender: type };
+      }
+    }
+  }
+
   return false;
 }