When caching type references cache the tracked symbols so they can be emitted in the d.ts file (#51721)

Author: sheetalkamat

src/compiler/checker.ts

@@ -1010,6 +1010,7 @@ import {
     tokenToString,
     tracing,
     TracingNode,
+    TrackedSymbol,
     TransientSymbol,
     TransientSymbolLinks,
     tryAddToSet,
@@ -6424,6 +6425,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 symbolDepth: undefined,
                 inferTypeParameters: undefined,
                 approximateLength: 0,
+                trackedSymbols: undefined,
             };
             context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
             const resultingNode = cb(context);
@@ -6922,6 +6924,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 }
                 const cachedResult = links?.serializedTypes?.get(key);
                 if (cachedResult) {
+                    // TODO:: check if we instead store late painted statements associated with this?
+                    cachedResult.trackedSymbols?.forEach(
+                        ([symbol, enclosingDeclaration, meaning]) =>
+                            context.tracker.trackSymbol(
+                                symbol,
+                                enclosingDeclaration,
+                                meaning,
+                            ),
+                    );
                     if (cachedResult.truncating) {
                         context.truncating = true;
                     }
@@ -6942,7 +6953,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const result = transform(type);
                 const addedLength = context.approximateLength - startLength;
                 if (!context.reportedDiagnostic && !context.encounteredError) {
-                    links?.serializedTypes?.set(key, { node: result, truncating: context.truncating, addedLength });
+                    links?.serializedTypes?.set(key, {
+                        node: result,
+                        truncating: context.truncating,
+                        addedLength,
+                        trackedSymbols: context.trackedSymbols,
+                    });
                 }
                 context.visitedTypes.delete(typeId);
                 if (id) {
@@ -8860,6 +8876,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     if (context.reportedDiagnostic) {
                         oldcontext.reportedDiagnostic = context.reportedDiagnostic; // hoist diagnostic result into outer context
                     }
+                    if (context.trackedSymbols) {
+                        if (!oldContext.trackedSymbols) oldContext.trackedSymbols = context.trackedSymbols;
+                        else Debug.assert(context.trackedSymbols === oldContext.trackedSymbols);
+                    }
                     context = oldContext;
                 }
             }
@@ -50378,6 +50398,7 @@ interface NodeBuilderContext {
     // State
     encounteredError: boolean;
     reportedDiagnostic: boolean;
+    trackedSymbols: TrackedSymbol[] | undefined;
     visitedTypes: Set<number> | undefined;
     symbolDepth: Map<string, number> | undefined;
     inferTypeParameters: TypeParameter[] | undefined;
@@ -50418,6 +50439,8 @@ class SymbolTrackerImpl implements SymbolTracker {
                 this.onDiagnosticReported();
                 return true;
             }
+            // Skip recording type parameters as they dont contribute to late painted statements
+            if (!(symbol.flags & SymbolFlags.TypeParameter)) (this.context.trackedSymbols ??= []).push([symbol, enclosingDeclaration, meaning]);
         }
         return false;
     }

src/compiler/types.ts

@@ -6031,11 +6031,14 @@ export interface NodeLinks {
     assertionExpressionType?: Type;     // Cached type of the expression of a type assertion
 }
 
+/** @internal */
+export type TrackedSymbol = [symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags];
 /** @internal */
 export interface SerializedTypeEntry {
     node: TypeNode;
     truncating?: boolean;
     addedLength: number;
+    trackedSymbols: readonly TrackedSymbol[] | undefined;
 }
 
 // dprint-ignore

src/testRunner/unittests/tsc/incremental.ts

@@ -908,4 +908,55 @@ console.log(a);`,
         }],
         baselinePrograms: true,
     });
+
+    verifyTsc({
+        scenario: "incremental",
+        subScenario: "generates typerefs correctly",
+        commandLineArgs: ["-p", `/src/project`],
+        fs: () =>
+            loadProjectFromFiles({
+                "/src/project/tsconfig.json": jsonToReadableText({
+                    compilerOptions: {
+                        composite: true,
+                        outDir: "outDir",
+                        checkJs: true,
+                    },
+                    include: ["src"],
+                }),
+                "/src/project/src/box.ts": Utils.dedent`
+                    export interface Box<T> {
+                        unbox(): T
+                    }
+                `,
+                "/src/project/src/bug.js": Utils.dedent`
+                    import * as B from "./box.js"
+                    import * as W from "./wrap.js"
+
+                    /**
+                     * @template {object} C
+                     * @param {C} source
+                     * @returns {W.Wrap<C>}
+                     */
+                    const wrap = source => {
+                    throw source
+                    }
+
+                    /**
+                     * @returns {B.Box<number>}
+                     */
+                    const box = (n = 0) => ({ unbox: () => n })
+
+                    export const bug = wrap({ n: box(1) });
+                `,
+                "/src/project/src/wrap.ts": Utils.dedent`
+                    export type Wrap<C> = {
+                        [K in keyof C]: { wrapped: C[K] }
+                    }
+                `,
+            }),
+        edits: [{
+            caption: "modify js file",
+            edit: fs => appendText(fs, "/src/project/src/bug.js", `export const something = 1;`),
+        }],
+    });
 });