@zzzen/pyright-internal 1.2.0-dev.20230507 → 1.2.0-dev.20230521

package/dist/analyzer/program.d.ts

@@ -1,15 +1,12 @@
-import { CancellationToken, CompletionItem, DocumentSymbol } from 'vscode-languageserver';
-import { ConfigOptions, ExecutionEnvironment } from '../common/configOptions';
+import { CancellationToken } from 'vscode-languageserver';
+import { ConfigOptions } from '../common/configOptions';
 import { ConsoleInterface } from '../common/console';
 import { Diagnostic } from '../common/diagnostic';
 import { FileDiagnostics } from '../common/diagnosticSink';
 import { FileEditAction } from '../common/editAction';
-import { ProgramView } from '../common/extensibility';
+import { ProgramMutator, ProgramView } from '../common/extensibility';
 import { LogTracker } from '../common/logTracker';
-import { Position, Range } from '../common/textRange';
-import { AutoImportOptions, AutoImportResult } from '../languageService/autoImporter';
-import { AbbreviationMap, CompletionOptions, CompletionResultsList } from '../languageService/completionProvider';
-import { IndexOptions, IndexResults, WorkspaceSymbolCallback } from '../languageService/documentSymbolProvider';
+import { Range } from '../common/textRange';
 import { ParseResults } from '../parser/parser';
 import { CacheManager } from './cacheManager';
 import { ImportResolver } from './importResolver';
@@ -18,7 +15,6 @@ import { SourceMapper } from './sourceMapper';
 import { Symbol } from './symbol';
 import { PrintTypeOptions, TypeEvaluator } from './typeEvaluatorTypes';
 import { Type } from './types';
