@zzzen/pyright-internal 1.2.0-dev.20230219 → 1.2.0-dev.20230305

package/dist/analyzer/program.d.ts

@@ -86,6 +86,7 @@ export declare class Program {
     setPreCheckCallback(preCheckCallback: PreCheckCallback): void;
     setAllowedThirdPartyImports(importNames: string[]): void;
     addTrackedFiles(filePaths: string[], isThirdPartyImport?: boolean, isInPyTypedPackage?: boolean): void;
+    addInterimFile(filePath: string): SourceFileInfo;
     addTrackedFile(filePath: string, isThirdPartyImport?: boolean, isInPyTypedPackage?: boolean): SourceFile;
     setFileOpened(filePath: string, version: number | null, contents: TextDocumentContentChangeEvent[], options?: OpenFileOptions): void;
     getChainedFilePath(filePath: string): string | undefined;
@@ -95,7 +96,7 @@ export declare class Program {
     markFilesDirty(filePaths: string[], evenIfContentsAreSame: boolean, indexingNeeded?: boolean): void;
     getFileCount(userFileOnly?: boolean): number;
     getUserFileCount(): number;
-    getTracked(): SourceFileInfo[];
+    getUserFiles(): SourceFileInfo[];
     getOpened(): SourceFileInfo[];
     getFilesToAnalyzeCount(): number;
     isCheckingOnlyOpenFiles(): boolean;
@@ -105,7 +106,7 @@ export declare class Program {
     getSourceFile(filePath: string): SourceFile | undefined;
     getBoundSourceFile(filePath: string): SourceFile | undefined;
     getSourceFileInfo(filePath: string): SourceFileInfo | undefined;
-    getBoundSourceFileInfo(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;
@@ -150,8 +151,8 @@ export declare class Program {
     renameModule(path: string, newPath: string, token: CancellationToken): FileEditActions | undefined;
     moveSymbolAtPosition(filePath: string, newFilePath: string, position: Position, options: {
         importFormat: ImportFormat;
-    }, token?: CancellationToken): FileEditActions | undefined;
-    private _moveSymbolAtPosition;
+    }, token: CancellationToken): FileEditActions | undefined;
+    clone(): Program;
     canRenameSymbolAtPosition(filePath: string, position: Position, isDefaultWorkspace: boolean, allowModuleRename: boolean, token: CancellationToken): {
         range: Range;
         declarations: Declaration[];

package/dist/analyzer/program.js

@@ -36,15 +36,16 @@ const collectionUtils_1 = require("../common/collectionUtils");
 const configOptions_1 = require("../common/configOptions");
 const console_1 = require("../common/console");
 const debug_1 = require("../common/debug");
-const diagnosticSink_1 = require("../common/diagnosticSink");
 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 textEditUtils_1 = require("../common/textEditUtils");
+const textEditTracker_1 = require("../common/textEditTracker");
 const textRange_1 = require("../common/textRange");
+const textRangeCollection_1 = require("../common/textRangeCollection");
 const timing_1 = require("../common/timing");
+const workspaceEditUtils_1 = require("../common/workspaceEditUtils");
 const autoImporter_1 = require("../languageService/autoImporter");
 const callHierarchyProvider_1 = require("../languageService/callHierarchyProvider");
 const completionProvider_1 = require("../languageService/completionProvider");
@@ -219,6 +220,15 @@ class Program {
             this.addTrackedFile(filePath, isThirdPartyImport, isInPyTypedPackage);
         });
     }
+    addInterimFile(filePath) {
+        // Double check not already there.
+        let fileInfo = this.getSourceFileInfo(filePath);
+        if (!fileInfo) {
+            fileInfo = this._createInterimFileInfo(filePath);
+            this._addToSourceFileListAndMap(fileInfo);
+        }
+        return fileInfo;
+    }
     addTrackedFile(filePath, isThirdPartyImport = false, isInPyTypedPackage = false) {
         let sourceFileInfo = this.getSourceFileInfo(filePath);
         const importName = this._getImportNameForFile(filePath);
@@ -280,8 +290,6 @@ class Program {
             sourceFileInfo.diagnosticsVersion = 0;
         }
         sourceFileInfo.sourceFile.setClientVersion(version, contents);
-        // Tell any extensions that this source file changed.
-        extensibility_1.Extensions.getProgramExtensions(filePath).forEach((e) => e.sourceFileChanged ? e.sourceFileChanged(sourceFileInfo) : undefined);
     }
     getChainedFilePath(filePath) {
         var _a;
@@ -369,8 +377,8 @@ class Program {
     getUserFileCount() {
         return this._sourceFileList.filter((s) => (0, sourceFileInfoUtils_1.isUserCode)(s)).length;
     }
-    getTracked() {
-        return this._sourceFileList.filter((s) => s.isTracked);
+    getUserFiles() {
+        return this._sourceFileList.filter((s) => (0, sourceFileInfoUtils_1.isUserCode)(s));
     }
     getOpened() {
         return this._sourceFileList.filter((s) => s.isOpenByClient);
@@ -422,12 +430,12 @@ class Program {
     getSourceFileInfo(filePath) {
         return this._sourceFileMap.get((0, pathUtils_1.normalizePathCase)(this._fs, filePath));
     }
-    getBoundSourceFileInfo(filePath) {
+    getBoundSourceFileInfo(filePath, content, force) {
         const sourceFileInfo = this.getSourceFileInfo(filePath);
         if (!sourceFileInfo) {
             return undefined;
         }
-        this._bindFile(sourceFileInfo);
+        this._bindFile(sourceFileInfo, content, force);
         return sourceFileInfo;
     }
     // Performs parsing and analysis of any source files in the program
@@ -678,8 +686,7 @@ class Program {
     _addShadowedFile(stubFile, shadowImplPath) {
         let shadowFileInfo = this.getSourceFileInfo(shadowImplPath);
         if (!shadowFileInfo) {
-            shadowFileInfo = this._createInterimFileInfo(shadowImplPath);
-            this._addToSourceFileListAndMap(shadowFileInfo);
+            shadowFileInfo = this.addInterimFile(shadowImplPath);
         }
         if (!shadowFileInfo.shadows.includes(stubFile)) {
             shadowFileInfo.shadows.push(stubFile);
@@ -727,8 +734,8 @@ class Program {
             : undefined);
         return this._evaluator;
     }
-    _parseFile(fileToParse, content) {
-        if (!this._isFileNeeded(fileToParse) || !fileToParse.sourceFile.isParseRequired()) {
+    _parseFile(fileToParse, content, force) {
+        if (!force && (!this._isFileNeeded(fileToParse) || !fileToParse.sourceFile.isParseRequired())) {
             return;
         }
         if (fileToParse.sourceFile.parse(this._configOptions, this._importResolver, content)) {
@@ -747,12 +754,12 @@ class Program {
     }
     // Binds the specified file and all of its dependencies, recursively. If
     // it runs out of time, it returns true. If it completes, it returns false.
-    _bindFile(fileToAnalyze, content) {
+    _bindFile(fileToAnalyze, content, force) {
         var _a, _b;
-        if (!this._isFileNeeded(fileToAnalyze) || !fileToAnalyze.sourceFile.isBindingRequired()) {
+        if (!force && (!this._isFileNeeded(fileToAnalyze) || !fileToAnalyze.sourceFile.isBindingRequired())) {
             return;
         }
-        this._parseFile(fileToAnalyze, content);
+        this._parseFile(fileToAnalyze, content, force);
         const getScopeIfAvailable = (fileInfo) => {
             if (!fileInfo || fileInfo === fileToAnalyze) {
                 return undefined;
@@ -1376,13 +1383,8 @@ class Program {
         });
     }
     moveSymbolAtPosition(filePath, newFilePath, position, options, token) {
-        if (vscode_languageserver_1.CancellationToken.is(options)) {
-            return this._moveSymbolAtPosition(filePath, newFilePath, position, { importFormat: "absolute" /* Absolute */ }, options);
-        }
-        return this._moveSymbolAtPosition(filePath, newFilePath, position, options, token);
-    }
-    _moveSymbolAtPosition(filePath, newFilePath, position, options, token) {
         return this._runEvaluatorWithCancellationToken(token, () => {
+            var _a, _b;
             const sourceFileExt = (0, pathUtils_1.getFileExtension)(filePath);
             const destFileExt = (0, pathUtils_1.getFileExtension)(newFilePath);
             if (sourceFileExt.toLowerCase() !== destFileExt.toLowerCase()) {
@@ -1412,9 +1414,21 @@ class Program {
                 return undefined;
             }
             // If this isn't a name node, there are no references to be found.
-            if (node.nodeType !== 38 /* Name */) {
+            if (node.nodeType !== 38 /* Name */ || !renameModuleProvider_1.RenameModuleProvider.canMoveSymbol(this._evaluator, node)) {
                 return undefined;
             }
+            // We will try to
+            // 1. Find symbol to move.
+            // 2. Update all references to the symbol to new location.
+            // 3. Remove the existing symbol.
+            // 4. Insert the symbol to the destination module.
+            // 5. Insert imports required for the symbol moved to the destination module.
+            // 6. Remove import no longer needed from the original module.
+            //
+            // Here all changes are done to edits, no features in LS will apply changes to
+            // program directly. All modification is done through LSP by a edit request so
+            // things like undo or edit stacks UI works.
+            // 1. Find symbol to move.
             const execEnv = this._configOptions.findExecEnvironment(filePath);
             const declarations = documentSymbolCollector_1.DocumentSymbolCollector.getDeclarationsForNode(node, this._evaluator, 
             /* resolveLocalNames */ false, documentSymbolCollector_1.DocumentSymbolCollectorUseCase.Rename, token, this._createSourceMapper(execEnv, token, fileInfo));
@@ -1422,21 +1436,21 @@ class Program {
             if (!renameModuleProvider) {
                 return undefined;
             }
+            // 2. Update affected references.
             this._processModuleReferences(renameModuleProvider, node.value, filePath);
+            // 3. Remove existing symbols.
             const sourceDecl = renameModuleProvider.declarations.find((d) => d.node && (0, pathUtils_1.getFileExtension)(d.path) === sourceFileExt);
             if (!sourceDecl) {
                 // Can't find symbol we can move.
                 return undefined;
             }
+            const symbolRange = renameModuleProvider_1.RenameModuleProvider.getSymbolTextRange(parseResults, sourceDecl);
             const importAdder = new importAdder_1.ImportAdder(this._configOptions, this._importResolver, this._evaluator);
-            const collectedimports = importAdder.collectImportsForSymbolsUsed(parseResults, sourceDecl.node, token);
+            const collectedimports = importAdder.collectImportsForSymbolsUsed(parseResults, symbolRange, token);
             let insertionPoint = 0;
             let insertionIndentation = 0;
             const newFileParseResults = newFileInfo === null || newFileInfo === void 0 ? void 0 : newFileInfo.sourceFile.getParseResults();
             if (newFileParseResults) {
-                // TODO: Add "insertAfter" option to make sure we insert symbol after that point.
-                //       For example, if collectedImports has symbols from the destination file, we should
-                //       insert after those symbols are defined.
                 const insertBefore = renameModuleProvider.tryGetFirstSymbolUsage(newFileParseResults);
                 insertionPoint = (0, insertionPointUtils_1.getInsertionPointForSymbolUnderModule)(this._evaluator, newFileParseResults, node.value, {
                     symbolDeclToIgnore: sourceDecl.path,
@@ -1446,16 +1460,15 @@ class Program {
                     // No place to insert the symbol.
                     return undefined;
                 }
-                insertionIndentation = (0, indentationUtils_1.getNewlineIndentation)(newFileParseResults, insertionPoint);
+                insertionIndentation = (0, indentationUtils_1.getModuleStatementIndentation)(newFileParseResults);
             }
+            const reindentResult = (0, indentationUtils_1.reindentSpan)(parseResults, symbolRange, insertionIndentation);
+            const fullRange = renameModuleProvider_1.RenameModuleProvider.getSymbolFullStatementTextRange(parseResults, sourceDecl);
+            renameModuleProvider.textEditTracker.addEdit(filePath, (0, positionUtils_1.convertTextRangeToRange)(textRange_1.TextRange.combine([reindentResult.originalSpan, fullRange]), parseResults.tokenizerOutput.lines), '');
+            // 4. Add the symbol to the destination file.
             const fileOperations = [];
-            renameModuleProvider.textEditTracker.addEdit(filePath, (0, parseTreeUtils_1.getFullStatementRange)(sourceDecl.node, parseResults, { includeTrailingBlankLines: true }), '');
-            let codeSnippetToInsert = (0, indentationUtils_1.reindentSpan)(parseResults, sourceDecl.node, insertionIndentation);
+            let codeSnippetToInsert = reindentResult.text;
             if (newFileParseResults) {
-                // TODO: We need to "add import" statement for symbols defined in the destination file
-                //       if we couldn't find insertion point where all constraints are met.
-                //       For example, if the symbol we are moving is used before other symbols it references are declared.
-                importAdder.applyImportsTo(collectedimports, newFileParseResults, options.importFormat, renameModuleProvider.textEditTracker, token);
                 const range = (0, positionUtils_1.convertTextRangeToRange)({ start: insertionPoint, length: 0 }, newFileParseResults.tokenizerOutput.lines);
                 // If we are adding at the end of line (ex, end of a file),
                 // add new lines.
@@ -1465,16 +1478,121 @@ class Program {
             }
             else {
                 fileOperations.push({ kind: 'create', filePath: newFilePath });
-                const tempParseResults = (0, sourceFile_1.parseFile)(this._configOptions, newFilePath, codeSnippetToInsert, sourceFile_1.IPythonMode.None, new diagnosticSink_1.DiagnosticSink());
-                const insertAddEdits = importAdder.applyImports(collectedimports, tempParseResults, insertionPoint, options.importFormat, token);
-                const updateContent = (0, textEditUtils_1.applyTextEditActions)(codeSnippetToInsert, insertAddEdits, tempParseResults.tokenizerOutput.lines);
-                renameModuleProvider.textEditTracker.addEdit(newFilePath, (0, textRange_1.getEmptyRange)(), updateContent);
-            }
+                renameModuleProvider.textEditTracker.addEdit(newFilePath, (0, textRange_1.getEmptyRange)(), codeSnippetToInsert);
+            }
+            // 5. Insert imports required for the symbol moved to the destination module.
+            //
+            // Since step 5 and 6 can create nested edits, we clone the program and apply all changes to re-calculate
+            // edits we need to apply to the destination file. The same workflow as `fix all` but done in program level
+            // not service level.
+            const cloned = this.clone();
+            let edits = renameModuleProvider.getEdits();
+            const textAfterSymbolAdded = (0, workspaceEditUtils_1.applyTextEditsToString)(edits.filter((v) => v.filePath === newFilePath), (_a = newFileParseResults === null || newFileParseResults === void 0 ? void 0 : newFileParseResults.tokenizerOutput.lines) !== null && _a !== void 0 ? _a : new textRangeCollection_1.TextRangeCollection([]), (_b = newFileInfo === null || newFileInfo === void 0 ? void 0 : newFileInfo.sourceFile.getFileContent()) !== null && _b !== void 0 ? _b : '');
+            _updateFileContent(cloned, newFilePath, textAfterSymbolAdded);
+            const textAfterImportsAdded = _tryGetTextAfterImportsAdded(cloned, newFilePath, collectedimports, insertionPoint, token);
+            edits = _updateFileEditActions(edits, newFilePath, newFileParseResults, textAfterSymbolAdded, textAfterImportsAdded);
+            // 6. Remove imports no longer required from original module.
+            const textAfterSymbolRemoved = (0, workspaceEditUtils_1.applyTextEditsToString)(edits.filter((v) => v.filePath === filePath), parseResults.tokenizerOutput.lines, fileInfo.sourceFile.getFileContent());
+            _updateFileContent(cloned, filePath, textAfterSymbolRemoved);
+            const textAfterUnusedImportsRemoved = _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, collectedimports, 0, token);
+            edits = _updateFileEditActions(edits, filePath, parseResults, textAfterSymbolRemoved, textAfterUnusedImportsRemoved);
+            cloned.dispose();
             return {
-                edits: renameModuleProvider.getEdits(),
+                edits,
                 fileOperations,
             };
+            function _updateFileEditActions(edits, filePath, parseResults, oldText, newText) {
+                if (newText === undefined || oldText === newText) {
+                    return edits;
+                }
+                // There were nested edits. Replace whole file.
+                edits = edits.filter((v) => v.filePath !== filePath);
+                edits.push({
+                    filePath,
+                    range: parseResults
+                        ? (0, positionUtils_1.convertTextRangeToRange)(parseResults.parseTree, parseResults.tokenizerOutput.lines)
+                        : (0, textRange_1.getEmptyRange)(),
+                    replacementText: newText,
+                });
+                return edits;
+            }
+            function _tryGetTextAfterImportsAdded(cloned, filePath, importData, insertionPoint, token) {
+                const sourceFile = cloned.getBoundSourceFile(filePath);
+                const parseResults = sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.getParseResults();
+                if (!parseResults) {
+                    return undefined;
+                }
+                const insertAddEdits = importAdder.applyImports(importData, filePath, parseResults, insertionPoint, options.importFormat, token);
+                return (0, workspaceEditUtils_1.applyTextEditsToString)(insertAddEdits, parseResults.tokenizerOutput.lines, sourceFile.getFileContent());
+            }
+            function _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, importData, attempt, token) {
+                var _a;
+                (0, cancellationUtils_1.throwIfCancellationRequested)(token);
+                cloned.analyzeFile(filePath, token);
+                const sourceFile = cloned.getBoundSourceFile(filePath);
+                const parseResults = sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.getParseResults();
+                if (!parseResults) {
+                    return undefined;
+                }
+                const tracker = new textEditTracker_1.TextEditTracker();
+                for (const diagnostic of cloned
+                    .getDiagnosticsForRange(filePath, (0, positionUtils_1.convertTextRangeToRange)(parseResults.parseTree, parseResults.tokenizerOutput.lines))
+                    .filter((d) => {
+                    var _a;
+                    return d.category === 3 /* UnusedCode */ &&
+                        ((_a = d.getActions()) === null || _a === void 0 ? void 0 : _a.some((a) => a.action === "pyright.unusedImport" /* unusedImport */));
+                })) {
+                    const nameNode = (0, parseTreeUtils_1.findNodeByPosition)(parseResults.parseTree, diagnostic.range.start, parseResults.tokenizerOutput.lines);
+                    if ((nameNode === null || nameNode === void 0 ? void 0 : nameNode.nodeType) !== 38 /* Name */) {
+                        continue;
+                    }
+                    // decl is synthesized. there is no node associated with the decl.
+                    // ex) import a or import a.b
+                    const dottedName1 = ((_a = nameNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 37 /* ModuleName */ ? nameNode.parent.nameParts : [nameNode];
+                    for (const [decl, names] of importData.declarations) {
+                        if (decl.node) {
+                            if (textRange_1.TextRange.containsRange(decl.node, nameNode)) {
+                                tracker.removeNodes({ node: nameNode, parseResults: parseResults });
+                                break;
+                            }
+                        }
+                        const dottedName2 = (0, parseTreeUtils_1.getDottedName)((0, parseTreeUtils_1.getDottedNameWithGivenNodeAsLastName)(names[0]));
+                        if (dottedName2 && (0, collectionUtils_1.arrayEquals)(dottedName1, dottedName2, (e1, e2) => e1.value === e2.value)) {
+                            tracker.removeNodes({ node: nameNode, parseResults: parseResults });
+                            break;
+                        }
+                    }
+                }
+                const oldText = sourceFile.getFileContent();
+                const newText = (0, workspaceEditUtils_1.applyTextEditsToString)(tracker.getEdits(token).filter((v) => v.filePath === filePath), parseResults.tokenizerOutput.lines, oldText);
+                // We will attempt to remove unused imports multiple times since removing 1 unused import
+                // could make another import unused. This is due to how we calculate which import is not used.
+                // ex) import os, os.path, os.path.xxx
+                // `os.path` and `os.path.xxx` will be marked as used due to `import os`.
+                // once `os` is removed `os.path` will be marked as unused and so on.
+                // We will attempt to remove those chained unused imports up to 10 chain.
+                if (attempt > 10 || oldText === newText) {
+                    return newText;
+                }
+                _updateFileContent(cloned, filePath, newText);
+                return _tryGetTextAfterUnusedImportsRemoved(cloned, filePath, importData, attempt + 1, token);
+            }
         });
+        function _updateFileContent(cloned, filePath, text) {
+            var _a, _b;
+            const info = cloned.getSourceFileInfo(filePath);
+            const version = info ? ((_a = info.sourceFile.getClientVersion()) !== null && _a !== void 0 ? _a : 0) + 1 : 0;
+            const chainedFilePath = info ? (_b = info.chainedSourceFile) === null || _b === void 0 ? void 0 : _b.sourceFile.getFilePath() : undefined;
+            const ipythonMode = info ? info.sourceFile.getIPythonMode() : sourceFile_1.IPythonMode.None;
+            const isTracked = info ? info.isTracked : true;
+            const realFilePath = info ? info.sourceFile.getRealFilePath() : filePath;
+            cloned.setFileOpened(filePath, version, [{ text }], {
+                chainedFilePath,
+                ipythonMode,
+                isTracked,
+                realFilePath,
+            });
+        }
         function _getNumberOfBlankLinesToInsert(parseResults, position) {
             // This basically try to add 2 blanks lines before previous line with text.
             if (position.line === 0 && position.character === 0) {
@@ -1489,6 +1607,28 @@ class Program {
             return position.character !== 0 ? linesToAdd + 1 : linesToAdd;
         }
     }
+    clone() {
+        var _a;
+        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);
+        // 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();
+            if (version === undefined) {
+                continue;
+            }
+            program.setFileOpened(fileInfo.sourceFile.getFilePath(), version, [{ text: fileInfo.sourceFile.getOpenFileContents() }], {
+                chainedFilePath: (_a = fileInfo.chainedSourceFile) === null || _a === void 0 ? void 0 : _a.sourceFile.getFilePath(),
+                ipythonMode: fileInfo.sourceFile.getIPythonMode(),
+                isTracked: fileInfo.isTracked,
+                realFilePath: fileInfo.sourceFile.getRealFilePath(),
+            });
+        }
+        return program;
+    }
     canRenameSymbolAtPosition(filePath, position, isDefaultWorkspace, allowModuleRename, token) {
         return this._runEvaluatorWithCancellationToken(token, () => {
             const sourceFileInfo = this.getSourceFileInfo(filePath);
@@ -1681,6 +1821,7 @@ class Program {
         this._createNewEvaluator();
         this._discardCachedParseResults();
         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);
@@ -1911,8 +2052,7 @@ class Program {
                 // Special case for import statement.
                 // ex) import X.Y
                 // SourceFile for X might not be in memory since import `X.Y` only brings in Y
-                stubFileInfo = this._createInterimFileInfo(stubFilePath);
-                this._addToSourceFileListAndMap(stubFileInfo);
+                stubFileInfo = this.addInterimFile(stubFilePath);
             }
             this._addShadowedFile(stubFileInfo, implFilePath);
             return this.getBoundSourceFile(implFilePath);
@@ -1922,8 +2062,7 @@ class Program {
                 // Special case for import statement.
                 // ex) import X.Y
                 // SourceFile for X might not be in memory since import `X.Y` only brings in Y
-                fileInfo = this._createInterimFileInfo(f);
-                this._addToSourceFileListAndMap(fileInfo);
+                fileInfo = this.addInterimFile(f);
                 // Even though this file is not referenced by anything, make sure
                 // we have parse tree for doc string.
                 fileInfo.sourceFile.parse(this._configOptions, this._importResolver);