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

package/dist/analyzer/sourceFile.js

@@ -72,50 +72,58 @@ var IPythonMode;
     // Each cell is its own document.
     IPythonMode[IPythonMode["CellDocs"] = 1] = "CellDocs";
 })(IPythonMode = exports.IPythonMode || (exports.IPythonMode = {}));
-class SourceFile {
-    constructor(fs, filePath, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, console, logTracker, realFilePath, ipythonMode = IPythonMode.None) {
-        // True if the file appears to have been deleted.
-        this._isFileDeleted = false;
+class WriteableData {
+    constructor() {
         // Number that is incremented every time the diagnostics
         // are updated.
-        this._diagnosticVersion = 0;
+        this.diagnosticVersion = 0;
         // Generation count of the file contents. When the contents
         // change, this is incremented.
-        this._fileContentsVersion = 0;
+        this.fileContentsVersion = 0;
         // Length and hash of the file the last time it was read from disk.
-        this._lastFileContentLength = undefined;
-        this._lastFileContentHash = undefined;
+        this.lastFileContentLength = undefined;
+        this.lastFileContentHash = undefined;
         // Version of file contents that have been analyzed.
-        this._analyzedFileContentsVersion = -1;
+        this.analyzedFileContentsVersion = -1;
         // Do we need to walk the parse tree and clean
         // the binder information hanging from it?
-        this._parseTreeNeedsCleaning = false;
+        this.parseTreeNeedsCleaning = false;
         // Reentrancy check for binding.
-        this._isBindingInProgress = false;
+        this.isBindingInProgress = false;
         // Diagnostics generated during different phases of analysis.
-        this._parseDiagnostics = [];
-        this._commentDiagnostics = [];
-        this._bindDiagnostics = [];
-        this._checkerDiagnostics = [];
-        this._typeIgnoreLines = new Map();
-        this._pyrightIgnoreLines = new Map();
-        // Settings that control which diagnostics should be output. The rules
-        // are initialized to the basic set. They should be updated after the
-        // the file is parsed.
-        this._diagnosticRuleSet = (0, configOptions_1.getBasicDiagnosticRuleSet)();
+        this.parseDiagnostics = [];
+        this.commentDiagnostics = [];
+        this.bindDiagnostics = [];
+        this.checkerDiagnostics = [];
+        this.typeIgnoreLines = new Map();
+        this.pyrightIgnoreLines = new Map();
         // Circular dependencies that have been reported in this file.
-        this._circularDependencies = [];
-        this._noCircularDependencyConfirmed = false;
+        this.circularDependencies = [];
+        this.noCircularDependencyConfirmed = false;
         // Do we need to perform a binding step?
-        this._isBindingNeeded = true;
+        this.isBindingNeeded = true;
         // Do we have valid diagnostic results from a checking pass?
-        this._isCheckingNeeded = true;
+        this.isCheckingNeeded = true;
         // Do we need to perform an indexing step?
-        this._indexingNeeded = true;
+        this.indexingNeeded = true;
+        // True if the file appears to have been deleted.
+        this.isFileDeleted = false;
+    }
+}
+class SourceFile {
+    constructor(fs, filePath, moduleName, isThirdPartyImport, isThirdPartyPyTypedPresent, editMode, console, logTracker, realFilePath, ipythonMode = IPythonMode.None) {
+        // Data that changes when the source file changes.
+        this._writableData = new WriteableData();
+        // Settings that control which diagnostics should be output. The rules
+        // are initialized to the basic set. They should be updated after the
+        // the file is parsed.
+        this._diagnosticRuleSet = (0, configOptions_1.getBasicDiagnosticRuleSet)();
         // Indicate whether this file is for ipython or not.
         this._ipythonMode = IPythonMode.None;
+        this._isEditMode = false;
         this.fileSystem = fs;
         this._console = console || new console_1.StandardConsole();
+        this._isEditMode = editMode;
         this._filePath = filePath;
         this._realFilePath = realFilePath !== null && realFilePath !== void 0 ? realFilePath : filePath;
         this._moduleName = moduleName;
@@ -162,7 +170,7 @@ class SourceFile {
         this._moduleName = name;
     }
     getDiagnosticVersion() {
-        return this._diagnosticVersion;
+        return this._writableData.diagnosticVersion;
     }
     isStubFile() {
         return this._isStubFile;
@@ -174,7 +182,7 @@ class SourceFile {
     // If the prevVersion is specified, the method returns undefined if
     // the diagnostics haven't changed.
     getDiagnostics(options, prevDiagnosticVersion) {
-        if (this._diagnosticVersion === prevDiagnosticVersion) {
+        if (this._writableData.diagnosticVersion === prevDiagnosticVersion) {
             return undefined;
         }
         let includeWarningsAndErrors = true;
@@ -184,23 +192,23 @@ class SourceFile {
             includeWarningsAndErrors = false;
         }
         let diagList = [
-            ...this._parseDiagnostics,
-            ...this._commentDiagnostics,
-            ...this._bindDiagnostics,
-            ...this._checkerDiagnostics,
+            ...this._writableData.parseDiagnostics,
+            ...this._writableData.commentDiagnostics,
+            ...this._writableData.bindDiagnostics,
+            ...this._writableData.checkerDiagnostics,
         ];
         const prefilteredDiagList = diagList;
-        const typeIgnoreLinesClone = new Map(this._typeIgnoreLines);
-        const pyrightIgnoreLinesClone = new Map(this._pyrightIgnoreLines);
+        const typeIgnoreLinesClone = new Map(this._writableData.typeIgnoreLines);
+        const pyrightIgnoreLinesClone = new Map(this._writableData.pyrightIgnoreLines);
         // Filter the diagnostics based on "type: ignore" lines.
         if (this._diagnosticRuleSet.enableTypeIgnoreComments) {
-            if (this._typeIgnoreLines.size > 0) {
+            if (this._writableData.typeIgnoreLines.size > 0) {
                 diagList = diagList.filter((d) => {
                     if (d.category !== 3 /* UnusedCode */ &&
                         d.category !== 4 /* UnreachableCode */ &&
                         d.category !== 5 /* Deprecated */) {
                         for (let line = d.range.start.line; line <= d.range.end.line; line++) {
-                            if (this._typeIgnoreLines.has(line)) {
+                            if (this._writableData.typeIgnoreLines.has(line)) {
                                 typeIgnoreLinesClone.delete(line);
                                 return false;
                             }
@@ -211,11 +219,11 @@ class SourceFile {
             }
         }
         // Filter the diagnostics based on "pyright: ignore" lines.
-        if (this._pyrightIgnoreLines.size > 0) {
+        if (this._writableData.pyrightIgnoreLines.size > 0) {
             diagList = diagList.filter((d) => {
                 if (d.category !== 4 /* UnreachableCode */ && d.category !== 5 /* Deprecated */) {
                     for (let line = d.range.start.line; line <= d.range.end.line; line++) {
-                        const pyrightIgnoreComment = this._pyrightIgnoreLines.get(line);
+                        const pyrightIgnoreComment = this._writableData.pyrightIgnoreLines.get(line);
                         if (pyrightIgnoreComment) {
                             if (!pyrightIgnoreComment.rulesList) {
                                 pyrightIgnoreLinesClone.delete(line);
@@ -263,20 +271,20 @@ class SourceFile {
                     diag.range.start.line <= range.start.line &&
                     diag.range.end.line >= range.end.line);
             };
-            if (prefilteredErrorList.length === 0 && this._typeIgnoreAll !== undefined) {
-                const rangeStart = this._typeIgnoreAll.range.start;
-                const rangeEnd = rangeStart + this._typeIgnoreAll.range.length;
-                const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._parseResults.tokenizerOutput.lines);
+            if (prefilteredErrorList.length === 0 && this._writableData.typeIgnoreAll !== undefined) {
+                const rangeStart = this._writableData.typeIgnoreAll.range.start;
+                const rangeEnd = rangeStart + this._writableData.typeIgnoreAll.range.length;
+                const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._writableData.parseResults.tokenizerOutput.lines);
                 if (!isUnreachableCodeRange(range) && this._diagnosticRuleSet.enableTypeIgnoreComments) {
                     unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryTypeIgnore(), range));
                 }
             }
             typeIgnoreLinesClone.forEach((ignoreComment) => {
                 var _a;
-                if ((_a = this._parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput.lines) {
+                if ((_a = this._writableData.parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput.lines) {
                     const rangeStart = ignoreComment.range.start;
                     const rangeEnd = rangeStart + ignoreComment.range.length;
-                    const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._parseResults.tokenizerOutput.lines);
+                    const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._writableData.parseResults.tokenizerOutput.lines);
                     if (!isUnreachableCodeRange(range) && this._diagnosticRuleSet.enableTypeIgnoreComments) {
                         unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryTypeIgnore(), range));
                     }
@@ -284,11 +292,11 @@ class SourceFile {
             });
             pyrightIgnoreLinesClone.forEach((ignoreComment) => {
                 var _a;
-                if ((_a = this._parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput.lines) {
+                if ((_a = this._writableData.parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput.lines) {
                     if (!ignoreComment.rulesList) {
                         const rangeStart = ignoreComment.range.start;
                         const rangeEnd = rangeStart + ignoreComment.range.length;
-                        const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._parseResults.tokenizerOutput.lines);
+                        const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._writableData.parseResults.tokenizerOutput.lines);
                         if (!isUnreachableCodeRange(range)) {
                             unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryPyrightIgnore(), range));
                         }
@@ -297,7 +305,7 @@ class SourceFile {
                         ignoreComment.rulesList.forEach((unusedRule) => {
                             const rangeStart = unusedRule.range.start;
                             const rangeEnd = rangeStart + unusedRule.range.length;
-                            const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._parseResults.tokenizerOutput.lines);
+                            const range = (0, positionUtils_1.convertOffsetsToRange)(rangeStart, rangeEnd, this._writableData.parseResults.tokenizerOutput.lines);
                             if (!isUnreachableCodeRange(range)) {
                                 unnecessaryTypeIgnoreDiags.push(new diagnostic_1.Diagnostic(diagCategory, localize_1.Localizer.Diagnostic.unnecessaryPyrightIgnoreRule().format({
                                     name: unusedRule.text,
@@ -308,9 +316,10 @@ class SourceFile {
                 }
             });
         }
-        if (this._diagnosticRuleSet.reportImportCycles !== 'none' && this._circularDependencies.length > 0) {
+        if (this._diagnosticRuleSet.reportImportCycles !== 'none' &&
+            this._writableData.circularDependencies.length > 0) {
             const category = (0, diagnostic_1.convertLevelToCategory)(this._diagnosticRuleSet.reportImportCycles);
-            this._circularDependencies.forEach((cirDep) => {
+            this._writableData.circularDependencies.forEach((cirDep) => {
                 const diag = new diagnostic_1.Diagnostic(category, localize_1.Localizer.Diagnostic.importCycleDetected() +
                     '\n' +
                     cirDep
@@ -321,8 +330,8 @@ class SourceFile {
                 diagList.push(diag);
             });
         }
-        if (this._hitMaxImportDepth !== undefined) {
-            diagList.push(new diagnostic_1.Diagnostic(0 /* Error */, localize_1.Localizer.Diagnostic.importDepthExceeded().format({ depth: this._hitMaxImportDepth }), (0, textRange_1.getEmptyRange)()));
+        if (this._writableData.hitMaxImportDepth !== undefined) {
+            diagList.push(new diagnostic_1.Diagnostic(0 /* Error */, localize_1.Localizer.Diagnostic.importDepthExceeded().format({ depth: this._writableData.hitMaxImportDepth }), (0, textRange_1.getEmptyRange)()));
         }
         // add diagnostics for comments that match the task list tokens
         this._addTaskListDiagnostics(options.taskListTokens, diagList);
@@ -333,7 +342,7 @@ class SourceFile {
         // If there is a "type: ignore" comment at the top of the file, clear
         // the diagnostic list of all error, warning, and information diagnostics.
         if (this._diagnosticRuleSet.enableTypeIgnoreComments) {
-            if (this._typeIgnoreAll !== undefined) {
+            if (this._writableData.typeIgnoreAll !== undefined) {
                 diagList = diagList.filter((diag) => diag.category !== 0 /* Error */ &&
                     diag.category !== 1 /* Warning */ &&
                     diag.category !== 2 /* Information */);
@@ -352,19 +361,33 @@ class SourceFile {
         return diagList;
     }
     getImports() {
-        return this._imports || [];
+        return this._writableData.imports || [];
     }
     getBuiltinsImport() {
-        return this._builtinsImport;
+        return this._writableData.builtinsImport;
     }
     getIPythonDisplayImport() {
-        return this._ipythonDisplayImport;
+        return this._writableData.ipythonDisplayImport;
     }
     getModuleSymbolTable() {
-        return this._moduleSymbolTable;
+        return this._writableData.moduleSymbolTable;
     }
     getCheckTime() {
-        return this._checkTime;
+        return this._writableData.checkTime;
+    }
+    enterEditMode() {
+        this._isEditMode = true;
+    }
+    exitEditMode() {
+        this._isEditMode = false;
+        // If we had an edit, return our text.
+        if (this._preEditData) {
+            const text = this._writableData.clientDocumentContents;
+            this._writableData = this._preEditData;
+            this._preEditData = undefined;
+            return text;
+        }
+        return undefined;
     }
     // Indicates whether the contents of the file have changed since
     // the last analysis was performed.
@@ -372,11 +395,11 @@ class SourceFile {
         // If this is an open file any content changes will be
         // provided through the editor. We can assume contents
         // didn't change without us knowing about them.
-        if (this._clientDocumentContents) {
+        if (this._writableData.clientDocumentContents) {
             return false;
         }
         // If the file was never read previously, no need to check for a change.
-        if (this._lastFileContentLength === undefined) {
+        if (this._writableData.lastFileContentLength === undefined) {
             return false;
         }
         // Read in the latest file contents and see if the hash matches
@@ -384,10 +407,10 @@ class SourceFile {
         try {
             // Read the file's contents.
             const fileContents = this.fileSystem.readFileSync(this._filePath, 'utf8');
-            if (fileContents.length !== this._lastFileContentLength) {
+            if (fileContents.length !== this._writableData.lastFileContentLength) {
                 return true;
             }
-            if (StringUtils.hashString(fileContents) !== this._lastFileContentHash) {
+            if (StringUtils.hashString(fileContents) !== this._writableData.lastFileContentHash) {
                 return true;
             }
         }
@@ -400,45 +423,45 @@ class SourceFile {
     // in cases where memory is low. When info is needed, the file
     // will be re-parsed and rebound.
     dropParseAndBindInfo() {
-        this._parseResults = undefined;
-        this._moduleSymbolTable = undefined;
-        this._isBindingNeeded = true;
+        this._writableData.parseResults = undefined;
+        this._writableData.moduleSymbolTable = undefined;
+        this._writableData.isBindingNeeded = true;
     }
     markDirty(indexingNeeded = true) {
-        this._fileContentsVersion++;
-        this._noCircularDependencyConfirmed = false;
-        this._isCheckingNeeded = true;
-        this._isBindingNeeded = true;
-        this._indexingNeeded = indexingNeeded;
-        this._moduleSymbolTable = undefined;
-        this._cachedIndexResults = undefined;
+        this._writableData.fileContentsVersion++;
+        this._writableData.noCircularDependencyConfirmed = false;
+        this._writableData.isCheckingNeeded = true;
+        this._writableData.isBindingNeeded = true;
+        this._writableData.indexingNeeded = indexingNeeded;
+        this._writableData.moduleSymbolTable = undefined;
+        this._writableData.cachedIndexResults = undefined;
         const filePath = this.getFilePath();
         extensibility_1.Extensions.getProgramExtensions(filePath).forEach((e) => (e.fileDirty ? e.fileDirty(filePath) : null));
     }
     markReanalysisRequired(forceRebinding) {
         // Keep the parse info, but reset the analysis to the beginning.
-        this._isCheckingNeeded = true;
-        this._noCircularDependencyConfirmed = false;
+        this._writableData.isCheckingNeeded = true;
+        this._writableData.noCircularDependencyConfirmed = false;
         // If the file contains a wildcard import or __all__ symbols,
         // we need to rebind because a dependent import may have changed.
-        if (this._parseResults) {
-            if (this._parseResults.containsWildcardImport ||
-                AnalyzerNodeInfo.getDunderAllInfo(this._parseResults.parseTree) !== undefined ||
+        if (this._writableData.parseResults) {
+            if (this._writableData.parseResults.containsWildcardImport ||
+                AnalyzerNodeInfo.getDunderAllInfo(this._writableData.parseResults.parseTree) !== undefined ||
                 forceRebinding) {
                 // We don't need to rebuild index data since wildcard
                 // won't affect user file indices. User file indices
                 // don't contain import alias info.
-                this._parseTreeNeedsCleaning = true;
-                this._isBindingNeeded = true;
-                this._moduleSymbolTable = undefined;
+                this._writableData.parseTreeNeedsCleaning = true;
+                this._writableData.isBindingNeeded = true;
+                this._writableData.moduleSymbolTable = undefined;
             }
         }
     }
     getClientVersion() {
-        return this._clientDocumentVersion;
+        return this._writableData.clientDocumentVersion;
     }
     getOpenFileContents() {
-        return this._clientDocumentContents;
+        return this._writableData.clientDocumentContents;
     }
     getFileContent() {
         // Get current buffer content if the file is opened.
@@ -462,82 +485,86 @@ class SourceFile {
         }
     }
     setClientVersion(version, contents) {
+        // Save pre edit state if in edit mode.
+        this._cachePreEditState();
         if (version === null) {
-            this._clientDocumentVersion = undefined;
-            this._clientDocumentContents = undefined;
+            this._writableData.clientDocumentVersion = undefined;
+            this._writableData.clientDocumentContents = undefined;
         }
         else {
-            this._clientDocumentVersion = version;
-            this._clientDocumentContents = contents;
+            this._writableData.clientDocumentVersion = version;
+            this._writableData.clientDocumentContents = contents;
             const contentsHash = StringUtils.hashString(contents);
             // Have the contents of the file changed?
-            if (contents.length !== this._lastFileContentLength || contentsHash !== this._lastFileContentHash) {
+            if (contents.length !== this._writableData.lastFileContentLength ||
+                contentsHash !== this._writableData.lastFileContentHash) {
                 this.markDirty();
             }
-            this._lastFileContentLength = contents.length;
-            this._lastFileContentHash = contentsHash;
-            this._isFileDeleted = false;
+            this._writableData.lastFileContentLength = contents.length;
+            this._writableData.lastFileContentHash = contentsHash;
+            this._writableData.isFileDeleted = false;
         }
     }
     prepareForClose() {
         // Nothing to do currently.
     }
     isFileDeleted() {
-        return this._isFileDeleted;
+        return this._writableData.isFileDeleted;
     }
     isParseRequired() {
-        return !this._parseResults || this._analyzedFileContentsVersion !== this._fileContentsVersion;
+        return (!this._writableData.parseResults ||
+            this._writableData.analyzedFileContentsVersion !== this._writableData.fileContentsVersion);
     }
     isBindingRequired() {
-        if (this._isBindingInProgress) {
+        if (this._writableData.isBindingInProgress) {
             return false;
         }
         if (this.isParseRequired()) {
             return true;
         }
-        return this._isBindingNeeded;
+        return this._writableData.isBindingNeeded;
     }
     isIndexingRequired() {
-        return this._indexingNeeded;
+        return this._writableData.indexingNeeded;
     }
     isCheckingRequired() {
-        return this._isCheckingNeeded;
+        return this._writableData.isCheckingNeeded;
     }
     getParseResults() {
         if (!this.isParseRequired()) {
-            return this._parseResults;
+            return this._writableData.parseResults;
         }
         return undefined;
     }
     getCachedIndexResults() {
-        return this._cachedIndexResults;
+        return this._writableData.cachedIndexResults;
     }
     cacheIndexResults(indexResults) {
-        this._cachedIndexResults = indexResults;
+        this._writableData.cachedIndexResults = indexResults;
     }
     // Adds a new circular dependency for this file but only if
     // it hasn't already been added.
     addCircularDependency(circDependency) {
         let updatedDependencyList = false;
         // Some topologies can result in a massive number of cycles. We'll cut it off.
-        if (this._circularDependencies.length < _maxImportCyclesPerFile) {
-            if (!this._circularDependencies.some((dep) => dep.isEqual(circDependency))) {
-                this._circularDependencies.push(circDependency);
+        if (this._writableData.circularDependencies.length < _maxImportCyclesPerFile) {
+            if (!this._writableData.circularDependencies.some((dep) => dep.isEqual(circDependency))) {
+                this._writableData.circularDependencies.push(circDependency);
                 updatedDependencyList = true;
             }
         }
         if (updatedDependencyList) {
-            this._diagnosticVersion++;
+            this._writableData.diagnosticVersion++;
         }
     }
     setNoCircularDependencyConfirmed() {
-        this._noCircularDependencyConfirmed = true;
+        this._writableData.noCircularDependencyConfirmed = true;
     }
     isNoCircularDependencyConfirmed() {
-        return !this.isParseRequired() && this._noCircularDependencyConfirmed;
+        return !this.isParseRequired() && this._writableData.noCircularDependencyConfirmed;
     }
     setHitMaxImportDepth(maxImportDepth) {
-        this._hitMaxImportDepth = maxImportDepth;
+        this._writableData.hitMaxImportDepth = maxImportDepth;
     }
     // Parse the file and update the state. Callers should wait for completion
     // (or at least cancel) prior to calling again. It returns true if a parse
@@ -561,8 +588,8 @@ class SourceFile {
                             throw new Error("Can't get file content");
                         }
                         // Remember the length and hash for comparison purposes.
-                        this._lastFileContentLength = fileContents.length;
-                        this._lastFileContentHash = StringUtils.hashString(fileContents);
+                        this._writableData.lastFileContentLength = fileContents.length;
+                        this._writableData.lastFileContentHash = StringUtils.hashString(fileContents);
                     });
                     logState.add(`fs read ${timing_1.timingStats.readFileTime.totalTime - startTime}ms`);
                 }
@@ -570,7 +597,7 @@ class SourceFile {
                     diagSink.addError(`Source file could not be read`, (0, textRange_1.getEmptyRange)());
                     fileContents = '';
                     if (!this.fileSystem.existsSync(this._realFilePath)) {
-                        this._isFileDeleted = true;
+                        this._writableData.isFileDeleted = true;
                     }
                 }
             }
@@ -578,27 +605,28 @@ class SourceFile {
                 // Parse the token stream, building the abstract syntax tree.
                 const parseResults = parseFile(configOptions, this._filePath, fileContents, this._ipythonMode, diagSink);
                 (0, debug_1.assert)(parseResults !== undefined && parseResults.tokenizerOutput !== undefined);
-                this._parseResults = parseResults;
-                this._typeIgnoreLines = this._parseResults.tokenizerOutput.typeIgnoreLines;
-                this._typeIgnoreAll = this._parseResults.tokenizerOutput.typeIgnoreAll;
-                this._pyrightIgnoreLines = this._parseResults.tokenizerOutput.pyrightIgnoreLines;
+                this._writableData.parseResults = parseResults;
+                this._writableData.typeIgnoreLines = this._writableData.parseResults.tokenizerOutput.typeIgnoreLines;
+                this._writableData.typeIgnoreAll = this._writableData.parseResults.tokenizerOutput.typeIgnoreAll;
+                this._writableData.pyrightIgnoreLines =
+                    this._writableData.parseResults.tokenizerOutput.pyrightIgnoreLines;
                 // Resolve imports.
                 const execEnvironment = configOptions.findExecEnvironment(this._filePath);
                 timing_1.timingStats.resolveImportsTime.timeOperation(() => {
                     const importResult = this._resolveImports(importResolver, parseResults.importedModules, execEnvironment);
-                    this._imports = importResult.imports;
-                    this._builtinsImport = importResult.builtinsImportResult;
-                    this._ipythonDisplayImport = importResult.ipythonDisplayImportResult;
-                    this._parseDiagnostics = diagSink.fetchAndClear();
+                    this._writableData.imports = importResult.imports;
+                    this._writableData.builtinsImport = importResult.builtinsImportResult;
+                    this._writableData.ipythonDisplayImport = importResult.ipythonDisplayImportResult;
+                    this._writableData.parseDiagnostics = diagSink.fetchAndClear();
                 });
                 // Is this file in a "strict" path?
                 const useStrict = configOptions.strict.find((strictFileSpec) => strictFileSpec.regExp.test(this._realFilePath)) !==
                     undefined;
                 const commentDiags = [];
-                this._diagnosticRuleSet = CommentUtils.getFileLevelDirectives(this._parseResults.tokenizerOutput.tokens, this._parseResults.tokenizerOutput.lines, configOptions.diagnosticRuleSet, useStrict, commentDiags);
-                this._commentDiagnostics = [];
+                this._diagnosticRuleSet = CommentUtils.getFileLevelDirectives(this._writableData.parseResults.tokenizerOutput.tokens, this._writableData.parseResults.tokenizerOutput.lines, configOptions.diagnosticRuleSet, useStrict, commentDiags);
+                this._writableData.commentDiagnostics = [];
                 commentDiags.forEach((commentDiag) => {
-                    this._commentDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, commentDiag.message, (0, positionUtils_1.convertTextRangeToRange)(commentDiag.range, this._parseResults.tokenizerOutput.lines)));
+                    this._writableData.commentDiagnostics.push(new diagnostic_1.Diagnostic(0 /* Error */, commentDiag.message, (0, positionUtils_1.convertTextRangeToRange)(commentDiag.range, this._writableData.parseResults.tokenizerOutput.lines)));
                 });
             }
             catch (e) {
@@ -607,7 +635,7 @@ class SourceFile {
                     JSON.stringify(e);
                 this._console.error(localize_1.Localizer.Diagnostic.internalParseError().format({ file: this.getFilePath(), message }));
                 // Create dummy parse results.
-                this._parseResults = {
+                this._writableData.parseResults = {
                     text: '',
                     parseTree: parseNodes_1.ModuleNode.create({ start: 0, length: 0 }),
                     importedModules: [],
@@ -625,34 +653,34 @@ class SourceFile {
                     containsWildcardImport: false,
                     typingSymbolAliases: new Map(),
                 };
-                this._imports = undefined;
-                this._builtinsImport = undefined;
-                this._ipythonDisplayImport = undefined;
+                this._writableData.imports = undefined;
+                this._writableData.builtinsImport = undefined;
+                this._writableData.ipythonDisplayImport = undefined;
                 const diagSink = new diagnosticSink_1.DiagnosticSink();
                 diagSink.addError(localize_1.Localizer.Diagnostic.internalParseError().format({ file: this.getFilePath(), message }), (0, textRange_1.getEmptyRange)());
-                this._parseDiagnostics = diagSink.fetchAndClear();
+                this._writableData.parseDiagnostics = diagSink.fetchAndClear();
                 // Do not rethrow the exception, swallow it here. Callers are not
                 // prepared to handle an exception.
             }
-            this._analyzedFileContentsVersion = this._fileContentsVersion;
-            this._indexingNeeded = true;
-            this._isBindingNeeded = true;
-            this._isCheckingNeeded = true;
-            this._parseTreeNeedsCleaning = false;
-            this._hitMaxImportDepth = undefined;
-            this._diagnosticVersion++;
+            this._writableData.analyzedFileContentsVersion = this._writableData.fileContentsVersion;
+            this._writableData.indexingNeeded = true;
+            this._writableData.isBindingNeeded = true;
+            this._writableData.isCheckingNeeded = true;
+            this._writableData.parseTreeNeedsCleaning = false;
+            this._writableData.hitMaxImportDepth = undefined;
+            this._writableData.diagnosticVersion++;
             return true;
         });
     }
     index(options, token) {
         return this._logTracker.log(`indexing: ${this._getPathForLogging(this._filePath)}`, (ls) => {
             // If we have no completed analysis job, there's nothing to do.
-            if (!this._parseResults || !this.isIndexingRequired()) {
+            if (!this._writableData.parseResults || !this.isIndexingRequired()) {
                 ls.suppress();
                 return undefined;
             }
-            this._indexingNeeded = false;
-            const symbols = documentSymbolProvider_1.DocumentSymbolProvider.indexSymbols(AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree), this._parseResults, options, token);
+            this._writableData.indexingNeeded = false;
+            const symbols = documentSymbolProvider_1.DocumentSymbolProvider.indexSymbols(AnalyzerNodeInfo.getFileInfo(this._writableData.parseResults.parseTree), this._writableData.parseResults, options, token);
             ls.add(`found ${symbols.length}`);
             const name = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(this._filePath));
             const privateOrProtected = SymbolNameUtils.isPrivateOrProtectedName(name);
@@ -661,21 +689,25 @@ class SourceFile {
     }
     addHierarchicalSymbolsForDocument(symbolList, token) {
         // If we have no completed analysis job, there's nothing to do.
-        if (!this._parseResults && !this._cachedIndexResults) {
+        if (!this._writableData.parseResults && !this._writableData.cachedIndexResults) {
             return;
         }
-        documentSymbolProvider_1.DocumentSymbolProvider.addHierarchicalSymbolsForDocument(this._parseResults ? AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree) : undefined, this.getCachedIndexResults(), this._parseResults, symbolList, token);
+        documentSymbolProvider_1.DocumentSymbolProvider.addHierarchicalSymbolsForDocument(this._writableData.parseResults
+            ? AnalyzerNodeInfo.getFileInfo(this._writableData.parseResults.parseTree)
+            : undefined, this.getCachedIndexResults(), this._writableData.parseResults, symbolList, token);
     }
     getSymbolsForDocument(query, token) {
         // If we have no completed analysis job, there's nothing to do.
-        if (!this._parseResults && !this._cachedIndexResults) {
+        if (!this._writableData.parseResults && !this._writableData.cachedIndexResults) {
             return [];
         }
-        return documentSymbolProvider_1.DocumentSymbolProvider.getSymbolsForDocument(this._parseResults ? AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree) : undefined, this.getCachedIndexResults(), this._parseResults, this._filePath, query, token);
+        return documentSymbolProvider_1.DocumentSymbolProvider.getSymbolsForDocument(this._writableData.parseResults
+            ? AnalyzerNodeInfo.getFileInfo(this._writableData.parseResults.parseTree)
+            : undefined, this.getCachedIndexResults(), this._writableData.parseResults, this._filePath, query, token);
     }
-    getCompletionsForPosition(position, workspacePath, configOptions, importResolver, importLookup, evaluator, options, sourceMapper, nameMap, libraryMap, moduleSymbolsCallback, token) {
+    getCompletionsForPosition(program, position, workspacePath, importLookup, options, nameMap, libraryMap, moduleSymbolsCallback, token) {
         // If we have no completed analysis job, there's nothing to do.
-        if (!this._parseResults) {
+        if (!this._writableData.parseResults) {
             return undefined;
         }
         // This command should be called only for open files, in which
@@ -684,20 +716,20 @@ class SourceFile {
         if (fileContents === undefined) {
             return undefined;
         }
-        const completionProvider = new completionProvider_1.CompletionProvider(workspacePath, this._parseResults, fileContents, importResolver, position, this._filePath, configOptions, importLookup, evaluator, options, sourceMapper, {
+        const completionProvider = new completionProvider_1.CompletionProvider(program, workspacePath, this._filePath, position, importLookup, options, {
             nameMap,
             libraryMap,
             getModuleSymbolsMap: moduleSymbolsCallback,
         }, token);
         return completionProvider.getCompletionsForPosition();
     }
-    resolveCompletionItem(configOptions, importResolver, importLookup, evaluator, options, sourceMapper, nameMap, libraryMap, moduleSymbolsCallback, completionItem, token) {
+    resolveCompletionItem(program, importLookup, options, nameMap, libraryMap, moduleSymbolsCallback, completionItem, token) {
         const fileContents = this.getOpenFileContents();
-        if (!this._parseResults || fileContents === undefined) {
+        if (!this._writableData.parseResults || fileContents === undefined) {
             return;
         }
         const completionData = (0, lspUtils_1.fromLSPAny)(completionItem.data);
-        const completionProvider = new completionProvider_1.CompletionProvider(completionData.workspacePath, this._parseResults, fileContents, importResolver, completionData.position, this._filePath, configOptions, importLookup, evaluator, options, sourceMapper, {
+        const completionProvider = new completionProvider_1.CompletionProvider(program, completionData.workspacePath, this._filePath, completionData.position, importLookup, options, {
             nameMap,
             libraryMap,
             getModuleSymbolsMap: moduleSymbolsCallback,
@@ -707,28 +739,28 @@ class SourceFile {
     bind(configOptions, importLookup, builtinsScope, futureImports) {
         (0, debug_1.assert)(!this.isParseRequired(), 'Bind called before parsing');
         (0, debug_1.assert)(this.isBindingRequired(), 'Bind called unnecessarily');
-        (0, debug_1.assert)(!this._isBindingInProgress, 'Bind called while binding in progress');
-        (0, debug_1.assert)(this._parseResults !== undefined, 'Parse results not available');
+        (0, debug_1.assert)(!this._writableData.isBindingInProgress, 'Bind called while binding in progress');
+        (0, debug_1.assert)(this._writableData.parseResults !== undefined, 'Parse results not available');
         return this._logTracker.log(`binding: ${this._getPathForLogging(this._filePath)}`, () => {
             try {
                 // Perform name binding.
                 timing_1.timingStats.bindTime.timeOperation(() => {
                     this._cleanParseTreeIfRequired();
-                    const fileInfo = this._buildFileInfo(configOptions, this._parseResults.text, importLookup, builtinsScope, futureImports);
-                    AnalyzerNodeInfo.setFileInfo(this._parseResults.parseTree, fileInfo);
+                    const fileInfo = this._buildFileInfo(configOptions, this._writableData.parseResults.text, importLookup, builtinsScope, futureImports);
+                    AnalyzerNodeInfo.setFileInfo(this._writableData.parseResults.parseTree, fileInfo);
                     const binder = new binder_1.Binder(fileInfo, configOptions.indexGenerationMode);
-                    this._isBindingInProgress = true;
-                    binder.bindModule(this._parseResults.parseTree);
+                    this._writableData.isBindingInProgress = true;
+                    binder.bindModule(this._writableData.parseResults.parseTree);
                     // If we're in "test mode" (used for unit testing), run an additional
                     // "test walker" over the parse tree to validate its internal consistency.
                     if (configOptions.internalTestMode) {
                         const testWalker = new testWalker_1.TestWalker();
-                        testWalker.walk(this._parseResults.parseTree);
+                        testWalker.walk(this._writableData.parseResults.parseTree);
                     }
-                    this._bindDiagnostics = fileInfo.diagnosticSink.fetchAndClear();
-                    const moduleScope = AnalyzerNodeInfo.getScope(this._parseResults.parseTree);
+                    this._writableData.bindDiagnostics = fileInfo.diagnosticSink.fetchAndClear();
+                    const moduleScope = AnalyzerNodeInfo.getScope(this._writableData.parseResults.parseTree);
                     (0, debug_1.assert)(moduleScope !== undefined, 'Module scope not returned by binder');
-                    this._moduleSymbolTable = moduleScope.symbolTable;
+                    this._writableData.moduleSymbolTable = moduleScope.symbolTable;
                 });
             }
             catch (e) {
@@ -738,36 +770,36 @@ class SourceFile {
                 this._console.error(localize_1.Localizer.Diagnostic.internalBindError().format({ file: this.getFilePath(), message }));
                 const diagSink = new diagnosticSink_1.DiagnosticSink();
                 diagSink.addError(localize_1.Localizer.Diagnostic.internalBindError().format({ file: this.getFilePath(), message }), (0, textRange_1.getEmptyRange)());
-                this._bindDiagnostics = diagSink.fetchAndClear();
+                this._writableData.bindDiagnostics = diagSink.fetchAndClear();
                 // Do not rethrow the exception, swallow it here. Callers are not
                 // prepared to handle an exception.
             }
             finally {
-                this._isBindingInProgress = false;
+                this._writableData.isBindingInProgress = false;
             }
             // Prepare for the next stage of the analysis.
-            this._diagnosticVersion++;
-            this._isCheckingNeeded = true;
-            this._indexingNeeded = true;
-            this._isBindingNeeded = false;
+            this._writableData.diagnosticVersion++;
+            this._writableData.isCheckingNeeded = true;
+            this._writableData.indexingNeeded = true;
+            this._writableData.isBindingNeeded = false;
         });
     }
     check(importResolver, evaluator, sourceMapper, dependentFiles) {
         (0, debug_1.assert)(!this.isParseRequired(), 'Check called before parsing');
         (0, debug_1.assert)(!this.isBindingRequired(), 'Check called before binding');
-        (0, debug_1.assert)(!this._isBindingInProgress, 'Check called while binding in progress');
+        (0, debug_1.assert)(!this._writableData.isBindingInProgress, 'Check called while binding in progress');
         (0, debug_1.assert)(this.isCheckingRequired(), 'Check called unnecessarily');
-        (0, debug_1.assert)(this._parseResults !== undefined, 'Parse results not available');
+        (0, debug_1.assert)(this._writableData.parseResults !== undefined, 'Parse results not available');
         return this._logTracker.log(`checking: ${this._getPathForLogging(this._filePath)}`, () => {
             try {
                 timing_1.timingStats.typeCheckerTime.timeOperation(() => {
                     const checkDuration = new timing_1.Duration();
-                    const checker = new checker_1.Checker(importResolver, evaluator, this._parseResults, sourceMapper, dependentFiles);
+                    const checker = new checker_1.Checker(importResolver, evaluator, this._writableData.parseResults, sourceMapper, dependentFiles);
                     checker.check();
-                    this._isCheckingNeeded = false;
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(this._parseResults.parseTree);
-                    this._checkerDiagnostics = fileInfo.diagnosticSink.fetchAndClear();
-                    this._checkTime = checkDuration.getDurationInMilliseconds();
+                    this._writableData.isCheckingNeeded = false;
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(this._writableData.parseResults.parseTree);
+                    this._writableData.checkerDiagnostics = fileInfo.diagnosticSink.fetchAndClear();
+                    this._writableData.checkTime = checkDuration.getDurationInMilliseconds();
                 });
             }
             catch (e) {
@@ -779,9 +811,9 @@ class SourceFile {
                     this._console.error(localize_1.Localizer.Diagnostic.internalTypeCheckingError().format({ file: this.getFilePath(), message }));
                     const diagSink = new diagnosticSink_1.DiagnosticSink();
                     diagSink.addError(localize_1.Localizer.Diagnostic.internalTypeCheckingError().format({ file: this.getFilePath(), message }), (0, textRange_1.getEmptyRange)());
-                    this._checkerDiagnostics = diagSink.fetchAndClear();
+                    this._writableData.checkerDiagnostics = diagSink.fetchAndClear();
                     // Mark the file as complete so we don't get into an infinite loop.
-                    this._isCheckingNeeded = false;
+                    this._writableData.isCheckingNeeded = false;
                 }
                 throw e;
             }
@@ -789,14 +821,26 @@ class SourceFile {
                 // Clear any circular dependencies associated with this file.
                 // These will be detected by the program module and associated
                 // with the source file right before it is finalized.
-                this._circularDependencies = [];
-                this._diagnosticVersion++;
+                this._writableData.circularDependencies = [];
+                this._writableData.diagnosticVersion++;
             }
         });
     }
     test_enableIPythonMode(enable) {
         this._ipythonMode = enable ? IPythonMode.CellDocs : IPythonMode.None;
     }
+    _cachePreEditState() {
+        // If there's no document yet, this change doesn't count as a write yet.
+        if (this._writableData.clientDocumentContents !== undefined) {
+            // If this is our first write, then make a copy of the writable data.
+            if (this._isEditMode && !this._preEditData) {
+                // Copy over the writable data.
+                this._preEditData = this._writableData;
+                // Recreate all the writable data from scratch.
+                this._writableData = new WriteableData();
+            }
+        }
+    }
     // Get all task list diagnostics for the current file and add them
     // to the specified diagnostic list
     _addTaskListDiagnostics(taskListTokens, diagList) {
@@ -806,10 +850,10 @@ class SourceFile {
             return;
         }
         // if we have no tokens, we're done
-        if (!((_b = (_a = this._parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput) === null || _b === void 0 ? void 0 : _b.tokens)) {
+        if (!((_b = (_a = this._writableData.parseResults) === null || _a === void 0 ? void 0 : _a.tokenizerOutput) === null || _b === void 0 ? void 0 : _b.tokens)) {
             return;
         }
-        const tokenizerOutput = this._parseResults.tokenizerOutput;
+        const tokenizerOutput = this._writableData.parseResults.tokenizerOutput;
         for (let i = 0; i < tokenizerOutput.tokens.count; i++) {
             const token = tokenizerOutput.tokens.getItemAt(i);
             // if there are no comments, skip this token
@@ -845,8 +889,8 @@ class SourceFile {
         }
     }
     _buildFileInfo(configOptions, fileContents, importLookup, builtinsScope, futureImports) {
-        (0, debug_1.assert)(this._parseResults !== undefined, 'Parse results not available');
-        const analysisDiagnostics = new diagnosticSink_1.TextRangeDiagnosticSink(this._parseResults.tokenizerOutput.lines);
+        (0, debug_1.assert)(this._writableData.parseResults !== undefined, 'Parse results not available');
+        const analysisDiagnostics = new diagnosticSink_1.TextRangeDiagnosticSink(this._writableData.parseResults.tokenizerOutput.lines);
         const fileInfo = {
             importLookup,
             futureImports,
@@ -855,8 +899,8 @@ class SourceFile {
             executionEnvironment: configOptions.findExecEnvironment(this._filePath),
             diagnosticRuleSet: this._diagnosticRuleSet,
             fileContents,
-            lines: this._parseResults.tokenizerOutput.lines,
-            typingSymbolAliases: this._parseResults.typingSymbolAliases,
+            lines: this._writableData.parseResults.tokenizerOutput.lines,
+            typingSymbolAliases: this._writableData.parseResults.typingSymbolAliases,
             definedConstants: configOptions.defineConstant,
             filePath: this._filePath,
             moduleName: this._moduleName,
@@ -871,11 +915,11 @@ class SourceFile {
         return fileInfo;
     }
     _cleanParseTreeIfRequired() {
-        if (this._parseResults) {
-            if (this._parseTreeNeedsCleaning) {
-                const cleanerWalker = new parseTreeCleaner_1.ParseTreeCleanerWalker(this._parseResults.parseTree);
+        if (this._writableData.parseResults) {
+            if (this._writableData.parseTreeNeedsCleaning) {
+                const cleanerWalker = new parseTreeCleaner_1.ParseTreeCleanerWalker(this._writableData.parseResults.parseTree);
                 cleanerWalker.clean();
-                this._parseTreeNeedsCleaning = false;
+                this._writableData.parseTreeNeedsCleaning = false;
             }
         }
     }