Fix declaration emit to retain imports for unresolved type aliases

internal/checker/nodebuilderimpl.go

@@ -3111,5 +3111,16 @@ func (b *NodeBuilderImpl) newStringLiteralEx(text string, isSingleQuote bool) *a
 // Direct serialization core functions for types, type aliases, and symbols
 
 func (t *TypeAlias) ToTypeReferenceNode(b *NodeBuilderImpl) *ast.Node {
-	return b.f.NewTypeReferenceNode(b.symbolToEntityNameNode(t.Symbol()), b.mapToTypeNodes(t.TypeArguments(), false /*isBareList*/))
+	sym := t.Symbol()
+	// For unresolved symbols (e.g., from unresolved imports with --noResolve), try to find and track
+	// the local import binding by resolving the name without following the alias.
+	// This ensures the import is retained in declaration emit.
+	if sym.CheckFlags&ast.CheckFlagsUnresolved != 0 && b.ctx.enclosingDeclaration != nil {
+		localSym := b.ch.resolveName(b.ctx.enclosingDeclaration, sym.Name, ast.SymbolFlagsType|ast.SymbolFlagsAlias, nil, false, false)
+		if localSym != nil && localSym.Flags&ast.SymbolFlagsAlias != 0 {
+			// Track the local alias symbol (the import specifier) to mark it visible
+			b.ctx.tracker.TrackSymbol(localSym, b.ctx.enclosingDeclaration, ast.SymbolFlagsType)
+		}
+	}
+	return b.f.NewTypeReferenceNode(b.symbolToEntityNameNode(sym), b.mapToTypeNodes(t.TypeArguments(), false /*isBareList*/))
 }

testdata/baselines/reference/compiler/declarationEmitRetainsImportOfCastType.errors.txt

@@ -0,0 +1,12 @@
+declarationEmitRetainsImportOfCastType.ts(1,30): error TS2307: Cannot find module 'jotai' or its corresponding type declarations.
+
+
+==== declarationEmitRetainsImportOfCastType.ts (1 errors) ====
+    import { WritableAtom } from 'jotai'
+                                 ~~~~~~~
+!!! error TS2307: Cannot find module 'jotai' or its corresponding type declarations.
+
+    export function focusAtom() {
+      return null as unknown as WritableAtom<any, any, any>
+    }
+

testdata/baselines/reference/compiler/declarationEmitRetainsImportOfCastType.js

@@ -0,0 +1,22 @@
+//// [tests/cases/compiler/declarationEmitRetainsImportOfCastType.ts] ////
+
+//// [declarationEmitRetainsImportOfCastType.ts]
+import { WritableAtom } from 'jotai'
+
+export function focusAtom() {
+  return null as unknown as WritableAtom<any, any, any>
+}
+
+
+//// [declarationEmitRetainsImportOfCastType.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.focusAtom = focusAtom;
+function focusAtom() {
+    return null;
+}
+
+
+//// [declarationEmitRetainsImportOfCastType.d.ts]
+import { WritableAtom } from 'jotai';
+export declare function focusAtom(): WritableAtom<any, any, any>;

testdata/baselines/reference/compiler/declarationEmitRetainsImportOfCastType.symbols

@@ -0,0 +1,13 @@
+//// [tests/cases/compiler/declarationEmitRetainsImportOfCastType.ts] ////
+
+=== declarationEmitRetainsImportOfCastType.ts ===
+import { WritableAtom } from 'jotai'
+>WritableAtom : Symbol(WritableAtom, Decl(declarationEmitRetainsImportOfCastType.ts, 0, 8))
+
+export function focusAtom() {
+>focusAtom : Symbol(focusAtom, Decl(declarationEmitRetainsImportOfCastType.ts, 0, 36))
+
+  return null as unknown as WritableAtom<any, any, any>
+>WritableAtom : Symbol(WritableAtom, Decl(declarationEmitRetainsImportOfCastType.ts, 0, 8))
+}
+

testdata/baselines/reference/compiler/declarationEmitRetainsImportOfCastType.types

@@ -0,0 +1,14 @@
+//// [tests/cases/compiler/declarationEmitRetainsImportOfCastType.ts] ////
+
+=== declarationEmitRetainsImportOfCastType.ts ===
+import { WritableAtom } from 'jotai'
+>WritableAtom : any
+
+export function focusAtom() {
+>focusAtom : () => WritableAtom<any, any, any>
+
+  return null as unknown as WritableAtom<any, any, any>
+>null as unknown as WritableAtom<any, any, any> : WritableAtom<any, any, any>
+>null as unknown : unknown
+}
+

testdata/baselines/reference/submodule/compiler/isolatedDeclarationErrorTypes1.js

@@ -24,6 +24,7 @@ exports.foo3 = foo3;
 
 
 //// [isolatedDeclarationErrorTypes1.d.ts]
+import { Unresolved } from "foo";
 export declare const foo1: (type?: any) => void;
 export declare const foo2: (type?: any) => void;
 export declare const foo3: (type: Unresolved) => void;

testdata/baselines/reference/submodule/compiler/isolatedDeclarationErrorTypes1.js.diff

@@ -1,10 +1,9 @@
 --- old.isolatedDeclarationErrorTypes1.js
 +++ new.isolatedDeclarationErrorTypes1.js
-@@= skipped -23, +23 lines =@@
-
+@@= skipped -24, +24 lines =@@
 
  //// [isolatedDeclarationErrorTypes1.d.ts]
--import { Unresolved } from "foo";
+ import { Unresolved } from "foo";
 -export declare const foo1: (type?: Unresolved) => void;
 -export declare const foo2: (type?: Unresolved | undefined) => void;
 +export declare const foo1: (type?: any) => void;

testdata/tests/cases/compiler/declarationEmitRetainsImportOfCastType.ts

@@ -0,0 +1,8 @@
+// @declaration: true
+// @noResolve: true
+
+import { WritableAtom } from 'jotai'
+
+export function focusAtom() {
+  return null as unknown as WritableAtom<any, any, any>
+}