@zzzen/pyright-internal 1.2.0-dev.20260705 → 1.2.0-dev.20260712

package/dist/typeServer/programWrapper.js

@@ -0,0 +1,731 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgramWrapper = void 0;
+exports.makeProgram = makeProgram;
+const analyzerNodeInfo_1 = require("../analyzer/analyzerNodeInfo");
+const parseTreeUtils_1 = require("../analyzer/parseTreeUtils");
+const scopeUtils_1 = require("../analyzer/scopeUtils");
+const sourceFile_1 = require("../analyzer/sourceFile");
+const typeEvaluatorTypes_1 = require("../analyzer/typeEvaluatorTypes");
+const types_1 = require("../analyzer/types");
+const debug_1 = require("../common/debug");
+const uri_1 = require("../common/uri/uri");
+const uriMap_1 = require("../common/uri/uriMap");
+const uriUtils_1 = require("../common/uri/uriUtils");
+const parseNodes_1 = require("../parser/parseNodes");
+const typeServerEvaluator_1 = require("./typeServerEvaluator");
+const typeEvalUtils_1 = require("./typeEvalUtils");
+const diagnosticUtils_1 = require("./diagnosticUtils");
+const typeServerConversionTypes_1 = require("./typeServerConversionTypes");
+const typeServerServiceKeys_1 = require("./typeServerServiceKeys");
+const typeServerConversionUtils_1 = require("./typeServerConversionUtils");
+const cancellation_1 = require("./cancellation");
+const typeCache_1 = require("./typeCache");
+/**
+ * Adapter that lets the in-proc Pyright `Program` (which is mutable and has no
+ * native snapshot concept) satisfy the `IProgram` contract the type server's
+ * conversion layer is written against.
+ *
+ *   - `run` runs the callback over the live `Program` via `_program.run(...)`.
+ *     Because Pyright's evaluator is synchronous the callback executes atomically,
+ *     so it simply receives `this` — there is no copy-on-write snapshot view.
+ *   - A monotonic `snapshot` counter (on the shared `ITypeCache`) is bumped by the
+ *     mutating methods below. It is a protocol-level content version: the server
+ *     hands it to clients via `typeServer/getSnapshot`, rejects stale requests at
+ *     the request boundary, and fires `SnapshotChangedNotification` on change.
+ *   - Cross-request state (`_declTypeCache`, `_protocolDeclCache`, `_addedStubs`, …)
+ *     lives on the wrapper, not on the `Program`, which has nowhere to put it, and
+ *     is invalidated when the snapshot increments.
+ */
+class ProgramWrapper {
+    constructor(_program, _cache) {
+        this._program = _program;
+        this._cache = _cache;
+        this._declTypeCache = new WeakMap();
+        this._protocolDeclCache = new Map();
+        this._disableSnapshotIncrement = false;
+        this._addedStubs = new uriMap_1.UriMap();
+        this._inEditMode = false;
+        // Overwrite a bunch of the program's methods so we can update the snapshot.
+        const originalSetFileOpened = this._program.setFileOpened.bind(this._program);
+        this._program.setFileOpened = (fileUri, version, contents, options) => {
+            originalSetFileOpened(fileUri, version, contents, options);
+            this._incrementSnapshot();
+        };
+        const originalSetFileClosed = this._program.setFileClosed.bind(this._program);
+        this._program.setFileClosed = (fileUri) => {
+            const result = originalSetFileClosed(fileUri);
+            this._incrementSnapshot();
+            return result;
+        };
+        const originalUpdateChainedUri = this._program.updateChainedUri.bind(this._program);
+        this._program.updateChainedUri = (fileUri, chainedFileUri) => {
+            originalUpdateChainedUri(fileUri, chainedFileUri);
+            this._incrementSnapshot();
+        };
+        const originalMarkFilesDirty = this._program.markFilesDirty.bind(this._program);
+        this._program.markFilesDirty = (fileUris, evenIfContentsAreSame) => {
+            originalMarkFilesDirty(fileUris, evenIfContentsAreSame);
+            this._incrementSnapshot();
+        };
+        const originalMarkAllFilesDirty = this._program.markAllFilesDirty.bind(this._program);
+        this._program.markAllFilesDirty = (evenIfContentsAreSame) => {
+            originalMarkAllFilesDirty(evenIfContentsAreSame);
+            this._incrementSnapshot();
+        };
+        const originalSetConfigOptions = this._program.setConfigOptions.bind(this._program);
+        this._program.setConfigOptions = (configOptions) => {
+            originalSetConfigOptions(configOptions);
+            this._cachedSearchPaths = undefined;
+            this._incrementSnapshot();
+        };
+        const originalSetImportResolver = this._program.setImportResolver.bind(this._program);
+        this._program.setImportResolver = (importResolver) => {
+            originalSetImportResolver(importResolver);
+            this._cachedSearchPaths = undefined;
+            this._incrementSnapshot();
+        };
+    }
+    get id() {
+        return this._program.id;
+    }
+    get typeCache() {
+        return this._cache;
+    }
+    get rootPath() {
+        return this._program.rootPath;
+    }
+    get console() {
+        return this._program.console;
+    }
+    get configOptions() {
+        return this._program.configOptions;
+    }
+    get fs() {
+        return this._program.fileSystem;
+    }
+    get fileSystem() {
+        return this._program.fileSystem;
+    }
+    get serviceProvider() {
+        return this._program.serviceProvider;
+    }
+    get uriMapper() {
+        return this._program.serviceProvider.tryGet(typeServerServiceKeys_1.TypeServerServiceKeys.uriMapper);
+    }
+    get isAlive() {
+        return true;
+    }
+    get isPyright() {
+        return true;
+    }
+    get performsAnalysis() {
+        return true;
+    }
+    get supportsPullDiagnostics() {
+        return true;
+    }
+    get symbolLookup() {
+        const symbolLookup = {
+            getFileInfo: (node) => {
+                // Ensure the file is bound before reading AnalyzerInfo off the node.
+                // Without this, nodes from files that haven't been bound yet (e.g.
+                // freshly-discovered modules during a code-action request) return
+                // undefined fileInfo and crash downstream readers.
+                const fileUri = this._cache.getUri(node);
+                this._program.getBoundSourceFileInfo(fileUri);
+                return (0, analyzerNodeInfo_1.getFileInfo)(node);
+            },
+            getImportInfo: (node) => {
+                return (0, analyzerNodeInfo_1.getImportInfo)(node);
+            },
+            getDeclaration: (node) => {
+                return (0, analyzerNodeInfo_1.getDeclaration)(node);
+            },
+            getFlowNode: (node) => {
+                return (0, analyzerNodeInfo_1.getFlowNode)(node);
+            },
+            getScope(node) {
+                return (0, analyzerNodeInfo_1.getScope)(node);
+            },
+            getScopeIdForNode(node) {
+                return (0, parseTreeUtils_1.getScopeIdForNode)(node);
+            },
+            getDunderAllInfo(node) {
+                return (0, analyzerNodeInfo_1.getDunderAllInfo)(node);
+            },
+            getSymbolsForFile: (fileUri, skipFileNeededCheck = false) => {
+                // The underlying sync `Program` has only one version of any file, and there is
+                // no snapshot view to pin to. Callers expect this to return a symbol table even
+                // if the file hasn't been analyzed yet, so ensure the file is present and bound.
+                this._program.addInterimFile(fileUri);
+                this._program.getBoundSourceFileInfo(fileUri, undefined, skipFileNeededCheck);
+                return this._program.getModuleSymbolTable(fileUri);
+            },
+            getSymbolsForNode: (node) => {
+                const scope = (0, scopeUtils_1.getScopeForNode)(node);
+                return scope?.symbolTable;
+            },
+            lookupSymbol: (scopingNode, name, _skipFileNeededCheck) => {
+                return (0, typeEvalUtils_1.getSymbolFromScope)(scopingNode, name);
+            },
+            getMatchingFileInfos: (fileId) => {
+                const parseTrees = this._program
+                    .getSourceFileInfoList()
+                    .map((f) => f.sourceFile.getParseResults()?.parserOutput.parseTree)
+                    .filter((t) => !!t);
+                const fileInfos = parseTrees.map((p) => (0, analyzerNodeInfo_1.getFileInfo)(p)).filter((f) => f.fileId === fileId);
+                return fileInfos;
+            },
+        };
+        return symbolLookup;
+    }
+    runEditMode(callback, token) {
+        let results = [];
+        if (this._inEditMode) {
+            throw new cancellation_1.ServerCanceledException();
+        }
+        this._inEditMode = true;
+        this._program.enterEditMode();
+        try {
+            this._program.evaluator?.runWithCancellationToken(token, () => callback(this));
+        }
+        finally {
+            results = this._program.exitEditMode();
+            this._inEditMode = false;
+        }
+        return results;
+    }
+    enterEditMode() {
+        this._program.enterEditMode();
+    }
+    exitEditMode() {
+        return this._program.exitEditMode();
+    }
+    run(callback, token) {
+        return this._program.run(() => callback(this), token);
+    }
+    createEvaluator() {
+        return (0, typeServerEvaluator_1.createTypeServerEvaluator)(this._program, this.symbolLookup);
+    }
+    getCachedTypeForDeclaration(decl) {
+        return this._declTypeCache.get(decl.node);
+    }
+    setCachedTypeForDeclaration(decl, type) {
+        this._declTypeCache.set(decl.node, type);
+    }
+    getCachedProtocolDecl(tspDecl) {
+        return this._protocolDeclCache.get((0, typeServerConversionTypes_1.getProtocolDeclKey)(tspDecl));
+    }
+    setCachedProtocolDecl(tspDecl, decl) {
+        this._protocolDeclCache.set((0, typeServerConversionTypes_1.getProtocolDeclKey)(tspDecl), decl);
+    }
+    getSourceMapper(fileUri, mapCompiled, preferStubs, token) {
+        const sourceMapper = this._program.getSourceMapper(fileUri, token, mapCompiled, preferStubs);
+        const wrapper = {
+            findDeclarations: (decl) => {
+                return sourceMapper ? sourceMapper.findDeclarations(decl) : [];
+            },
+            findDeclarationsByType: (originatedPath, type, useTypeAlias) => {
+                return sourceMapper ? sourceMapper.findDeclarationsByType(originatedPath, type, useTypeAlias) : [];
+            },
+            findClassDeclarationsByType: (uri, type) => {
+                return sourceMapper ? sourceMapper.findClassDeclarationsByType(uri, type) : [];
+            },
+            findFunctionDeclarations: (decl) => {
+                return sourceMapper ? sourceMapper.findFunctionDeclarations(decl) : [];
+            },
+            getSourcePathsFromStub: (stubUri, fromFile) => {
+                return sourceMapper ? sourceMapper.getSourcePathsFromStub(stubUri, fromFile) : [];
+            },
+            getModuleNode: (uri) => {
+                return sourceMapper ? sourceMapper.getModuleNode(uri) : undefined;
+            },
+            findModules: (stubFile) => {
+                return sourceMapper ? sourceMapper.findModules(stubFile) : [];
+            },
+            getFileInfo: (node) => {
+                // Ensure the file is bound before reading AnalyzerInfo off the node.
+                const fileUri = this._cache.getUri(node);
+                this._program.getBoundSourceFileInfo(fileUri);
+                return (0, analyzerNodeInfo_1.getFileInfo)(node);
+            },
+        };
+        return wrapper;
+    }
+    getUri(node) {
+        return this._cache.getUri(node);
+    }
+    isCaseSensitive(uri) {
+        return this._cache.isCaseSensitive(uri);
+    }
+    /**
+     * Ensures the file is analyzed and the evaluator's prefetched type cache is warmed up.
+     * This avoids expensive re-evaluation when the cache is cold (e.g., first request for a file
+     * that imports large libraries).
+     */
+    ensureFileAnalyzed(fileUri, token) {
+        const sourceFile = this._program.getSourceFile(fileUri);
+        if (!sourceFile) {
+            return;
+        }
+        // Analyze the file if needed
+        this._program.analyzeFile(fileUri, token);
+        // Warm up the evaluator's prefetched type cache by calling getType on the first expression.
+        // This triggers initializePrefetchedTypes which caches built-in types like object, bool, int, etc.
+        // Without this, the first call to getExpectedType/getType would be slow.
+        const parserOutput = this._program.getParserOutput(fileUri);
+        if (parserOutput?.parseTree) {
+            this._program.run((p) => {
+                // Find the first expression node in the parse tree
+                const firstExpr = (0, typeServerConversionUtils_1.findFirstExpression)(parserOutput.parseTree);
+                if (firstExpr) {
+                    // This will trigger initializePrefetchedTypes
+                    p.evaluator?.getType(firstExpr);
+                }
+            }, token);
+        }
+    }
+    getComputedType(arg, token) {
+        const result = this._program.run((p) => {
+            if ((0, typeEvalUtils_1.isDeclaration)(arg)) {
+                return (0, typeEvalUtils_1.getEffectiveTypeOfDeclaration)(p.evaluator, arg);
+            }
+            if ((0, parseNodes_1.isExpressionNode)(arg)) {
+                return p.evaluator?.getType(arg);
+            }
+            return undefined;
+        }, token);
+        // Massage the result to ensure compatibility with the protocol.
+        return this._massageTypeResult(result);
+    }
+    getExpectedType(arg, token) {
+        const result = this._program.run((p) => {
+            if ((0, typeEvalUtils_1.isDeclaration)(arg)) {
+                const type = p.evaluator?.getTypeForDeclaration(arg)?.type;
+                return type
+                    ? {
+                        type,
+                        node: arg.node,
+                        candidates: [],
+                    }
+                    : undefined;
+            }
+            if ((0, parseNodes_1.isExpressionNode)(arg)) {
+                return p.evaluator?.getExpectedType(arg);
+            }
+            return undefined;
+        }, token);
+        return this._massageExpectedTypeResult(result);
+    }
+    getDeclaredType(arg, token) {
+        const result = this._program.run((p) => {
+            if ((0, typeEvalUtils_1.isDeclaration)(arg)) {
+                return p.evaluator?.getTypeForDeclaration(arg)?.type;
+            }
+            if ((0, parseNodes_1.isExpressionNode)(arg)) {
+                return p.evaluator?.getType(arg);
+            }
+            return undefined;
+        }, token);
+        // Massage the result to ensure compatibility with the protocol.
+        return this._massageTypeResult(result);
+    }
+    startProfiling() {
+        const localProfiler = this.serviceProvider.tryGet(typeServerServiceKeys_1.TypeServerServiceKeys.profilingService);
+        return localProfiler?.startProfiling();
+    }
+    stopProfiling() {
+        const localProfiler = this.serviceProvider.tryGet(typeServerServiceKeys_1.TypeServerServiceKeys.profilingService);
+        return localProfiler?.stopProfiling();
+    }
+    startWorkspaceDiagnostics(partialResultToken) {
+        // No-op for internal program
+    }
+    stopWorkspaceDiagnostics() {
+        // No-op for internal program
+    }
+    getPythonSearchPaths(token) {
+        const execEnv = this._getExecEnv(this._program.rootPath);
+        if (!this._cachedSearchPaths) {
+            this._cachedSearchPaths = this._program.importResolver.getImportRoots(execEnv);
+        }
+        return this._cachedSearchPaths;
+    }
+    lookupImport(fileUriOrModule, options) {
+        return this._program.lookUpImport(fileUriOrModule, options);
+    }
+    owns(uri) {
+        return this._program.owns(uri);
+    }
+    getParserOutput(fileUri) {
+        let results = this._program.getParserOutput(fileUri);
+        if (!results) {
+            // Try making an interim file instead.
+            if (this.fileSystem.existsSync(fileUri)) {
+                this._program.addInterimFile(fileUri);
+                results = this._program.getParserOutput(fileUri);
+            }
+        }
+        return results;
+    }
+    getParseResults(fileUri) {
+        let results = this._program.getParseResults(fileUri);
+        if (!results) {
+            // Try making an interim file instead.
+            if (this.fileSystem.existsSync(fileUri)) {
+                this._program.addInterimFile(fileUri);
+                results = this._program.getParseResults(fileUri);
+            }
+        }
+        if (!results) {
+            return undefined;
+        }
+        // Sync `ProgramView.getParseResults` returns the upstream `ParseFileResults`; the
+        // type server's `ParseResults` adds `moduleName` and `uri`. Synthesize them so the
+        // wrapper satisfies the shared `IProgram` contract used by snapshot-aware callers.
+        return {
+            ...results,
+            moduleName: this.getModuleName(fileUri) ?? '',
+            uri: fileUri,
+        };
+    }
+    addStubCode(code, directoryUri) {
+        // Generate a unique stub URI
+        // If directoryUri is provided, create the stub in that directory so imports resolve correctly
+        const stubFileName = `__stub_${Date.now()}_${Math.random().toString(36).substring(7)}.pyi`;
+        const stubUri = directoryUri
+            ? directoryUri.resolvePaths(stubFileName)
+            : uri_1.Uri.file(`/${stubFileName}`, this.serviceProvider);
+        // Disable snapshot increment while adding stub files since they're dynamically generated
+        // and don't invalidate existing type analysis
+        this._disableSnapshotIncrement = true;
+        try {
+            // Add as an interim file to the underlying program
+            // This allows the program to parse and track the file
+            this._program.setFileOpened(stubUri, 0, code, {
+                ipythonMode: sourceFile_1.IPythonMode.None,
+                chainedFileUri: undefined,
+                isVirtual: true,
+            });
+            this._program.addInterimFile(stubUri);
+            // Get the parse results from the program
+            const parseResults = this._program.getParseResults(stubUri);
+            if (!parseResults) {
+                throw new Error('Failed to parse stub code');
+            }
+            this._addedStubs.set(stubUri, true);
+            return {
+                uri: stubUri,
+                parseResults: { ...parseResults, moduleName: this.getModuleName(stubUri) ?? '', uri: stubUri },
+            };
+        }
+        finally {
+            this._disableSnapshotIncrement = false;
+        }
+    }
+    getModuleName(fileUri) {
+        // Use the import resolver to get the module name, matching the sync Program._getModuleName() behavior.
+        // This ensures proper module name resolution for operations like rename module.
+        // If this looks like a directory path (no extension or ends with __init__), determine the target file.
+        // We don't require the file/directory to exist - the import resolver computes module names from paths.
+        let targetUri = fileUri;
+        // Check if it's an existing directory
+        if (this._program.fileSystem.existsSync(fileUri) && !(0, uriUtils_1.isFile)(this._program.fileSystem, fileUri)) {
+            // It's an existing directory - look for __init__.pyi first, then __init__.py
+            let initFile = fileUri.initPyiUri;
+            if (!this._program.fileSystem.existsSync(initFile)) {
+                initFile = fileUri.initPyUri;
+                if (!this._program.fileSystem.existsSync(initFile)) {
+                    // No __init__ file found, can't determine module name for this package
+                    return undefined;
+                }
+            }
+            targetUri = initFile;
+        }
+        else if (!this._program.fileSystem.existsSync(fileUri)) {
+            // File doesn't exist yet (e.g., new file path for rename/move)
+            // The import resolver can still compute the module name from the path
+            // For directories being created, assume __init__.py will be created
+            const ext = fileUri.lastExtension;
+            if (!ext) {
+                // No extension suggests it's a directory - use __init__.py path for module name
+                targetUri = fileUri.initPyUri;
+            }
+            // Otherwise, use the file path as-is
+        }
+        const execEnv = this._program.configOptions.findExecEnvironment(targetUri);
+        const moduleNameAndType = this._program.importResolver.getModuleNameForImport(targetUri, execEnv, 
+        /* allowIllegalModuleName */ true, 
+        /* detectPyTyped */ true);
+        return moduleNameAndType.moduleName || undefined;
+    }
+    getSourceFileInfo(fileUri) {
+        const result = this._program.getSourceFileInfo(fileUri);
+        if (result) {
+            return this._makeSourceFileInfo(result);
+        }
+        return undefined;
+    }
+    hasSourceFile(fileUri) {
+        // Sync `Program.getSourceFileInfo` does not lazily materialize, so a
+        // simple existence check is safe.
+        return !!this._program.getSourceFileInfo(fileUri);
+    }
+    getTrackedFileList() {
+        return this._program.getSourceFileInfoList().map((s) => this._makeSourceFileInfo(s));
+    }
+    updateFileContents(uri, newContents) {
+        let fileInfo = this._program.getSourceFileInfo(uri);
+        if (!fileInfo) {
+            fileInfo = this._program.addInterimFile(uri);
+        }
+        if (fileInfo) {
+            const version = fileInfo.clientVersion || 0;
+            const chainedFileUri = fileInfo ? fileInfo.chainedSourceFile?.uri : undefined;
+            const ipythonMode = fileInfo ? fileInfo.ipythonMode : sourceFile_1.IPythonMode.None;
+            this._program.setFileOpened(uri, version + 1, newContents, { chainedFileUri, ipythonMode });
+        }
+    }
+    addTrackedFile(uri, isThirdPartyImport, isInPyTypedPackage) {
+        this._program.addTrackedFile(uri, isThirdPartyImport, isInPyTypedPackage);
+    }
+    setTrackedFiles(uris) {
+        this._program.setTrackedFiles(uris);
+    }
+    handleMemoryHighUsage() {
+        this._program.handleMemoryHighUsage();
+    }
+    getSnapshot(token) {
+        return this._cache.snapshot;
+    }
+    getDocumentDiagnostics(uri, previousResultId, token) {
+        const sourceFile = this._program.getSourceFile(uri);
+        if (sourceFile) {
+            // Analyze the file if it needs to be analyzed
+            if (sourceFile.isCheckingRequired() || sourceFile.isBindingRequired()) {
+                this._program.analyzeFile(uri, token);
+            }
+        }
+        const parseResults = this._program.getParseResults(uri);
+        let diagnostics = [];
+        let versionStr = undefined;
+        if (sourceFile && parseResults) {
+            const range = {
+                start: { line: 0, character: 0 },
+                end: { line: parseResults.tokenizerOutput.lines.count, character: 0 },
+            };
+            diagnostics = this._program
+                .getDiagnosticsForRange(uri, range)
+                .map((d) => (0, diagnosticUtils_1.convertFromPyrightDiagnostic)(d, this._program.fileSystem, true, true) || d);
+            versionStr = sourceFile.getDiagnosticVersion().toString();
+        }
+        return { kind: 'full', resultId: versionStr, items: diagnostics };
+    }
+    resolveImport(source, moduleDescriptor, token) {
+        const realModuleDescriptor = {
+            ...moduleDescriptor,
+            importedSymbols: new Set(),
+        };
+        const results = this._program.importResolver.resolveImport(source, this._getExecEnv(source), realModuleDescriptor);
+        const uris = results.resolvedUris.filter((uri) => uri !== undefined && !uri.isEmpty());
+        if (uris && results.isImportFound) {
+            // Make sure to pick the last one. It's the most specific.
+            return uris[uris.length - 1];
+        }
+        return undefined;
+    }
+    changedWatchedFiles(changes) {
+        // Not necessary for the normal program.
+    }
+    addInterimFile(uri) {
+        this._program.addInterimFile(uri);
+        return this;
+    }
+    dispose() {
+        // Don't dispose of the program. The caller is responsible for that.
+    }
+    _massageTypeResult(result) {
+        // For function types, make sure we inferred the return type if not
+        // already.
+        if (result && (0, types_1.isFunctionOrOverloaded)(result)) {
+            this._program.evaluator?.inferReturnTypeIfNecessary(result);
+        }
+        // Temporary problem. If this is a class, the protocol compatibility
+        // map stores Pyright types in it. Remove it.
+        if (result && (0, types_1.isClass)(result) && result.shared.protocolCompatibility) {
+            result = { ...result, shared: { ...result.shared, protocolCompatibility: undefined } };
+        }
+        // Remove all cached values. They need to be recomputed on the client side.
+        if (result && result.cached) {
+            result = { ...result, cached: undefined };
+        }
+        return result;
+    }
+    _massageExpectedTypeResult(result) {
+        if (!result) {
+            return undefined;
+        }
+        const type = this._massageTypeResult(result.type);
+        if (!type) {
+            return undefined;
+        }
+        const candidates = result.candidates
+            .map((candidate) => this._massageTypeResult(candidate))
+            .filter((candidate) => !!candidate);
+        return {
+            type,
+            node: result.node,
+            candidates: (0, typeEvaluatorTypes_1.ensureExpectedTypeCandidates)(type, candidates),
+        };
+    }
+    _makeSourceFileInfo(s) {
+        // Create an anonymous class that wraps a SourceFileInfo and provides the ISourceFileInfo interface
+        return new (class {
+            constructor(_parentWrapper, _s) {
+                this._parentWrapper = _parentWrapper;
+                this._s = _s;
+                this._makeSourceFileInfo = (sf) => {
+                    return this._parentWrapper._makeSourceFileInfo(sf);
+                };
+            }
+            // Implement all properties from SourceFileInfo as getters
+            get uri() {
+                return this._s.uri;
+            }
+            get contents() {
+                return this._s.contents;
+            }
+            get ipythonMode() {
+                return this._s.ipythonMode;
+            }
+            get isTypeshedFile() {
+                return this._s.isTypeshedFile;
+            }
+            get isThirdPartyImport() {
+                return this._s.isThirdPartyImport;
+            }
+            get isThirdPartyPyTypedPresent() {
+                return this._s.isThirdPartyPyTypedPresent;
+            }
+            get isTypingStubFile() {
+                return this._s.isTypingStubFile;
+            }
+            get hasTypeAnnotations() {
+                return this._s.hasTypeAnnotations;
+            }
+            get diagnosticsVersion() {
+                return this._s.diagnosticsVersion;
+            }
+            get semanticVersion() {
+                return this._s.semanticVersion;
+            }
+            get clientVersion() {
+                return this._s.clientVersion;
+            }
+            get chainedSourceFile() {
+                return this._s.chainedSourceFile;
+            }
+            get isTracked() {
+                return this._s.isTracked;
+            }
+            get isOpenByClient() {
+                return this._s.isOpenByClient;
+            }
+            get isVirtual() {
+                return this._s.isVirtual;
+            }
+            get imports() {
+                return this._s.imports;
+            }
+            get areImportsComputed() {
+                return true;
+            }
+            get importedBy() {
+                return this._s.importedBy;
+            }
+            get shadows() {
+                return this._s.shadows;
+            }
+            get shadowedBy() {
+                return this._s.shadowedBy;
+            }
+            getImports() {
+                return s.imports.map(this._makeSourceFileInfo);
+            }
+            getImportedBy() {
+                return s.importedBy.map(this._makeSourceFileInfo);
+            }
+            getImplicitImport() {
+                if (s.builtinsImport === s) {
+                    return undefined;
+                }
+                if (s.chainedSourceFile && !s.chainedSourceFile.sourceFile.isFileDeleted()) {
+                    return this._makeSourceFileInfo(s.chainedSourceFile);
+                }
+                return s.builtinsImport ? this._makeSourceFileInfo(s.builtinsImport) : undefined;
+            }
+            getBuiltinsImport() {
+                return s.builtinsImport ? this._makeSourceFileInfo(s.builtinsImport) : undefined;
+            }
+            // Binding-specialized methods: in the wrapper path, imports are always
+            // synchronously available so these delegate to the full-import versions.
+            getBuiltinsImportForBinding() {
+                return this.getBuiltinsImport();
+            }
+            getImplicitImportForBinding() {
+                return this.getImplicitImport();
+            }
+        })(this, s);
+    }
+    _incrementSnapshot() {
+        if (this._disableSnapshotIncrement) {
+            return;
+        }
+        this._cache.incrementSnapshot();
+        this._cachedSearchPaths = undefined;
+        // Drop the declaration→Type cache; entries are tied to parse-tree
+        // nodes that may be replaced by re-parsed source files.
+        this._declTypeCache = new WeakMap();
+        // Drop the protocol-declaration cache; the resolved Pyright Declaration
+        // it points to may reference parse nodes that no longer exist.
+        this._protocolDeclCache = new Map();
+        // Remove all added stubs from our tracking map
+        this._disableSnapshotIncrement = true;
+        try {
+            this._addedStubs.forEach((_, uri) => {
+                this._program.setFileClosed(uri);
+            });
+            this._addedStubs.clear();
+        }
+        finally {
+            this._disableSnapshotIncrement = false;
+        }
+    }
+    _getExecEnv(uri) {
+        const env = this._program.configOptions
+            .getExecutionEnvironments()
+            .find((env) => env.root && (env.root.equals(uri) || uri.isChild(env.root)));
+        return env ?? this._program.configOptions.getDefaultExecEnvironment();
+    }
+}
+exports.ProgramWrapper = ProgramWrapper;
+const programWrappers = new WeakMap();
+function makeProgram(program, cache) {
+    // Cache the wrapper for the program. This lets us avoid creating multiple wrappers for the
+    // same program and use the same wrapper as the key into other maps.
+    let wrapper = programWrappers.get(program);
+    if (!wrapper) {
+        wrapper = new ProgramWrapper(program, cache ?? new typeCache_1.TypeCache(program.serviceProvider, (uri) => program.getParserOutput(uri)));
+        programWrappers.set(program, wrapper);
+    }
+    else if (cache && wrapper instanceof ProgramWrapper && wrapper.typeCache !== cache) {
+        // Enforce the snapshot invariant: a program must not be re-wrapped with a different
+        // type cache. If it were, `server._onGetSnapshot()` (which reads the global cache) and
+        // the request handlers (which read the wrapper's cache) would report divergent
+        // snapshots and livelock the client on permanent `ServerCancelled`.
+        (0, debug_1.fail)('makeProgram called with a different type cache for an already-wrapped program');
+    }
+    return wrapper;
+}
+//# sourceMappingURL=programWrapper.js.map