typescript 7.1.0-dev.20260923.1 → 7.1.0-dev.20260925.1

package/dist/api/sync/api.js

@@ -21,7 +21,7 @@ import { TypePredicateKind } from "#enums/typePredicateKind";
 import { ModifierFlags, unescapeLeadingUnderscores, } from "../../ast/index.js";
 import { assertNever } from "../../internal/utils.js";
 import { encodeNode, uint8ArrayToBase64, } from "../node/encoder.js";
-import { decodeNode, getNodeId, parseNodeHandle, readParseOptionsKey, readSourceFileHash, RemoteSourceFile, } from "../node/node.js";
+import { decodeNode, getNodeId, parseNodeHandle, readParseOptionsKey, readSourceFileHash, readSourceFileLease, RemoteSourceFile, } from "../node/node.js";
 import { Wtf8Decoder } from "../node/wtf8.js";
 import { createGetCanonicalFileName, toPath, } from "../path.js";
 import { resolveFileName, toCreateSnapshotRequest, } from "../proto.js";
@@ -30,6 +30,22 @@ import { Client, } from "./client.js";
 export { formatDiagnostics, formatDiagnosticsWithColorAndContext } from "../diagnosticFormatter.js";
 export { documentURIToFileName, fileNameToDocumentURI } from "../path.js";
 export { CheckFlags, CompletionItemKind, DiagnosticCategory, ElementFlags, EmitOnly, IndexKind, JsxEmit, ModifierFlags, ModuleKind, ModuleResolutionKind, NodeBuilderFlags, ObjectFlags, ScriptKind, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypeFormatFlags, TypePredicateKind };
+let nextModuleResolutionCallbackId = 0;
+function registerModuleResolutionCallback(client, callback, getSnapshot) {
+    const name = `resolveModuleName/${++nextModuleResolutionCallbackId}`;
+    const dispose = client.registerCallback(name, params => {
+        const { moduleName, containingDirectory, resolutionMode, snapshot: snapshotId, inProgressSnapshot } = params;
+        let snapshot = snapshotId === undefined ? undefined : getSnapshot(snapshotId);
+        if (snapshotId !== undefined && snapshot === undefined) {
+            throw new Error(`Snapshot ${snapshotId} is inactive`);
+        }
+        if (inProgressSnapshot !== undefined) {
+            snapshot = -inProgressSnapshot;
+        }
+        return callback(moduleName, containingDirectory, resolutionMode, { snapshot });
+    });
+    return { name, dispose };
+}
 export { all, defer } from "./generatorSupport.js";
 import { sourceFileResponseToUint8Array } from "../node/encoder.js";
 import { executeRequestGenerators, } from "./generatorSupport.js";
@@ -42,7 +58,8 @@ export class API {
     getCanonicalFileNameWorker;
     initialized = false;
     initializing;
-    activeSnapshots = new Set();
+    activeSnapshots = new Map();
+    activeSourceFileLeases = new Map();
     printer;
     internal;
     constructor(options = {}) {
@@ -169,6 +186,10 @@ export class API {
             return yield* apiRequest("parseJsonConfigFileContent", { json, ...options });
         });
     }
