@typescript/native-preview 7.0.0-dev.20260623.1 → 7.0.0-dev.20260626.1

package/dist/api/async/api.js

@@ -12,9 +12,8 @@ import { TypePredicateKind } from "#enums/typePredicateKind";
 import { ModifierFlags, } from "../../ast/index.js";
 import { encodeNode, uint8ArrayToBase64, } from "../node/encoder.js";
 import { decodeNode, getNodeId, parseNodeHandle, readParseOptionsKey, readSourceFileHash, RemoteSourceFile, } from "../node/node.js";
-import { ObjectRegistry, } from "../objectRegistry.js";
 import { createGetCanonicalFileName, toPath, } from "../path.js";
-import { resolveFileName } from "../proto.js";
+import { resolveFileName, toUpdateSnapshotRequest, } from "../proto.js";
 import { SourceFileCache } from "../sourceFileCache.js";
 import { Client, } from "./client.js";
 export { CompletionItemKind, DiagnosticCategory, ElementFlags, ModifierFlags, NodeBuilderFlags, ObjectFlags, SignatureFlags, SignatureKind, SymbolFlags, TypeFlags, TypePredicateKind };
@@ -56,10 +55,7 @@ export class API {
     }
     async updateSnapshot(params) {
         await this.ensureInitialized();
-        const requestParams = params ?? {};
-        if (requestParams.openProject) {
-            requestParams.openProject = resolveFileName(requestParams.openProject);
-        }
+        const requestParams = toUpdateSnapshotRequest(params);
         const data = await this.client.apiRequest("updateSnapshot", requestParams);
         // Retain cached source files from previous snapshot for unchanged files
         if (this.latestSnapshot) {
@@ -123,23 +119,18 @@ export class Snapshot {
     projectMap;
     toPath;
     client;
-    objectRegistry;
     disposed = false;
     onDispose;
+    snapshotRegistry;
     constructor(data, client, sourceFileCache, toPath, onDispose) {
         this.id = data.snapshot;
         this.client = client;
         this.toPath = toPath;
         this.onDispose = onDispose;
-        this.objectRegistry = new SnapshotObjectRegistry({
-            createSymbol: symbolData => new Symbol(symbolData, this.objectRegistry),
-            createType: typeData => new TypeObject(typeData, this.objectRegistry),
-            createSignature: sigData => new Signature(sigData, this.objectRegistry),
-        }, client, this.id);
-        // Create projects
+        this.snapshotRegistry = new SnapshotObjectRegistry(client, this.id);
         this.projectMap = new Map();
         for (const projData of data.projects) {
-            const project = new Project(projData, this.id, client, this.objectRegistry, sourceFileCache, toPath);
+            const project = new Project(projData, this.id, client, sourceFileCache, toPath, this.snapshotRegistry);
             this.projectMap.set(toPath(projData.configFileName), project);
         }
     }
@@ -168,7 +159,11 @@ export class Snapshot {
         if (this.disposed)
             return;
         this.disposed = true;
-        this.objectRegistry.clear();
+        for (const project of this.projectMap.values()) {
+            project.dispose();
+        }
+        this.projectMap.clear();
+        this.snapshotRegistry.clear();
         this.onDispose();
         await this.client.apiRequest("release", { snapshot: this.id });
     }
@@ -181,41 +176,131 @@ export class Snapshot {
         }
     }
 }
-class SnapshotObjectRegistry extends ObjectRegistry {
+class SnapshotObjectRegistry {
+    symbols = new Map();
     client;
     snapshotId;
-    constructor(factories, client, snapshotId) {
-        super(factories);
+    constructor(client, snapshotId) {
         this.client = client;
         this.snapshotId = snapshotId;
     }
-    async fetchType(source, method, handle) {
+    getOrCreateSymbol(data) {
+        let symbol = this.symbols.get(data.id);
+        if (!symbol) {
+            symbol = new Symbol(data, this);
+            this.symbols.set(data.id, symbol);
+        }
+        return symbol;
+    }
+    getSymbol(id) {
+        return this.symbols.get(id);
+    }
+    clear() {
+        this.symbols.clear();
+    }
+    async fetchSymbol(source, method, handle, projectId) {
         if (!handle)
             return undefined;
-        const cached = this.getType(handle);
+        const cached = this.getSymbol(handle);
         if (cached)
             return cached;
         const data = await this.client.apiRequest(method, {
             snapshot: this.snapshotId,
+            project: projectId,
             objectId: source.id,
         });
         if (!data)
-            throw new Error(`${method} returned null type for ${source.constructor.name} ${source.id}`);
-        return this.getOrCreateType(data);
+            throw new Error(`${method} returned null symbol for ${source.constructor.name} ${source.id}`);
+        return this.getOrCreateSymbol(data);
     }
-    async fetchSymbol(source, method, handle) {
+    async fetchSymbols(source, method, handles, projectId) {
+        if (handles) {
+            const result = new Array(handles.length);
+            let allCached = true;
+            for (let i = 0; i < handles.length; i++) {
+                const cached = this.getSymbol(handles[i]);
+                if (!cached) {
+                    allCached = false;
+                    break;
+                }
+                result[i] = cached;
+            }
+            if (allCached)
+                return result;
+        }
+        const symbolData = await this.client.apiRequest(method, {
+            snapshot: this.snapshotId,
+            project: projectId,
+            objectId: source.id,
+        });
+        if (symbolData == null)
+            return [];
+        else
+            return symbolData.map(data => this.getOrCreateSymbol(data));
+    }
+}
+class ProjectObjectRegistry {
+    client;
+    snapshotId;
+    projectId;
+    snapshotRegistry;
+    types = new Map();
+    signatures = new Map();
+    constructor(client, snapshotId, projectId, snapshotRegistry) {
+        this.client = client;
+        this.snapshotId = snapshotId;
+        this.projectId = projectId;
+        this.snapshotRegistry = snapshotRegistry;
+    }
+    getOrCreateSymbol(data) {
+        return this.snapshotRegistry.getOrCreateSymbol(data);
+    }
+    getSymbol(id) {
+        return this.snapshotRegistry.getSymbol(id);
+    }
+    getOrCreateType(data) {
+        let type = this.types.get(data.id);
+        if (!type) {
+            type = new TypeObject(data, this);
+            this.types.set(data.id, type);
+        }
+        return type;
+    }
+    getType(id) {
+        return this.types.get(id);
+    }
+    getOrCreateSignature(data) {
+        let sig = this.signatures.get(data.id);
+        if (!sig) {
+            sig = new Signature(data, this);
+            this.signatures.set(data.id, sig);
+        }
+        return sig;
+    }
+    getSignature(id) {
+        return this.signatures.get(id);
+    }
+    clear() {
+        this.types.clear();
+        this.signatures.clear();
+    }
+    async fetchType(source, method, handle) {
         if (!handle)
             return undefined;
-        const cached = this.getSymbol(handle);
+        const cached = this.getType(handle);
         if (cached)
             return cached;
         const data = await this.client.apiRequest(method, {
             snapshot: this.snapshotId,
+            project: this.projectId,
             objectId: source.id,
         });
         if (!data)
-            throw new Error(`${method} returned null symbol for ${source.constructor.name} ${source.id}`);
-        return this.getOrCreateSymbol(data);
+            throw new Error(`${method} returned null type for ${source.constructor.name} ${source.id}`);
+        return this.getOrCreateType(data);
+    }
+    async fetchSymbol(source, method, handle) {
+        return this.snapshotRegistry.fetchSymbol(source, method, handle, this.projectId);
     }
     async fetchSignature(source, method, handle) {
         if (!handle)
@@ -225,6 +310,7 @@ class SnapshotObjectRegistry extends ObjectRegistry {
             return cached;
         const data = await this.client.apiRequest(method, {
             snapshot: this.snapshotId,
+            project: this.projectId,
             objectId: source.id,
         });
         if (!data)
@@ -248,6 +334,7 @@ class SnapshotObjectRegistry extends ObjectRegistry {
         }
         const typesData = await this.client.apiRequest(method, {
             snapshot: this.snapshotId,
+            project: this.projectId,
             objectId: source.id,
         });
         if (typesData == null)
@@ -256,28 +343,7 @@ class SnapshotObjectRegistry extends ObjectRegistry {
             return typesData.map(data => this.getOrCreateType(data));
     }
     async fetchSymbols(source, method, handles) {
-        if (handles) {
-            const result = new Array(handles.length);
-            let allCached = true;
-            for (let i = 0; i < handles.length; i++) {
-                const cached = this.getSymbol(handles[i]);
-                if (!cached) {
-                    allCached = false;
-                    break;
-                }
-                result[i] = cached;
-            }
-            if (allCached)
-                return result;
-        }
-        const symbolData = await this.client.apiRequest(method, {
-            snapshot: this.snapshotId,
-            objectId: source.id,
-        });
-        if (symbolData == null)
-            return [];
-        else
-            return symbolData.map(data => this.getOrCreateSymbol(data));
+        return this.snapshotRegistry.fetchSymbols(source, method, handles, this.projectId);
     }
 }
 export class Project {
@@ -289,16 +355,20 @@ export class Project {
     checker;
     emitter;
     client;
-    constructor(data, snapshotId, client, objectRegistry, sourceFileCache, toPath) {
+    constructor(data, snapshotId, client, sourceFileCache, toPath, snapshotRegistry) {
         this.id = data.id;
         this.configFileName = data.configFileName;
         this.compilerOptions = data.compilerOptions;
         this.rootFiles = data.rootFiles;
         this.client = client;
         this.program = new Program(snapshotId, this.id, client, sourceFileCache, toPath);
+        const objectRegistry = new ProjectObjectRegistry(client, snapshotId, this.id, snapshotRegistry);
         this.checker = new Checker(snapshotId, this.id, client, objectRegistry);
         this.emitter = new Emitter(client);
     }
+    dispose() {
+        this.checker.dispose();
+    }
 }
 export class Program {
     snapshotId;
@@ -338,6 +408,13 @@ export class Program {
         const sourceFile = new RemoteSourceFile(binaryData, this.decoder);
         return this.sourceFileCache.set(path, sourceFile, parseOptionsKey, contentHash, this.snapshotId, this.projectId);
     }
+    async getSourceFileNames() {
+        const data = await this.client.apiRequest("getSourceFileNames", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+        });
+        return data ?? [];
+    }
     /**
      * Get syntactic (parse) diagnostics for a specific file or all files.
      * @param file - Optional file to get diagnostics for. If omitted, returns diagnostics for all files.
@@ -350,6 +427,18 @@ export class Program {
         });
         return data ?? [];
     }
+    /**
+     * Get binder diagnostics for a specific file or all files.
+     * @param file - Optional file to get diagnostics for. If omitted, returns diagnostics for all files.
+     */
+    async getBindDiagnostics(file) {
+        const data = await this.client.apiRequest("getBindDiagnostics", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            ...(file !== undefined ? { file } : {}),
+        });
+        return data ?? [];
+    }
     /**
      * Get semantic (type-check) diagnostics for a specific file or all files.
      * @param file - Optional file to get diagnostics for. If omitted, returns diagnostics for all files.
@@ -386,6 +475,26 @@ export class Program {
         });
         return data ?? [];
     }
+    /**
+     * Get program-wide diagnostics for the project, including compiler options diagnostics.
+     */
+    async getProgramDiagnostics() {
+        const data = await this.client.apiRequest("getProgramDiagnostics", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+        });
+        return data ?? [];
+    }
+    /**
+     * Get global (non-file-specific) semantic diagnostics for the project.
+     */
+    async getGlobalDiagnostics() {
+        const data = await this.client.apiRequest("getGlobalDiagnostics", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+        });
+        return data ?? [];
+    }
     /**
      * Get config file parsing diagnostics for the project.
      */
@@ -408,6 +517,9 @@ export class Checker {
         this.client = client;
         this.objectRegistry = objectRegistry;
     }
+    dispose() {
+        this.objectRegistry.clear();
+    }
     async getSymbolAtLocation(nodeOrNodes) {
         if (Array.isArray(nodeOrNodes)) {
             const data = await this.client.apiRequest("getSymbolsAtLocations", {
@@ -752,6 +864,20 @@ export class Checker {
             location: getNodeId(node),
         });
     }
+    async isArrayType(type) {
+        return this.client.apiRequest("isArrayType", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            type: type.id,
+        });
+    }
+    async isTupleType(type) {
+        return this.client.apiRequest("isTupleType", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            type: type.id,
+        });
+    }
     async getReturnTypeOfSignature(signature) {
         const data = await this.client.apiRequest("getReturnTypeOfSignature", {
             snapshot: this.snapshotId,
@@ -791,6 +917,14 @@ export class Checker {
         });
         return data ? data.map(d => this.objectRegistry.getOrCreateType(d)) : [];
     }
+    async getApparentType(type) {
+        const data = await this.client.apiRequest("getApparentType", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            type: type.id,
+        });
+        return data ? this.objectRegistry.getOrCreateType(data) : undefined;
+    }
     async getPropertiesOfType(type) {
         const data = await this.client.apiRequest("getPropertiesOfType", {
             snapshot: this.snapshotId,
@@ -822,6 +956,95 @@ export class Checker {
         });
         return data ? this.objectRegistry.getOrCreateType(data) : undefined;
     }
+    async getBaseConstraintOfType(type) {
+        const data = await this.client.apiRequest("getBaseConstraintOfType", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            type: type.id,
+        });
+        return data ? this.objectRegistry.getOrCreateType(data) : undefined;
+    }
+    async getPropertyOfType(type, name) {
+        const data = await this.client.apiRequest("getPropertyOfType", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            type: type.id,
+            name,
+        });
+        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
+    }
+    async getConstantValue(node) {
+        const data = await this.client.apiRequest("getConstantValue", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            location: getNodeId(node),
+        });
+        return data ?? undefined;
+    }
+    async getSignatureFromDeclaration(node) {
+        const data = await this.client.apiRequest("getSignatureFromDeclaration", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            location: getNodeId(node),
+        });
+        return data ? this.objectRegistry.getOrCreateSignature(data) : undefined;
+    }
+    async getExportSpecifierLocalTargetSymbol(node) {
+        const data = await this.client.apiRequest("getExportSpecifierLocalTargetSymbol", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            location: getNodeId(node),
+        });
+        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
+    }
+    async getAliasedSymbol(symbol) {
+        const data = await this.client.apiRequest("getAliasedSymbol", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            symbol: symbol.id,
+        });
+        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
+    }
+    async getImmediateAliasedSymbol(symbol) {
+        const data = await this.client.apiRequest("getImmediateAliasedSymbol", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            symbol: symbol.id,
+        });
+        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
+    }
+    async getExportsOfModule(symbol) {
+        const data = await this.client.apiRequest("getExportsOfModule", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            symbol: symbol.id,
+        });
+        return data ? data.map(d => this.objectRegistry.getOrCreateSymbol(d)) : [];
+    }
+    async getMemberInModuleExports(symbol, name) {
+        const data = await this.client.apiRequest("getMemberInModuleExports", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            symbol: symbol.id,
+            name,
+        });
+        return data ? this.objectRegistry.getOrCreateSymbol(data) : undefined;
+    }
+    async getJsDocTagsOfSymbol(symbol) {
+        const data = await this.client.apiRequest("getJsDocTags", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            symbol: symbol.id,
+        });
+        return data ?? [];
+    }
+    async getDocumentationCommentOfSymbol(symbol) {
+        return this.client.apiRequest("getDocumentationComment", {
+            snapshot: this.snapshotId,
+            project: this.projectId,
+            symbol: symbol.id,
+        });
+    }
     async getTypeArguments(type) {
         const data = await this.client.apiRequest("getTypeArguments", {
             snapshot: this.snapshotId,
@@ -904,6 +1127,12 @@ export class Symbol {
             return this;
         return this.objectRegistry.fetchSymbol(this, "getExportSymbolOfSymbol", this.exportSymbol);
     }
+    async getJsDocTags(checker) {
+        return checker.getJsDocTagsOfSymbol(this);
+    }
+    async getDocumentationComment(checker) {
+        return checker.getDocumentationCommentOfSymbol(this);
+    }
 }
 class TypeObject {
     objectRegistry;
@@ -1030,6 +1259,114 @@ class TypeObject {
     async getConstraint() {
         return this.objectRegistry.fetchType(this, "getConstraintOfType", this.substConstraint);
     }
+    isUnionType() {
+        return isUnionType(this);
+    }
+    isIntersectionType() {
+        return isIntersectionType(this);
+    }
+    isObjectType() {
+        return isObjectType(this);
+    }
+    isIntrinsicType() {
+        return isIntrinsicType(this);
+    }
+    isLiteralType() {
+        return isLiteralType(this);
+    }
+    isStringLiteralType() {
+        return isStringLiteralType(this);
+    }
+    isNumberLiteralType() {
+        return isNumberLiteralType(this);
+    }
+    isBigIntLiteralType() {
+        return isBigIntLiteralType(this);
+    }
+    isBooleanLiteralType() {
+        return isBooleanLiteralType(this);
+    }
+    isTypeReference() {
+        return isTypeReference(this);
+    }
+    isTupleType() {
+        return isTupleType(this);
+    }
+    isIndexType() {
+        return isIndexType(this);
+    }
+    isIndexedAccessType() {
+        return isIndexedAccessType(this);
+    }
+    isConditionalType() {
+        return isConditionalType(this);
+    }
+    isSubstitutionType() {
+        return isSubstitutionType(this);
+    }
+    isTemplateLiteralType() {
+        return isTemplateLiteralType(this);
+    }
+    isStringMappingType() {
+        return isStringMappingType(this);
+    }
+    isTypeParameter() {
+        return isTypeParameter(this);
+    }
+}
+export function isUnionType(type) {
+    return (type.flags & TypeFlags.Union) !== 0;
+}
+export function isIntersectionType(type) {
+    return (type.flags & TypeFlags.Intersection) !== 0;
+}
+export function isObjectType(type) {
+    return (type.flags & TypeFlags.Object) !== 0;
+}
+export function isIntrinsicType(type) {
+    return (type.flags & TypeFlags.Intrinsic) !== 0;
+}
+export function isLiteralType(type) {
+    return (type.flags & TypeFlags.Literal) !== 0;
+}
+export function isStringLiteralType(type) {
+    return (type.flags & TypeFlags.StringLiteral) !== 0;
+}
+export function isNumberLiteralType(type) {
+    return (type.flags & TypeFlags.NumberLiteral) !== 0;
+}
+export function isBigIntLiteralType(type) {
+    return (type.flags & TypeFlags.BigIntLiteral) !== 0;
+}
+export function isBooleanLiteralType(type) {
+    return (type.flags & TypeFlags.BooleanLiteral) !== 0;
+}
+export function isTypeReference(type) {
+    return isObjectType(type) && (type.objectFlags & ObjectFlags.Reference) !== 0;
+}
+export function isTupleType(type) {
+    return isObjectType(type) && (type.objectFlags & ObjectFlags.Tuple) !== 0;
+}
+export function isIndexType(type) {
+    return (type.flags & TypeFlags.Index) !== 0;
+}
+export function isIndexedAccessType(type) {
+    return (type.flags & TypeFlags.IndexedAccess) !== 0;
+}
+export function isConditionalType(type) {
+    return (type.flags & TypeFlags.Conditional) !== 0;
+}
+export function isSubstitutionType(type) {
+    return (type.flags & TypeFlags.Substitution) !== 0;
+}
+export function isTemplateLiteralType(type) {
+    return (type.flags & TypeFlags.TemplateLiteral) !== 0;
+}
+export function isStringMappingType(type) {
+    return (type.flags & TypeFlags.StringMapping) !== 0;
+}
+export function isTypeParameter(type) {
+    return (type.flags & TypeFlags.TypeParameter) !== 0;
 }
 export class Signature {
     flags;