Fixed too eager type resolution when looking for symbol aliases

src/compiler/checker.ts

@@ -5731,15 +5731,57 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         });
     }
 
+    function resolveTypeAliasSymbol(symbol: Symbol): Symbol | undefined {
+        if (!symbol.declarations) {
+            return;
+        }
+        for (const decl of symbol.declarations) {
+            if (!isTypeAliasDeclaration(decl)) {
+                continue;
+            }
+            const location = getDirectTypeAliasLocation(decl);
+            if (!location) {
+                continue;
+            }
+            const aliased = resolveSymbol(getSymbolAtLocation(location));
+            if (aliased) {
+                return aliased.flags & SymbolFlags.TypeAlias && resolveTypeAliasSymbol(aliased) || aliased;
+            }
+        }
+
+        function getDirectTypeAliasLocation(decl: TypeAliasDeclaration): Node | undefined {
+            if (decl.typeParameters) {
+                return;
+            }
+            const typeNode = decl.type;
+            switch (typeNode.kind) {
+                case SyntaxKind.TypeReference: {
+                    const { typeName, typeArguments } = typeNode as TypeReferenceNode;
+                    if (typeArguments) {
+                        return;
+                    }
+                    return typeName;
+                }
+                case SyntaxKind.ImportType: {
+                    const { qualifier, typeArguments } = typeNode as ImportTypeNode;
+                    if (typeArguments) {
+                        return;
+                    }
+                    return qualifier || typeNode;
+                }
+            }
+        }
+    }
+
     /**
      * Checks if two symbols, through aliasing and/or merging, refer to the same thing
      */
     function getSymbolIfSameReference(s1: Symbol, s2: Symbol) {
-        if (s1.flags & SymbolFlags.TypeAlias && s2.declarations?.find(isTypeAlias)) {
-            s2 = getDeclaredTypeOfTypeAlias(s2).aliasSymbol || s2;
+        if (s1.flags & SymbolFlags.TypeAlias) {
+            s2 = resolveTypeAliasSymbol(s2) || s2;
         }
-        if (s2.flags & SymbolFlags.TypeAlias && s1.declarations?.find(isTypeAlias)) {
-            s1 = getDeclaredTypeOfTypeAlias(s1).aliasSymbol || s1;
+        if (s2.flags & SymbolFlags.TypeAlias) {
+            s1 = resolveTypeAliasSymbol(s1) || s1;
         }
         if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
             return s1;

tests/baselines/reference/declarationEmitUsingTypeAlias2.js

@@ -0,0 +1,53 @@
+//// [tests/cases/compiler/declarationEmitUsingTypeAlias2.ts] ////
+
+//// [inner.d.ts]
+export declare type Other = { other: string };
+export declare type SomeType = { arg: Other };
+
+//// [indirection.d.ts]
+import { Other as IndirectOther, SomeType as IndirectSomeType } from './inner';
+export declare type Other = IndirectOther;
+export declare type SomeType = IndirectSomeType
+
+//// [index.d.ts]
+import { Other, SomeType as IndirectSomeType } from './indirection';
+export type OtherType = Other;
+export type SomeType = IndirectSomeType;
+
+//// [package.json]
+{
+  "name": "some-dep",
+  "exports": {
+    ".": "./dist/index.js"
+  }
+}
+
+//// [index.ts]
+import { SomeType } from "some-dep";
+
+export const foo = (thing: SomeType) => {
+  return thing;
+};
+
+export const bar = (thing: SomeType) => {
+  return thing.arg;
+};
+
+//// [index.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bar = exports.foo = void 0;
+var foo = function (thing) {
+    return thing;
+};
+exports.foo = foo;
+var bar = function (thing) {
+    return thing.arg;
+};
+exports.bar = bar;
+
+
+//// [index.d.ts]
+import { SomeType } from "some-dep";
+export declare const foo: (thing: SomeType) => import("some-dep").SomeType;
+export declare const bar: (thing: SomeType) => import("some-dep").OtherType;

tests/baselines/reference/declarationEmitUsingTypeAlias2.symbols

@@ -0,0 +1,66 @@
+//// [tests/cases/compiler/declarationEmitUsingTypeAlias2.ts] ////
+
+=== node_modules/some-dep/dist/inner.d.ts ===
+export declare type Other = { other: string };
+>Other : Symbol(Other, Decl(inner.d.ts, 0, 0))
+>other : Symbol(other, Decl(inner.d.ts, 0, 29))
+
+export declare type SomeType = { arg: Other };
+>SomeType : Symbol(SomeType, Decl(inner.d.ts, 0, 46))
+>arg : Symbol(arg, Decl(inner.d.ts, 1, 32))
+>Other : Symbol(Other, Decl(inner.d.ts, 0, 0))
+
+=== node_modules/some-dep/dist/indirection.d.ts ===
+import { Other as IndirectOther, SomeType as IndirectSomeType } from './inner';
+>Other : Symbol(IndirectOther, Decl(inner.d.ts, 0, 0))
+>IndirectOther : Symbol(IndirectOther, Decl(indirection.d.ts, 0, 8))
+>SomeType : Symbol(IndirectSomeType, Decl(inner.d.ts, 0, 46))
+>IndirectSomeType : Symbol(IndirectSomeType, Decl(indirection.d.ts, 0, 32))
+
+export declare type Other = IndirectOther;
+>Other : Symbol(Other, Decl(indirection.d.ts, 0, 79))
+>IndirectOther : Symbol(IndirectOther, Decl(indirection.d.ts, 0, 8))
+
+export declare type SomeType = IndirectSomeType
+>SomeType : Symbol(SomeType, Decl(indirection.d.ts, 1, 42))
+>IndirectSomeType : Symbol(IndirectSomeType, Decl(indirection.d.ts, 0, 32))
+
+=== node_modules/some-dep/dist/index.d.ts ===
+import { Other, SomeType as IndirectSomeType } from './indirection';
+>Other : Symbol(Other, Decl(index.d.ts, 0, 8))
+>SomeType : Symbol(IndirectSomeType, Decl(indirection.d.ts, 1, 42))
+>IndirectSomeType : Symbol(IndirectSomeType, Decl(index.d.ts, 0, 15))
+
+export type OtherType = Other;
+>OtherType : Symbol(OtherType, Decl(index.d.ts, 0, 68))
+>Other : Symbol(Other, Decl(index.d.ts, 0, 8))
+
+export type SomeType = IndirectSomeType;
+>SomeType : Symbol(SomeType, Decl(index.d.ts, 1, 30))
+>IndirectSomeType : Symbol(IndirectSomeType, Decl(index.d.ts, 0, 15))
+
+=== src/index.ts ===
+import { SomeType } from "some-dep";
+>SomeType : Symbol(SomeType, Decl(index.ts, 0, 8))
+
+export const foo = (thing: SomeType) => {
+>foo : Symbol(foo, Decl(index.ts, 2, 12))
+>thing : Symbol(thing, Decl(index.ts, 2, 20))
+>SomeType : Symbol(SomeType, Decl(index.ts, 0, 8))
+
+  return thing;
+>thing : Symbol(thing, Decl(index.ts, 2, 20))
+
+};
+
+export const bar = (thing: SomeType) => {
+>bar : Symbol(bar, Decl(index.ts, 6, 12))
+>thing : Symbol(thing, Decl(index.ts, 6, 20))
+>SomeType : Symbol(SomeType, Decl(index.ts, 0, 8))
+
+  return thing.arg;
+>thing.arg : Symbol(arg, Decl(inner.d.ts, 1, 32))
+>thing : Symbol(thing, Decl(index.ts, 6, 20))
+>arg : Symbol(arg, Decl(inner.d.ts, 1, 32))
+
+};

tests/baselines/reference/declarationEmitUsingTypeAlias2.types

@@ -0,0 +1,61 @@
+//// [tests/cases/compiler/declarationEmitUsingTypeAlias2.ts] ////
+
+=== node_modules/some-dep/dist/inner.d.ts ===
+export declare type Other = { other: string };
+>Other : { other: string; }
+>other : string
+
+export declare type SomeType = { arg: Other };
+>SomeType : { arg: Other; }
+>arg : Other
+
+=== node_modules/some-dep/dist/indirection.d.ts ===
+import { Other as IndirectOther, SomeType as IndirectSomeType } from './inner';
+>Other : any
+>IndirectOther : any
+>SomeType : any
+>IndirectSomeType : any
+
+export declare type Other = IndirectOther;
+>Other : IndirectOther
+
+export declare type SomeType = IndirectSomeType
+>SomeType : IndirectSomeType
+
+=== node_modules/some-dep/dist/index.d.ts ===
+import { Other, SomeType as IndirectSomeType } from './indirection';
+>Other : any
+>SomeType : any
+>IndirectSomeType : any
+
+export type OtherType = Other;
+>OtherType : import("node_modules/some-dep/dist/inner").Other
+
+export type SomeType = IndirectSomeType;
+>SomeType : import("node_modules/some-dep/dist/inner").SomeType
+
+=== src/index.ts ===
+import { SomeType } from "some-dep";
+>SomeType : any
+
+export const foo = (thing: SomeType) => {
+>foo : (thing: SomeType) => import("node_modules/some-dep/dist/inner").SomeType
+>(thing: SomeType) => {  return thing;} : (thing: SomeType) => import("node_modules/some-dep/dist/inner").SomeType
+>thing : import("node_modules/some-dep/dist/inner").SomeType
+
+  return thing;
+>thing : import("node_modules/some-dep/dist/inner").SomeType
+
+};
+
+export const bar = (thing: SomeType) => {
+>bar : (thing: SomeType) => import("node_modules/some-dep/dist/inner").Other
+>(thing: SomeType) => {  return thing.arg;} : (thing: SomeType) => import("node_modules/some-dep/dist/inner").Other
+>thing : import("node_modules/some-dep/dist/inner").SomeType
+
+  return thing.arg;
+>thing.arg : import("node_modules/some-dep/dist/inner").Other
+>thing : import("node_modules/some-dep/dist/inner").SomeType
+>arg : import("node_modules/some-dep/dist/inner").Other
+
+};

tests/baselines/reference/errorReportNotCircular1.errors.txt

@@ -0,0 +1,52 @@
+data.ts(6,24): error TS2345: Argument of type '{}' is not assignable to parameter of type 'Data'.
+  Property 'quantity' is missing in type '{}' but required in type 'Data'.
+data.ts(6,28): error TS1360: Type '{ quantity: Value; }' does not satisfy the expected type '[]'.
+
+
+==== data.ts (2 errors) ====
+    // https://github.com/microsoft/TypeScript/issues/57357
+
+    import type { Data } from "./processor";
+
+    export function getData() {
+      return constructData({}) satisfies []; // error
+                           ~~
+!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'Data'.
+!!! error TS2345:   Property 'quantity' is missing in type '{}' but required in type 'Data'.
+!!! related TS2728 processor.ts:6:3: 'quantity' is declared here.
+                               ~~~~~~~~~
+!!! error TS1360: Type '{ quantity: Value; }' does not satisfy the expected type '[]'.
+    }
+
+    function constructData(data: Data) {
+      const { ...props } = data;
+      return {
+        ...props,
+      };
+    }
+
+==== type.ts (0 errors) ====
+    export type Value = {};
+
+==== processor.ts (0 errors) ====
+    import { getData } from "./data";
+
+    import type { Value } from "./type";
+
+    export type Data = {
+      quantity: Value;
+    };
+
+    declare function createRequestProcessor<Req>(pipeline: () => Req): Req;
+
+    export const processor = createRequestProcessor(getData);
+
+==== main.ts (0 errors) ====
+    import { processor } from "./processor";
+    export default processor;
+
+==== workerinterface.ts (0 errors) ====
+    import type Server from "./main";
+
+    export type _T = typeof Server;
+

tests/baselines/reference/errorReportNotCircular1.js

@@ -0,0 +1,65 @@
+//// [tests/cases/compiler/errorReportNotCircular1.ts] ////
+
+//// [data.ts]
+// https://github.com/microsoft/TypeScript/issues/57357
+
+import type { Data } from "./processor";
+
+export function getData() {
+  return constructData({}) satisfies []; // error
+}
+
+function constructData(data: Data) {
+  const { ...props } = data;
+  return {
+    ...props,
+  };
+}
+
+//// [type.ts]
+export type Value = {};
+
+//// [processor.ts]
+import { getData } from "./data";
+
+import type { Value } from "./type";
+
+export type Data = {
+  quantity: Value;
+};
+
+declare function createRequestProcessor<Req>(pipeline: () => Req): Req;
+
+export const processor = createRequestProcessor(getData);
+
+//// [main.ts]
+import { processor } from "./processor";
+export default processor;
+
+//// [workerinterface.ts]
+import type Server from "./main";
+
+export type _T = typeof Server;
+
+
+//// [type.js]
+export {};
+//// [processor.js]
+import { getData } from "./data";
+export const processor = createRequestProcessor(getData);
+//// [data.js]
+// https://github.com/microsoft/TypeScript/issues/57357
+export function getData() {
+    return constructData({}); // error
+}
+function constructData(data) {
+    const { ...props } = data;
+    return {
+        ...props,
+    };
+}
+//// [main.js]
+import { processor } from "./processor";
+export default processor;
+//// [workerinterface.js]
+export {};