+    /**
+     * Create and retain a source file independently of a program.
+     * Dispose the returned lease when the source file no longer needs to remain available remotely.
+     */
     get createSourceFile() {
         const owner = this;
         return cacheGeneratorMethod(owner, "createSourceFile", function (fileName, sourceText, options = {}) {
@@ -177,16 +198,20 @@ export class API {
             if (!data) {
                 throw new Error("createSourceFile returned no source file");
             }
-            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+            return owner.retainSourceFileResponse(data);
         }, function* (fileName, sourceText, options = {}) {
             yield* owner.ensureInitialized.gen();
             const data = sourceFileResponseToUint8Array(yield* apiRequest("createSourceFile", { fileName, sourceText, options }));
             if (!data) {
                 throw new Error("createSourceFile returned no source file");
             }
-            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+            return owner.retainSourceFileResponse(data);
         });
     }
+    /**
+     * Read, create, and retain a source file independently of a program.
+     * Dispose the returned lease when the source file no longer needs to remain available remotely.
+     */
     get createSourceFileFromFile() {
         const owner = this;
         return cacheGeneratorMethod(owner, "createSourceFileFromFile", function (file, options = {}) {
@@ -195,16 +220,37 @@ export class API {
             if (!data) {
                 throw new Error("createSourceFileFromFile returned no source file");
             }
-            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+            return owner.retainSourceFileResponse(data);
         }, function* (file, options = {}) {
             yield* owner.ensureInitialized.gen();
             const data = sourceFileResponseToUint8Array(yield* apiRequest("createSourceFileFromFile", { fileName: resolveFileName(file), options }));
             if (!data) {
                 throw new Error("createSourceFileFromFile returned no source file");
             }
-            return new RemoteSourceFile(data, owner.decoder, owner.client.getTimingCollector());
+            return owner.retainSourceFileResponse(data);
         });
     }
+    retainSourceFileResponse(data) {
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const lease = readSourceFileLease(view);
+        try {
+            const decoded = new RemoteSourceFile(data, this.decoder, this.client.getTimingCollector());
+            const sourceFile = this.sourceFileCache.setForLease(decoded.path, decoded, readParseOptionsKey(view), readSourceFileHash(view), lease);
+            const retained = new RetainedSourceFile(sourceFile, lease, this.client, () => {
+                this.activeSourceFileLeases.delete(lease);
+                this.sourceFileCache.releaseLease(lease);
+            });
+            this.activeSourceFileLeases.set(lease, retained);
+            return retained;
+        }
+        catch (error) {
+            try {
+                this.client.apiRequest("releaseSourceFile", { lease });
+            }
+            catch { }
+            throw error;
+        }
+    }
     get transpileModule() {
         const owner = this;
         return cacheGeneratorMethod(owner, "transpileModule", function (input, options = {}) {
@@ -249,24 +295,24 @@ export class API {
         const owner = this;
         function createSnapshot(params) {
             owner.ensureInitialized();
-            const requestParams = toCreateSnapshotRequest(params);
+            const requestParams = toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params));
             const data = owner.client.apiRequest("createSnapshot", requestParams);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), undefined);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         function* gen(params) {
             yield* owner.ensureInitialized.gen();
-            const requestParams = toCreateSnapshotRequest(params);
+            const requestParams = toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params));
             const data = yield* apiRequest("createSnapshot", requestParams);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), undefined);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         return cacheGeneratorMethod(owner, "createSnapshot", createSnapshot, gen);
@@ -275,12 +321,12 @@ export class API {
         const owner = this;
         return cacheGeneratorMethod(owner, "updateSnapshot", function (baseSnapshot, params) {
             owner.ensureInitialized();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot update an inactive snapshot");
             }
             const data = owner.client.apiRequest("updateSnapshot", {
                 snapshot: baseSnapshot.id,
-                changes: toCreateSnapshotRequest(params),
+                changes: toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params)),
             });
             if (data.snapshot === baseSnapshot.id) {
                 owner.client.apiRequest("release", { snapshot: data.snapshot });
@@ -288,19 +334,19 @@ export class API {
             }
             owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }, function* (baseSnapshot, params) {
             yield* owner.ensureInitialized.gen();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot update an inactive snapshot");
             }
             const data = yield* apiRequest("updateSnapshot", {
                 snapshot: baseSnapshot.id,
-                changes: toCreateSnapshotRequest(params),
+                changes: toCreateSnapshotRequest(owner.prepareCreateSnapshotParams(params)),
             });
             if (data.snapshot === baseSnapshot.id) {
                 yield* apiRequest("release", { snapshot: data.snapshot });
@@ -308,13 +354,38 @@ export class API {
             }
             owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         });
     }
