Fix reference marking of values merged with unresolvable type-only imports (#54799)

Author: andrewbranch

src/compiler/checker.ts

@@ -3814,8 +3814,8 @@ export type TypeOnlyImportDeclaration =
 
 export type TypeOnlyExportDeclaration =
     | ExportSpecifier & ({ readonly isTypeOnly: true } | { readonly parent: NamedExports & { readonly parent: ExportDeclaration & { readonly isTypeOnly: true } } })
-    | ExportDeclaration & { readonly isTypeOnly: true } // export * from "mod"
-    | NamespaceExport & { readonly parent: ExportDeclaration & { readonly isTypeOnly: true } } // export * as ns from "mod"
+    | ExportDeclaration & { readonly isTypeOnly: true, readonly moduleSpecifier: Expression } // export * from "mod"
+    | NamespaceExport & { readonly parent: ExportDeclaration & { readonly isTypeOnly: true, readonly moduleSpecifier: Expression } } // export * as ns from "mod"
     ;
 
 export type TypeOnlyAliasDeclaration = TypeOnlyImportDeclaration | TypeOnlyExportDeclaration;
@@ -5878,7 +5878,7 @@ export interface SymbolLinks {
     deferralParent?: Type;                      // Source union/intersection of a deferred type
     cjsExportMerged?: Symbol;                   // Version of the symbol with all non export= exports merged with the export= target
     typeOnlyDeclaration?: TypeOnlyAliasDeclaration | false; // First resolved alias declaration that makes the symbol only usable in type constructs
-    typeOnlyExportStarMap?: Map<__String, ExportDeclaration & { readonly isTypeOnly: true }>; // Set on a module symbol when some of its exports were resolved through a 'export type * from "mod"' declaration
+    typeOnlyExportStarMap?: Map<__String, ExportDeclaration & { readonly isTypeOnly: true, readonly moduleSpecifier: Expression }>; // Set on a module symbol when some of its exports were resolved through a 'export type * from "mod"' declaration
     typeOnlyExportStarName?: __String;          // Set to the name of the symbol re-exported by an 'export type *' declaration, when different from the symbol name
     isConstructorDeclaredProperty?: boolean;    // Property declared through 'this.x = ...' assignment in constructor
     tupleLabelDeclaration?: NamedTupleMember | ParameterDeclaration; // Declaration associated with the tuple's label

src/compiler/types.ts

@@ -620,4 +620,16 @@ export * as alias from './file';`, {
             testVerbatimModuleSyntax: true
         }
     );
+
+    transpilesCorrectly("Preserves exported const merged with type-only import", `
+        import fooValue from "./values";
+        import type {Foo} from "./types";
+
+        const Foo: Foo = fooValue as any as Foo;
+
+        export {Foo};
+    `, {
+        options: { compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ESNext } },
+        testVerbatimModuleSyntax: true
+    });
 });

src/testRunner/unittests/services/transpile.ts

@@ -5832,9 +5832,11 @@ declare namespace ts {
         };
     }) | ExportDeclaration & {
         readonly isTypeOnly: true;
+        readonly moduleSpecifier: Expression;
     } | NamespaceExport & {
         readonly parent: ExportDeclaration & {
             readonly isTypeOnly: true;
+            readonly moduleSpecifier: Expression;
         };
     };
     type TypeOnlyAliasDeclaration = TypeOnlyImportDeclaration | TypeOnlyExportDeclaration;

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -1774,9 +1774,11 @@ declare namespace ts {
         };
     }) | ExportDeclaration & {
         readonly isTypeOnly: true;
+        readonly moduleSpecifier: Expression;
     } | NamespaceExport & {
         readonly parent: ExportDeclaration & {
             readonly isTypeOnly: true;
+            readonly moduleSpecifier: Expression;
         };
     };
     type TypeOnlyAliasDeclaration = TypeOnlyImportDeclaration | TypeOnlyExportDeclaration;

tests/baselines/reference/api/typescript.d.ts

@@ -5,6 +5,7 @@ import MyFunction from "./MyComponent";
 >MyFunction : Symbol(MyFunction, Decl(main.ts, 0, 6))
 
 MyFunction({msg: "Hello World"});
+>MyFunction : Symbol(MyFunction, Decl(main.ts, 0, 6))
 >msg : Symbol(msg, Decl(main.ts, 2, 12))
 
 

tests/baselines/reference/importElisionExportNonExportAndDefault.symbols

@@ -33,7 +33,9 @@ exports.A = A;
 //// [b.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.x = void 0;
+exports.x = exports.A = void 0;
+var A = a.A; // Error
+exports.A = A;
 var x = 0;
 exports.x = x;
 //// [c.js]

tests/baselines/reference/importEquals3.js

@@ -0,0 +1,43 @@
+//// [tests/cases/conformance/externalModules/typeOnly/namespaceImportTypeQuery2.ts] ////
+
+//// [z.ts]
+interface A {}
+export type { A };
+
+//// [a.ts]
+import { A } from './z';
+const A = 0;
+export { A };
+export class B {};
+
+//// [b.ts]
+import * as types from './a';
+let t: typeof types = {
+  A: undefined as any, // ok
+  B: undefined as any,
+}
+
+
+//// [z.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//// [a.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.B = exports.A = void 0;
+var A = 0;
+exports.A = A;
+var B = /** @class */ (function () {
+    function B() {
+    }
+    return B;
+}());
+exports.B = B;
+;
+//// [b.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var t = {
+    A: undefined,
+    B: undefined,
+};

tests/baselines/reference/namespaceImportTypeQuery2.js

@@ -0,0 +1,39 @@
+//// [tests/cases/conformance/externalModules/typeOnly/namespaceImportTypeQuery2.ts] ////
+
+=== /z.ts ===
+interface A {}
+>A : Symbol(A, Decl(z.ts, 0, 0))
+
+export type { A };
+>A : Symbol(A, Decl(z.ts, 1, 13))
+
+=== /a.ts ===
+import { A } from './z';
+>A : Symbol(A, Decl(a.ts, 0, 8), Decl(a.ts, 1, 5))
+
+const A = 0;
+>A : Symbol(A, Decl(a.ts, 0, 8), Decl(a.ts, 1, 5))
+
+export { A };
+>A : Symbol(A, Decl(a.ts, 2, 8))
+
+export class B {};
+>B : Symbol(B, Decl(a.ts, 2, 13))
+
+=== /b.ts ===
+import * as types from './a';
+>types : Symbol(types, Decl(b.ts, 0, 6))
+
+let t: typeof types = {
+>t : Symbol(t, Decl(b.ts, 1, 3))
+>types : Symbol(types, Decl(b.ts, 0, 6))
+
+  A: undefined as any, // ok
+>A : Symbol(A, Decl(b.ts, 1, 23))
+>undefined : Symbol(undefined)
+
+  B: undefined as any,
+>B : Symbol(B, Decl(b.ts, 2, 22))
+>undefined : Symbol(undefined)
+}
+

tests/baselines/reference/namespaceImportTypeQuery2.symbols

@@ -0,0 +1,41 @@
+//// [tests/cases/conformance/externalModules/typeOnly/namespaceImportTypeQuery2.ts] ////
+
+=== /z.ts ===
+interface A {}
+export type { A };
+>A : A
+
+=== /a.ts ===
+import { A } from './z';
+>A : 0
+
+const A = 0;
+>A : 0
+>0 : 0
+
+export { A };
+>A : 0
+
+export class B {};
+>B : B
+
+=== /b.ts ===
+import * as types from './a';
+>types : typeof types
+
+let t: typeof types = {
+>t : typeof types
+>types : typeof types
+>{  A: undefined as any, // ok  B: undefined as any,} : { A: any; B: any; }
+
+  A: undefined as any, // ok
+>A : any
+>undefined as any : any
+>undefined : undefined
+
+  B: undefined as any,
+>B : any
+>undefined as any : any
+>undefined : undefined
+}
+