fix(type-utils): support matching intersection types in TypeOrValueSpecifier with a PackageSpecifier

packages/type-utils/src/TypeOrValueSpecifier.ts

@@ -167,33 +167,50 @@ export function typeMatchesSpecifier(
   specifier: TypeOrValueSpecifier,
   program: ts.Program,
 ): boolean {
-  if (tsutils.isIntrinsicErrorType(type)) {
-    return false;
-  }
-  if (typeof specifier === 'string') {
-    return specifierNameMatches(type, specifier);
-  }
-  if (!specifierNameMatches(type, specifier.name)) {
-    return false;
+  const wholeTypeMatches = ((): boolean => {
+    if (tsutils.isIntrinsicErrorType(type)) {
+      return false;
+    }
+    if (typeof specifier === 'string') {
+      return specifierNameMatches(type, specifier);
+    }
+    if (!specifierNameMatches(type, specifier.name)) {
+      return false;
+    }
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    const declarations = symbol?.getDeclarations() ?? [];
+    const declarationFiles = declarations.map(declaration =>
+      declaration.getSourceFile(),
+    );
+    switch (specifier.from) {
+      case 'file':
+        return typeDeclaredInFile(specifier.path, declarationFiles, program);
+      case 'lib':
+        return typeDeclaredInLib(declarationFiles, program);
+      case 'package':
+        return typeDeclaredInPackageDeclarationFile(
+          specifier.package,
+          declarations,
+          declarationFiles,
+          program,
+        );
+    }
+  })();
+
+  if (wholeTypeMatches) {
+    return true;
   }
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  const declarations = symbol?.getDeclarations() ?? [];
-  const declarationFiles = declarations.map(declaration =>
-    declaration.getSourceFile(),
-  );
-  switch (specifier.from) {
-    case 'file':
-      return typeDeclaredInFile(specifier.path, declarationFiles, program);
-    case 'lib':
-      return typeDeclaredInLib(declarationFiles, program);
-    case 'package':
-      return typeDeclaredInPackageDeclarationFile(
-        specifier.package,
-        declarations,
-        declarationFiles,
-        program,
-      );
+
+  if (
+    tsutils.isIntersectionType(type) &&
+    tsutils
+      .intersectionTypeParts(type)
+      .some(part => typeMatchesSpecifier(part, specifier, program))
+  ) {
+    return true;
   }
+
+  return false;
 }
 
 export const typeMatchesSomeSpecifier = (

packages/type-utils/src/typeOrValueSpecifiers/specifierNameMatches.ts

@@ -1,7 +1,5 @@
 import type * as ts from 'typescript';
 
-import * as tsutils from 'ts-api-utils';
-
 export function specifierNameMatches(
   type: ts.Type,
   names: string | string[],
@@ -19,9 +17,5 @@ export function specifierNameMatches(
     return true;
   }
 
-  if (tsutils.isIntersectionType(type)) {
-    return type.types.some(subType => specifierNameMatches(subType, names));
-  }
-
   return false;
 }

packages/type-utils/tests/TypeOrValueSpecifier.test.ts

@@ -395,15 +395,66 @@ describe('TypeOrValueSpecifier', () => {
       [
         `
           type SafePromise = Promise<number> & { __safeBrand: string };
-          type JoinedPromise = SafePromise & {};
+          type ResultType = { foo: 'bar' };
+          type Test = SafePromise & ResultType;
         `,
-        { from: 'file', name: ['JoinedPromise'] },
+        { from: 'file', name: ['ResultType'] },
       ],
     ])(
       'matches a matching type specifier for an intersection type: %s',
       runTestPositive,
     );
 
+    it.each<[string, TypeOrValueSpecifier]>([
+      [
+        `
+          declare module "node:test" {
+            type SafePromise = Promise<undefined> & { __safeBrand: string };
+            type ItResult = { foo: 'bar' };
+
+            export function it(): SafePromise & ItResult;
+          }
+
+          import { it } from "node:test";
+
+          type Test = ReturnType<typeof it>;
+        `,
+        {
+          from: 'package',
+          name: ['ItResult'],
+          package: 'node:test',
+        },
+      ],
+    ])(
+      'matches a matching package specifier for an intersection type: %s',
+      runTestPositive,
+    );
+
+    it.each<[string, TypeOrValueSpecifier]>([
+      [
+        `
+          declare module "node:test" {
+            type SafePromise = Promise<undefined> & { __safeBrand: string };
+            type ItResult = { foo: 'bar' };
+
+            export function it(): SafePromise & ItResult;
+          }
+
+          import { it } from "node:test";
+
+          type Test = ReturnType<typeof it>;
+        `,
+        {
+          from: 'package',
+          name: ['Result'],
+          package: 'node:test',
+        },
+      ],
+    ])(
+      "doesn't match a mismatched package specifier for an intersection type: %s",
+      runTestNegative,
+    );
+
     it("does not match a `declare global` with the 'global' package name", () => {
       runTestNegative(
         `