-export declare const MaxWorkspaceIndexFileCount = 2000;
 export interface SourceFileInfo {
     sourceFile: SourceFile;
     isTypeshedFile: boolean;
@@ -40,10 +36,6 @@ export interface MaxAnalysisTime {
     openFilesTimeInMs: number;
     noOpenFilesTimeInMs: number;
 }
-export interface Indices {
-    setWorkspaceIndex(path: string, indexResults: IndexResults): void;
-    getIndex(execEnv: string | undefined): Map<string, IndexResults> | undefined;
-}
 export declare type PreCheckCallback = (parseResults: ParseResults, evaluator: TypeEvaluator) => void;
 export interface OpenFileOptions {
     isTracked: boolean;
@@ -53,22 +45,22 @@ export interface OpenFileOptions {
 }
 export declare class Program {
     private _disableChecker?;
-    private _console;
-    private _sourceFileList;
-    private _sourceFileMap;
+    private static _nextId;
+    private readonly _console;
+    private readonly _sourceFileList;
+    private readonly _sourceFileMap;
+    private readonly _logTracker;
+    private readonly _cacheManager;
+    private readonly _id;
     private _allowedThirdPartyImports;
-    private _evaluator;
     private _configOptions;
     private _importResolver;
-    private _logTracker;
+    private _evaluator;
     private _parsedFileCount;
     private _preCheckCallback;
-    private _cacheManager;
-    private _id;
-    private static _nextId;
     private _isEditMode;
-    constructor(initialImportResolver: ImportResolver, initialConfigOptions: ConfigOptions, console?: ConsoleInterface, logTracker?: LogTracker, _disableChecker?: boolean | undefined, cacheManager?: CacheManager);
-    get id(): number;
+    constructor(initialImportResolver: ImportResolver, initialConfigOptions: ConfigOptions, console?: ConsoleInterface, logTracker?: LogTracker, _disableChecker?: boolean | undefined, cacheManager?: CacheManager, id?: string);
+    get id(): string;
     get console(): ConsoleInterface;
     get rootPath(): string;
     get evaluator(): TypeEvaluator | undefined;
@@ -90,8 +82,8 @@ export declare class Program {
     getChainedFilePath(filePath: string): string | undefined;
     updateChainedFilePath(filePath: string, chainedFilePath: string | undefined): void;
     setFileClosed(filePath: string, isTracked?: boolean): FileDiagnostics[];
-    markAllFilesDirty(evenIfContentsAreSame: boolean, indexingNeeded?: boolean): void;
-    markFilesDirty(filePaths: string[], evenIfContentsAreSame: boolean, indexingNeeded?: boolean): void;
+    markAllFilesDirty(evenIfContentsAreSame: boolean): void;
+    markFilesDirty(filePaths: string[], evenIfContentsAreSame: boolean): void;
     getFileCount(userFileOnly?: boolean): number;
     getUserFileCount(): number;
     getUserFiles(): SourceFileInfo[];
@@ -103,13 +95,13 @@ export declare class Program {
     owns(filePath: string): boolean;
     getSourceFile(filePath: string): SourceFile | undefined;
     getBoundSourceFile(filePath: string): SourceFile | undefined;
-    getSourceFileInfoList(): SourceFileInfo[];
+    getSourceFileInfoList(): readonly SourceFileInfo[];
     getSourceFileInfo(filePath: string): SourceFileInfo | undefined;
     getBoundSourceFileInfo(filePath: string, content?: string, force?: boolean): SourceFileInfo | undefined;
     analyze(maxTime?: MaxAnalysisTime, token?: CancellationToken): boolean;
     analyzeFile(filePath: string, token?: CancellationToken): boolean;
-    indexWorkspace(callback: (path: string, results: IndexResults) => void, token: CancellationToken): number;
     run<T>(callback: (p: ProgramView) => T, token: CancellationToken): T;
+    runWithMutation(callback: (v: ProgramView, m: ProgramMutator) => void, token: CancellationToken): void;
     getSourceMapper(filePath: string, token: CancellationToken, mapCompiled?: boolean, preferStubs?: boolean): SourceMapper;
     getParseResults(filePath: string): ParseResults | undefined;
     handleMemoryHighUsage(): void;
@@ -119,18 +111,11 @@ export declare class Program {
     getTypeOfSymbol(symbol: Symbol): Type;
     printType(type: Type, options?: PrintTypeOptions): string;
     getTextOnRange(filePath: string, range: Range, token: CancellationToken): string | undefined;
-    getAutoImports(filePath: string, range: Range, similarityLimit: number, nameMap: AbbreviationMap | undefined, options: AutoImportOptions, token: CancellationToken): AutoImportResult[];
     getDiagnostics(options: ConfigOptions): FileDiagnostics[];
     getDiagnosticsForRange(filePath: string, range: Range): Diagnostic[];
-    getFileIndex(filePath: string, options: IndexOptions, token: CancellationToken): IndexResults | undefined;
-    addSymbolsForDocument(filePath: string, symbolList: DocumentSymbol[], token: CancellationToken): void;
-    reportSymbolsForWorkspace(query: string, reporter: WorkspaceSymbolCallback, token: CancellationToken): void;
-    getCompletionsForPosition(filePath: string, position: Position, workspacePath: string, options: CompletionOptions, nameMap: AbbreviationMap | undefined, libraryMap: Map<string, IndexResults> | undefined, token: CancellationToken): Promise<CompletionResultsList | undefined>;
-    resolveCompletionItem(filePath: string, completionItem: CompletionItem, options: CompletionOptions, nameMap: AbbreviationMap | undefined, libraryMap: Map<string, IndexResults> | undefined, token: CancellationToken): void;
     clone(): Program;
     getCacheUsage(): number;
     emptyCache(): void;
-    test_createSourceMapper(execEnv: ExecutionEnvironment, from?: SourceFileInfo): SourceMapper;
     private _handleMemoryHighUsage;
     private _discardCachedParseResults;
     private _runEvaluatorWithCancellationToken;
@@ -153,7 +138,6 @@ export declare class Program {
     private _bindFile;
     private _getEffectiveFutureImports;
     private _lookUpImport;
-    private _buildModuleSymbolsMap;
     private _shouldCheckFile;
     private _checkTypes;
     private _getImportsRecursive;

package/dist/analyzer/program.js

@@ -28,12 +28,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Program = exports.MaxWorkspaceIndexFileCount = void 0;
+exports.Program = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
-const vscode_languageserver_types_1 = require("vscode-languageserver-types");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
 const cancellationUtils_1 = require("../common/cancellationUtils");
-const collectionUtils_1 = require("../common/collectionUtils");
 const configOptions_1 = require("../common/configOptions");
 const console_1 = require("../common/console");
 const debug = __importStar(require("../common/debug"));
@@ -42,25 +40,19 @@ const extensibility_1 = require("../common/extensibility");
 const logTracker_1 = require("../common/logTracker");
 const pathUtils_1 = require("../common/pathUtils");
 const positionUtils_1 = require("../common/positionUtils");
-const stringUtils_1 = require("../common/stringUtils");
 const textRange_1 = require("../common/textRange");
 const timing_1 = require("../common/timing");
-const autoImporter_1 = require("../languageService/autoImporter");
-const completionProvider_1 = require("../languageService/completionProvider");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const cacheManager_1 = require("./cacheManager");
 const circularDependency_1 = require("./circularDependency");
 const parseTreeUtils_1 = require("./parseTreeUtils");
-const scopeUtils_1 = require("./scopeUtils");
 const sourceFile_1 = require("./sourceFile");
 const sourceFileInfoUtils_1 = require("./sourceFileInfoUtils");
 const sourceMapper_1 = require("./sourceMapper");
-const symbolNameUtils_1 = require("./symbolNameUtils");
 const tracePrinter_1 = require("./tracePrinter");
 const typeEvaluatorWithTracker_1 = require("./typeEvaluatorWithTracker");
 const typeStubWriter_1 = require("./typeStubWriter");
 const _maxImportDepth = 256;
-exports.MaxWorkspaceIndexFileCount = 2000;
 // Container for all of the files that are being analyzed. Files
 // can fall into one or more of the following categories:
 //  Tracked - specified by the config options
@@ -68,7 +60,7 @@ exports.MaxWorkspaceIndexFileCount = 2000;
 //  Opened - temporarily opened in the editor
 //  Shadowed - implementation file that shadows a type stub file
 class Program {
-    constructor(initialImportResolver, initialConfigOptions, console, logTracker, _disableChecker, cacheManager) {
+    constructor(initialImportResolver, initialConfigOptions, console, logTracker, _disableChecker, cacheManager, id) {
         this._disableChecker = _disableChecker;
         this._sourceFileList = [];
         this._sourceFileMap = new Map();
@@ -104,6 +96,20 @@ class Program {
             if (!sourceFileInfo) {
                 return undefined;
             }
+            if (options === null || options === void 0 ? void 0 : options.skipParsing) {
+                // Return dummy information if the caller has indicated that parsing is
+                // unnecessary. This is used in cases where the caller simply wants to
+                // know if the source file exists but is not interested in the contents.
+                return {
+                    symbolTable: new Map(),
+                    dunderAllNames: undefined,
+                    usesUnsupportedDunderAllForm: false,
+                    get docString() {
+                        return undefined;
+                    },
+                    isInPyTypedPackage: false,
+                };
+            }
             if (sourceFileInfo.sourceFile.isBindingRequired()) {
                 // Bind the file if it's not already bound. Don't count this time
                 // against the type checker.
@@ -136,7 +142,7 @@ class Program {
         this._cacheManager = cacheManager !== null && cacheManager !== void 0 ? cacheManager : new cacheManager_1.CacheManager();
         this._cacheManager.registerCacheOwner(this);
         this._createNewEvaluator();
-        this._id = Program._nextId;
+        this._id = id !== null && id !== void 0 ? id : `Prog_${Program._nextId}`;
         Program._nextId += 1;
     }
     get id() {
@@ -351,14 +357,14 @@ class Program {
         }
         return this._removeUnneededFiles();
     }
-    markAllFilesDirty(evenIfContentsAreSame, indexingNeeded = true) {
+    markAllFilesDirty(evenIfContentsAreSame) {
         const markDirtySet = new Set();
         this._sourceFileList.forEach((sourceFileInfo) => {
             if (evenIfContentsAreSame) {
-                sourceFileInfo.sourceFile.markDirty(indexingNeeded);
+                sourceFileInfo.sourceFile.markDirty();
             }
             else if (sourceFileInfo.sourceFile.didContentsChangeOnDisk()) {
-                sourceFileInfo.sourceFile.markDirty(indexingNeeded);
+                sourceFileInfo.sourceFile.markDirty();
                 // Mark any files that depend on this file as dirty
                 // also. This will retrigger analysis of these other files.
                 this._markFileDirtyRecursive(sourceFileInfo, markDirtySet);
@@ -368,7 +374,7 @@ class Program {
             this._createNewEvaluator();
         }
     }
-    markFilesDirty(filePaths, evenIfContentsAreSame, indexingNeeded = true) {
+    markFilesDirty(filePaths, evenIfContentsAreSame) {
         const markDirtySet = new Set();
         filePaths.forEach((filePath) => {
             const sourceFileInfo = this.getSourceFileInfo(filePath);
@@ -377,7 +383,7 @@ class Program {
                 // Handle builtins and __builtins__ specially. They are implicitly
                 // included by all source files.
                 if (fileName === 'builtins.pyi' || fileName === '__builtins__.pyi') {
-                    this.markAllFilesDirty(evenIfContentsAreSame, indexingNeeded);
+                    this.markAllFilesDirty(evenIfContentsAreSame);
                     return;
                 }
                 // If !evenIfContentsAreSame, see if the on-disk contents have
@@ -385,7 +391,7 @@ class Program {
                 // because we'll receive updates directly from the client.
                 if (evenIfContentsAreSame ||
                     (!sourceFileInfo.isOpenByClient && sourceFileInfo.sourceFile.didContentsChangeOnDisk())) {
-                    sourceFileInfo.sourceFile.markDirty(indexingNeeded);
+                    sourceFileInfo.sourceFile.markDirty();
                     // Mark any files that depend on this file as dirty
                     // also. This will retrigger analysis of these other files.
                     this._markFileDirtyRecursive(sourceFileInfo, markDirtySet);
@@ -526,59 +532,6 @@ class Program {
             return false;
         });
     }
-    indexWorkspace(callback, token) {
-        if (!this._configOptions.indexing) {
-            return 0;
-        }
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            // Go through all workspace files to create indexing data.
-            // This will cause all files in the workspace to be parsed and bound. But
-            // _handleMemoryHighUsage will make sure we don't OOM and
-            // at the end of this method, we will drop all trees and symbol tables
-            // created due to indexing.
-            let count = 0;
-            const initiallyParsedSet = new Set();
-            for (const sourceFileInfo of this._sourceFileList) {
-                if (!sourceFileInfo.sourceFile.isParseRequired()) {
-                    initiallyParsedSet.add(sourceFileInfo);
-                }
-                if ((0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo) && !sourceFileInfo.sourceFile.isIndexingRequired()) {
-                    count++;
-                }
-            }
-            if (count >= exports.MaxWorkspaceIndexFileCount) {
-                // Already processed max files.
-                return 0;
-            }
-            for (const sourceFileInfo of this._sourceFileList) {
-                if (!(0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo) || !sourceFileInfo.sourceFile.isIndexingRequired()) {
-                    continue;
-                }
-                this._bindFile(sourceFileInfo);
-                const results = sourceFileInfo.sourceFile.index({ indexingForAutoImportMode: false }, token);
-                if (results) {
-                    if (++count > exports.MaxWorkspaceIndexFileCount) {
-                        this._console.warn(`Workspace indexing has hit its upper limit: 2000 files`);
-                        dropParseAndBindInfoCreatedForIndexing(this._sourceFileList, initiallyParsedSet);
-                        return count;
-                    }
-                    callback(sourceFileInfo.sourceFile.getFilePath(), results);
-                }
-                this._handleMemoryHighUsage();
-            }
-            dropParseAndBindInfoCreatedForIndexing(this._sourceFileList, initiallyParsedSet);
-            return count;
-        });
-        function dropParseAndBindInfoCreatedForIndexing(sourceFiles, initiallyParsedSet) {
-            for (const sourceFileInfo of sourceFiles) {
-                if (sourceFileInfo.sourceFile.isParseRequired() || initiallyParsedSet.has(sourceFileInfo)) {
-                    continue;
-                }
-                // Drop parse and bind info created during indexing.
-                sourceFileInfo.sourceFile.dropParseAndBindInfo();
-            }
-        }
-    }
     // This will allow the callback to execute a type evaluator with an associated
     // cancellation token and provide a read-only program.
     run(callback, token) {
@@ -586,6 +539,38 @@ class Program {
         const evaluator = (_a = this._evaluator) !== null && _a !== void 0 ? _a : this._createNewEvaluator();
         return evaluator.runWithCancellationToken(token, () => callback(this));
     }
+    // This will allow the callback to execute a type evaluator with an associated
+    // cancellation token and provide a mutable program. Should already be in edit mode when called.
+    runWithMutation(callback, token) {
+        var _a;
+        if (this._isEditMode) {
+            // Create a temporary mutator that doesn't talk to the
+            // background thread. In edit mode there is no background thread.
+            const mutator = {
+                addInterimFile: (f) => {
+                    return this.addInterimFile(f);
+                },
+                setFileOpened: (p, v, c, i, ch, r) => {
+                    this.setFileOpened(p, v, c, {
+                        isTracked: this.owns(p),
+                        ipythonMode: i,
+                        chainedFilePath: ch,
+                        realFilePath: r,
+                    });
+                },
+                updateOpenFileContents: (p, v, c, i, r) => {
+                    this.setFileOpened(p, v, c, {
+                        isTracked: this.owns(p),
+                        ipythonMode: i,
+                        chainedFilePath: undefined,
+                        realFilePath: r,
+                    });
+                },
+            };
+            const evaluator = (_a = this._evaluator) !== null && _a !== void 0 ? _a : this._createNewEvaluator();
+            evaluator.runWithCancellationToken(token, () => callback(this, mutator));
+        }
+    }
     getSourceMapper(filePath, token, mapCompiled, preferStubs) {
         const sourceFileInfo = this.getSourceFileInfo(filePath);
         const execEnv = this._configOptions.findExecEnvironment(filePath);
@@ -726,51 +711,6 @@ class Program {
             return fileContents.substr(textRange.start, textRange.length);
         });
     }
-    getAutoImports(filePath, range, similarityLimit, nameMap, options, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return [];
-        }
-        const sourceFile = sourceFileInfo.sourceFile;
-        const fileContents = sourceFile.getOpenFileContents();
-        if (fileContents === undefined) {
-            // this only works with opened file
-            return [];
-        }
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a;
-            this._bindFile(sourceFileInfo);
-            const parseTree = sourceFile.getParseResults();
-            const textRange = (0, positionUtils_1.convertRangeToTextRange)(range, parseTree.tokenizerOutput.lines);
-            if (!textRange) {
-                return [];
-            }
-            const currentNode = (0, parseTreeUtils_1.findNodeByOffset)(parseTree.parseTree, textRange.start);
-            if (!currentNode) {
-                return [];
-            }
-            const writtenWord = fileContents.substr(textRange.start, textRange.length);
-            const map = this._buildModuleSymbolsMap(sourceFileInfo, options.libraryMap, 
-            /* includeSymbolsFromIndices */ true, token);
-            options.patternMatcher =
-                (_a = options.patternMatcher) !== null && _a !== void 0 ? _a : ((p, t) => (0, stringUtils_1.computeCompletionSimilarity)(p, t) > similarityLimit);
-            const autoImporter = new autoImporter_1.AutoImporter(this._configOptions.findExecEnvironment(filePath), this._importResolver, parseTree, range.start, new completionProvider_1.CompletionMap(), map, options);
-            // Filter out any name that is already defined in the current scope.
-            const results = [];
-            const currentScope = (0, scopeUtils_1.getScopeForNode)(currentNode);
-            if (currentScope) {
-                const info = nameMap === null || nameMap === void 0 ? void 0 : nameMap.get(writtenWord);
-                if (info) {
-                    // No scope filter is needed since we only do exact match.
-                    (0, collectionUtils_1.appendArray)(results, autoImporter.getAutoImportCandidatesForAbbr(writtenWord, info, token));
-                }
-                results.push(...autoImporter
-                    .getAutoImportCandidates(writtenWord, similarityLimit, /* abbrFromUsers */ undefined, token)
-                    .filter((r) => !currentScope.lookUpSymbolRecursive(r.name)));
-            }
-            return results;
-        });
-    }
     getDiagnostics(options) {
         const fileDiagnostics = this._removeUnneededFiles();
         this._sourceFileList.forEach((sourceFileInfo) => {
@@ -815,127 +755,13 @@ class Program {
             return (0, textRange_1.doRangesIntersect)(diag.range, range);
         });
     }
-    getFileIndex(filePath, options, token) {
-        if (options.indexingForAutoImportMode) {
-            // Memory optimization. We only want to hold onto symbols
-            // usable outside when importSymbolsOnly is on.
-            const name = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(filePath));
-            if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
-                return undefined;
-            }
-        }
-        this._handleMemoryHighUsage();
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            var _a;
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return undefined;
-            }
-            const content = (_a = sourceFileInfo.sourceFile.getFileContent()) !== null && _a !== void 0 ? _a : '';
-            if (options.indexingForAutoImportMode &&
-                !options.includeAllSymbols &&
-                !sourceFileInfo.sourceFile.isStubFile() &&
-                !sourceFileInfo.sourceFile.isThirdPartyPyTypedPresent()) {
-                // Perf optimization. if py file doesn't contain __all__
-                // No need to parse and bind.
-                if (content.indexOf('__all__') < 0) {
-                    return undefined;
-                }
-            }
-            this._bindFile(sourceFileInfo, content);
-            return sourceFileInfo.sourceFile.index(options, token);
-        });
-    }
-    addSymbolsForDocument(filePath, symbolList, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (sourceFileInfo) {
-                if (!sourceFileInfo.sourceFile.getCachedIndexResults()) {
-                    // If we already have cached index for this file, no need to bind this file.
-                    this._bindFile(sourceFileInfo);
-                }
-                sourceFileInfo.sourceFile.addHierarchicalSymbolsForDocument(symbolList, token);
-            }
-        });
-    }
-    reportSymbolsForWorkspace(query, reporter, token) {
-        this._runEvaluatorWithCancellationToken(token, () => {
-            // Don't do a search if the query is empty. We'll return
-            // too many results in this case.
-            if (!query) {
-                return;
-            }
-            // "Workspace symbols" searches symbols only from user code.
-            for (const sourceFileInfo of this._sourceFileList) {
-                if (!(0, sourceFileInfoUtils_1.isUserCode)(sourceFileInfo)) {
-                    continue;
-                }
-                if (!sourceFileInfo.sourceFile.getCachedIndexResults()) {
-                    // If we already have cached index for this file, no need to bind this file.
-                    this._bindFile(sourceFileInfo);
-                }
-                const symbolList = sourceFileInfo.sourceFile.getSymbolsForDocument(query, token);
-                if (symbolList.length > 0) {
-                    reporter(symbolList);
-                }
-                // This operation can consume significant memory, so check
-                // for situations where we need to discard the type cache.
-                this._handleMemoryHighUsage();
-            }
-        });
-    }
-    async getCompletionsForPosition(filePath, position, workspacePath, options, nameMap, libraryMap, token) {
-        const sourceFileInfo = this.getSourceFileInfo(filePath);
-        if (!sourceFileInfo) {
-            return undefined;
-        }
-        const completionResult = this._logTracker.log(`completion at ${filePath}:${position.line}:${position.character}`, (ls) => {
-            var _a;
-            const result = this._runEvaluatorWithCancellationToken(token, () => {
-                this._bindFile(sourceFileInfo);
-                return sourceFileInfo.sourceFile.getCompletionsForPosition(this, position, workspacePath, this._lookUpImport, options, nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), token);
-            });
-            ls.add(`found ${(_a = result === null || result === void 0 ? void 0 : result.completionMap.size) !== null && _a !== void 0 ? _a : 'null'} items`);
-            return result;
-        });
-        const completionResultsList = {
-            completionList: vscode_languageserver_types_1.CompletionList.create(completionResult === null || completionResult === void 0 ? void 0 : completionResult.completionMap.toArray()),
-            memberAccessInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.memberAccessInfo,
-            autoImportInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.autoImportInfo,
-            extensionInfo: completionResult === null || completionResult === void 0 ? void 0 : completionResult.extensionInfo,
-        };
-        const parseResults = sourceFileInfo.sourceFile.getParseResults();
-        if ((parseResults === null || parseResults === void 0 ? void 0 : parseResults.parseTree) && (parseResults === null || parseResults === void 0 ? void 0 : parseResults.text)) {
-            const execEnv = this._configOptions.findExecEnvironment(filePath);
-            const sourceMapper = this._createSourceMapper(execEnv, token, sourceFileInfo, 
-            /* mapCompiled */ true);
-            const offset = (0, positionUtils_1.convertPositionToOffset)(position, parseResults.tokenizerOutput.lines);
-            if (offset !== undefined && sourceMapper) {
-                await Promise.all(extensibility_1.Extensions.getProgramExtensions(parseResults.parseTree).map((e) => {
-                    var _a;
-                    return (_a = e.completionListExtension) === null || _a === void 0 ? void 0 : _a.updateCompletionResults(this.evaluator, sourceMapper, options, completionResultsList, parseResults, offset, this._configOptions.functionSignatureDisplay, token);
-                }));
-            }
-        }
-        return completionResultsList;
-    }
-    resolveCompletionItem(filePath, completionItem, options, nameMap, libraryMap, token) {
-        return this._runEvaluatorWithCancellationToken(token, () => {
-            const sourceFileInfo = this.getSourceFileInfo(filePath);
-            if (!sourceFileInfo) {
-                return;
-            }
-            this._bindFile(sourceFileInfo);
-            sourceFileInfo.sourceFile.resolveCompletionItem(this, this._lookUpImport, options, nameMap, libraryMap, () => this._buildModuleSymbolsMap(sourceFileInfo, libraryMap, options.includeUserSymbolsInAutoImport, token), completionItem, token);
-        });
-    }
     clone() {
         var _a, _b;
         const program = new Program(this._importResolver, this._configOptions, this._console, new logTracker_1.LogTracker(this._console, 'Cloned'));
         // Cloned program will use whatever user files the program currently has.
         const userFiles = this.getUserFiles();
         program.setTrackedFiles(userFiles.map((i) => i.sourceFile.getFilePath()));
-        program.markAllFilesDirty(true);
+        program.markAllFilesDirty(/* evenIfContentsAreSame */ true);
         // Make sure we keep editor content (open file) which could be different than one in the file system.
         for (const fileInfo of this.getOpened()) {
             const version = fileInfo.sourceFile.getClientVersion();
@@ -968,9 +794,6 @@ class Program {
         this._parsedFileCount = 0;
         extensibility_1.Extensions.getProgramExtensions(this.rootPath).forEach((e) => (e.clearCache ? e.clearCache() : null));
     }
-    test_createSourceMapper(execEnv, from) {
-        return this._createSourceMapper(execEnv, vscode_languageserver_1.CancellationToken.None, /* from */ from, /* mapCompiled */ false);
-    }
     _handleMemoryHighUsage() {
         const cacheUsage = this._cacheManager.getCacheUsage();
         // If the total cache has exceeded 75%, determine whether we should empty
@@ -1182,7 +1005,7 @@ class Program {
                 thirdPartyImportAllowed = true;
             }
             else if (importResult.isNamespacePackage &&
-                importResult.filteredImplicitImports.some((implicitImport) => !!implicitImport.pyTypedInfo)) {
+                Array.from(importResult.filteredImplicitImports.values()).some((implicitImport) => !!implicitImport.pyTypedInfo)) {
                 // Handle the case where the import targets a namespace package, and a
                 // submodule contained within it has a py.typed marker.
                 thirdPartyImportAllowed = true;
@@ -1581,31 +1404,6 @@ class Program {
         });
         return effectiveFutureImports;
     }
-    // Build a map of all modules within this program and the module-
-    // level scope that contains the symbol table for the module.
-    _buildModuleSymbolsMap(sourceFileToExclude, libraryMap, includeSymbolsFromIndices, token) {
-        // If we have library map, always use the map for library symbols.
-        const predicate = (s) => {
-            if (!libraryMap) {
-                // We don't have any prebuilt indices, so we need to include
-                // all files.
-                return true;
-            }
-            if (!this._configOptions.indexing) {
-                // We have some prebuilt indices such as stdlib, but indexing is disabled.
-                // Include files we don't have prebuilt indices.
-                return libraryMap.get(s.sourceFile.getFilePath()) === undefined;
-            }
-            // We have prebuilt indices for third party libraries. Include only
-            // user files.
-            return (0, sourceFileInfoUtils_1.isUserCode)(s);
-        };
-        // Only include import alias from user files if indexing is off for now.
-        // Currently, when indexing is off, we don't do import alias deduplication, so
-        // adding import alias is cheap. But when indexing is on, we do deduplication, which
-        // require resolveAliasDeclaration that can cause more files to be parsed and bound.
-        return (0, autoImporter_1.buildModuleSymbolsMap)(this._sourceFileList.filter((s) => s !== sourceFileToExclude && predicate(s)), includeSymbolsFromIndices, token);
-    }
     _shouldCheckFile(fileInfo) {
         // Always do a full checking for a file that's open in the editor.
         if (fileInfo.isOpenByClient) {