+    prepareCreateSnapshotParams(params) {
+        if (!params)
+            return undefined;
+        const prepareOptions = (options) => {
+            if (!options)
+                return undefined;
+            const { moduleResolver, ...rest } = options;
+            moduleResolver?.ensureNotDisposed();
+            return {
+                ...rest,
+                moduleResolver: moduleResolver?.id,
+            };
+        };
+        return {
+            ...params,
+            createPrograms: params.createPrograms?.map(program => ({ ...program, options: prepareOptions(program.options) })),
+            reconfigurePrograms: params.reconfigurePrograms?.map(program => ({ ...program, options: prepareOptions(program.options) })),
+        };
+    }
+    prepareLanguageServerSnapshotChanges(changes) {
+        if (!changes)
+            return undefined;
+        const prepared = this.prepareCreateSnapshotParams(changes);
+        return prepared;
+    }
     createSnapshotUpdater(getSnapshot) {
         const update = ((params) => this.updateSnapshot(getSnapshot(), params));
         const owner = this;
@@ -333,42 +404,42 @@ export class API {
             owner.ensureInitialized();
             const changes = args[0];
             const baseSnapshot = args[1];
-            if (baseSnapshot && (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+            if (baseSnapshot && (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed())) {
                 throw new Error("Cannot use an inactive snapshot as a response base");
             }
             const data = owner.client.apiRequest("getCurrentLanguageServerSnapshot", {
                 baseSnapshot: baseSnapshot?.id,
-                changes,
+                changes: owner.prepareLanguageServerSnapshotChanges(changes),
             });
             if (baseSnapshot) {
                 owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             }
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         function* gen(...args) {
             yield* owner.ensureInitialized.gen();
             const changes = args[0];
             const baseSnapshot = args[1];
-            if (baseSnapshot && (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed())) {
+            if (baseSnapshot && (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed())) {
                 throw new Error("Cannot use an inactive snapshot as a response base");
             }
             const data = yield* apiRequest("getCurrentLanguageServerSnapshot", {
                 baseSnapshot: baseSnapshot?.id,
-                changes,
+                changes: owner.prepareLanguageServerSnapshotChanges(changes),
             });
             if (baseSnapshot) {
                 owner.sourceFileCache.retainForSnapshot(data.snapshot, baseSnapshot.id, data.changes);
             }
             const snapshot = new Snapshot(data, owner.client, owner.sourceFileCache, owner.toPath, owner, () => {
-                owner.activeSnapshots.delete(snapshot);
+                owner.activeSnapshots.delete(snapshot.id);
                 owner.sourceFileCache.releaseSnapshot(snapshot.id);
             }, owner.createSnapshotUpdater(() => snapshot), baseSnapshot);
-            owner.activeSnapshots.add(snapshot);
+            owner.activeSnapshots.set(snapshot.id, snapshot);
             return snapshot;
         }
         return cacheGeneratorMethod(owner, "getCurrentLanguageServerSnapshot", getCurrentLanguageServerSnapshot, gen);
@@ -379,26 +450,76 @@ export class API {
     get close() {
         const owner = this;
         return cacheGeneratorMethod(owner, "close", function () {
-            // Dispose all active snapshots
             try {
-                for (const snapshot of [...owner.activeSnapshots]) {
-                    snapshot.dispose();
+                for (const retained of [...owner.activeSourceFileLeases.values()]) {
+                    retained.dispose();
                 }
-                owner.sourceFileCache.clear();
             }
             finally {
-                owner.client.close(); // always close the underlying connection
+                try {
+                    for (const snapshot of [...owner.activeSnapshots.values()]) {
+                        snapshot.dispose();
+                    }
+                    owner.sourceFileCache.clear();
+                }
+                finally {
+                    owner.client.close(); // always close the underlying connection
+                }
             }
         }, function* () {
-            // Dispose all active snapshots
             try {
-                for (const snapshot of [...owner.activeSnapshots]) {
-                    yield* snapshot.dispose.gen();
+                for (const retained of [...owner.activeSourceFileLeases.values()]) {
+                    yield* retained.dispose.gen();
                 }
-                owner.sourceFileCache.clear();
             }
             finally {
-                owner.client.close(); // always close the underlying connection
+                try {
+                    for (const snapshot of [...owner.activeSnapshots.values()]) {
+                        yield* snapshot.dispose.gen();
+                    }
+                    owner.sourceFileCache.clear();
+                }
+                finally {
+                    owner.client.close(); // always close the underlying connection
+                }
+            }
+        });
+    }
+    get createModuleResolver() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "createModuleResolver", function (compilerOptions, options) {
+            owner.ensureInitialized();
+            const callback = options?.resolveModuleName
+                ? registerModuleResolutionCallback(owner.client, options.resolveModuleName, id => owner.activeSnapshots.get(id))
+                : undefined;
+            try {
+                const id = owner.client.apiRequest("createModuleResolver", {
+                    compilerOptions,
+                    moduleResolutions: options?.moduleResolutions,
+                    resolveModuleNameCallback: callback?.name,
+                });
+                return new ModuleResolver(id, owner.client, callback?.dispose);
+            }
+            catch (error) {
+                callback?.dispose();
+                throw error;
+            }
+        }, function* (compilerOptions, options) {
+            yield* owner.ensureInitialized.gen();
+            const callback = options?.resolveModuleName
+                ? registerModuleResolutionCallback(owner.client, options.resolveModuleName, id => owner.activeSnapshots.get(id))
+                : undefined;
+            try {
+                const id = yield* apiRequest("createModuleResolver", {
+                    compilerOptions,
+                    moduleResolutions: options?.moduleResolutions,
+                    resolveModuleNameCallback: callback?.name,
+                });
+                return new ModuleResolver(id, owner.client, callback?.dispose);
+            }
+            catch (error) {
+                callback?.dispose();
+                throw error;
             }
         });
     }
@@ -409,7 +530,7 @@ export class API {
         const owner = this;
         return cacheGeneratorMethod(owner, "runWithTemporaryFileUpdate", function (baseSnapshot, file, newText, cb) {
             owner.ensureInitialized();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot run a temporary file update on an inactive snapshot");
             }
             const snapshot = baseSnapshot.update({
@@ -427,7 +548,7 @@ export class API {
             }
         }, function* (baseSnapshot, file, newText, cb) {
             yield* owner.ensureInitialized.gen();
-            if (!owner.activeSnapshots.has(baseSnapshot) || baseSnapshot.isDisposed()) {
+            if (owner.activeSnapshots.get(baseSnapshot.id) !== baseSnapshot || baseSnapshot.isDisposed()) {
                 throw new Error("Cannot run a temporary file update on an inactive snapshot");
             }
             const snapshot = yield* baseSnapshot.update.gen({
@@ -503,6 +624,56 @@ export class API {
         });
     }
 }
+/** An independently retained source file and its disposable remote-lifetime lease. */
+export class RetainedSourceFile {
+    sourceFile;
+    lease;
+    client;
+    onDispose;
+    disposed = false;
+    disposePromise;
+    constructor(sourceFile, lease, client, onDispose) {
+        this.sourceFile = sourceFile;
+        this.lease = lease;
+        this.client = client;
+        this.onDispose = onDispose;
+    }
+    [globalThis.Symbol.dispose]() {
+        this.dispose();
+    }
+    get dispose() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "dispose", function () {
+            return owner.disposePromise ??= owner.disposeWorker();
+        }, function* () {
+            return owner.disposePromise ??= yield* owner.disposeWorker.gen();
+        });
+    }
+    get disposeWorker() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "disposeWorker", function () {
+            if (owner.disposed)
+                return;
+            owner.disposed = true;
+            try {
+                owner.client.apiRequest("releaseSourceFile", { lease: owner.lease });
+            }
+            finally {
+                owner.onDispose();
+            }
+        }, function* () {
+            if (owner.disposed)
+                return;
+            owner.disposed = true;
+            try {
+                yield* apiRequest("releaseSourceFile", { lease: owner.lease });
+            }
+            finally {
+                owner.onDispose();
+            }
+        });
+    }
+}
 export class InternalAPI {
     client;
     ensureInitialized;
@@ -701,6 +872,71 @@ export class Snapshot {
         return project;
     }
 }
+export class ModuleResolver {
+    id;
+    client;
+    disposeCallback;
+    disposed = false;
+    constructor(id, client, disposeCallback) {
+        this.id = id;
+        this.client = client;
+        this.disposeCallback = disposeCallback;
+    }
+    get resolveModuleName() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "resolveModuleName", function (moduleName, containingDirectory, resolutionMode, options) {
+            owner.ensureNotDisposed();
+            if (options?.snapshot instanceof Snapshot && options.snapshot.isDisposed()) {
+                throw new Error("Snapshot is disposed");
+            }
+            return owner.client.apiRequest("resolveModuleName", {
+                snapshot: options?.snapshot instanceof Snapshot ? options.snapshot.id : undefined,
+                inProgressSnapshot: typeof options?.snapshot === "number" ? -options.snapshot : undefined,
+                resolver: owner.id,
+                moduleName,
+                containingDirectory,
+                resolutionMode,
+            });
+        }, function* (moduleName, containingDirectory, resolutionMode, options) {
+            owner.ensureNotDisposed();
+            if (options?.snapshot instanceof Snapshot && options.snapshot.isDisposed()) {
+                throw new Error("Snapshot is disposed");
+            }
+            return yield* apiRequest("resolveModuleName", {
+                snapshot: options?.snapshot instanceof Snapshot ? options.snapshot.id : undefined,
+                inProgressSnapshot: typeof options?.snapshot === "number" ? -options.snapshot : undefined,
+                resolver: owner.id,
+                moduleName,
+                containingDirectory,
+                resolutionMode,
+            });
+        });
+    }
+    [globalThis.Symbol.dispose]() {
+        return this.dispose();
+    }
+    get dispose() {
+        const owner = this;
+        return cacheGeneratorMethod(owner, "dispose", function () {
+            if (owner.disposed)
+                return;
+            owner.client.apiRequest("releaseModuleResolver", { resolver: owner.id });
+            owner.disposed = true;
+            owner.disposeCallback?.();
+        }, function* () {
+            if (owner.disposed)
+                return;
+            yield* apiRequest("releaseModuleResolver", { resolver: owner.id });
+            owner.disposed = true;
+            owner.disposeCallback?.();
+        });
+    }
+    /** @internal */
+    ensureNotDisposed() {
+        if (this.disposed)
+            throw new Error("ModuleResolver is disposed");
+    }
+}
 class SnapshotObjectRegistry {
     symbols = new Map();
     client;
@@ -3196,21 +3432,9 @@ export class Checker {
     get getIndexTypeOfType() {
         const owner = this;
         return cacheGeneratorMethod(owner, "getIndexTypeOfType", function (type, kind) {
-            const data = owner.client.apiRequest("getIndexTypeOfTypeByKind", {
-                snapshot: owner.snapshotId,
-                project: owner.project.id,
-                type: type.id,
-                kind,
-            });
-            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+            return kind === IndexKind.String ? type.getStringIndexType() : type.getNumberIndexType();
         }, function* (type, kind) {
-            const data = yield* apiRequest("getIndexTypeOfTypeByKind", {
-                snapshot: owner.snapshotId,
-                project: owner.project.id,
-                type: type.id,
-                kind,
-            });
-            return data ? owner.objectRegistry.getOrCreateType(data) : undefined;
+            return kind === IndexKind.String ? (yield* type.getStringIndexType.gen()) : (yield* type.getNumberIndexType.gen());
         });
     }
     get getTypeOfPropertyOfType() {
@@ -3973,6 +4197,7 @@ class TypeObject {
     constructSignatures;
     indexInfos;
     baseTypes;
+    types;
     stringIndexType;
     numberIndexType;
     constructor(data, objectRegistry) {
@@ -4069,6 +4294,7 @@ class TypeObject {
         this.constructSignatures = false;
         this.indexInfos = false;
         this.baseTypes = false;
+        this.types = false;
         this.stringIndexType = false;
         this.numberIndexType = false;
     }
@@ -4283,7 +4509,10 @@ class TypeObject {
             if (!(owner.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
                 return undefined;
             }
-            return owner.objectRegistry.fetchTypes(owner, "getTypesOfType");
+            if (owner.types === false) {
+                owner.types = owner.objectRegistry.fetchTypes(owner, "getTypesOfType");
+            }
+            return owner.types;
         }, function* () {
             // Only union, intersection, and template literal types have constituent
             // types; any other kind has none, so return undefined rather than sending
@@ -4291,7 +4520,10 @@ class TypeObject {
             if (!(owner.flags & (TypeFlags.UnionOrIntersection | TypeFlags.TemplateLiteral))) {
                 return undefined;
             }
-            return yield* owner.objectRegistry.fetchTypes.gen(owner, "getTypesOfType");
+            if (owner.types === false) {
+                owner.types = yield* owner.objectRegistry.fetchTypes.gen(owner, "getTypesOfType");
+            }
+            return owner.types;
         });
     }
     get getTypeParameters() {