typescript 4.7.0-dev.20220419 → 4.7.0-dev.20220422

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220419";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220422";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -18293,10 +18293,10 @@ var ts;
         return ts.combinePaths(newDirPath, sourceFilePath);
     }
     ts.getSourceFilePathInNewDirWorker = getSourceFilePathInNewDirWorker;
-    function writeFile(host, diagnostics, fileName, data, writeByteOrderMark, sourceFiles) {
-        host.writeFile(fileName, data, writeByteOrderMark, function (hostErrorMessage) {
+    function writeFile(host, diagnostics, fileName, text, writeByteOrderMark, sourceFiles, data) {
+        host.writeFile(fileName, text, writeByteOrderMark, function (hostErrorMessage) {
             diagnostics.add(createCompilerDiagnostic(ts.Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage));
-        }, sourceFiles);
+        }, sourceFiles, data);
     }
     ts.writeFile = writeFile;
     function ensureDirectoriesExist(directoryPath, createDirectory, directoryExists) {
@@ -73432,6 +73432,7 @@ var ts;
                         }
                     }
                     else {
+                        error(attributeDecl.expression, ts.Diagnostics.Spread_types_may_only_be_created_from_object_types);
                         typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
                     }
                 }
@@ -74262,10 +74263,15 @@ var ts;
                 prop = getPropertyOfType(apparentType, right.escapedText);
             }
             // In `Foo.Bar.Baz`, 'Foo' is not referenced if 'Bar' is a const enum or a module containing only const enums.
+            // `Foo` is also not referenced in `enum FooCopy { Bar = Foo.Bar }`, because the enum member value gets inlined
+            // here even if `Foo` is not a const enum.
+            //
             // The exceptions are:
             //   1. if 'isolatedModules' is enabled, because the const enum value will not be inlined, and
             //   2. if 'preserveConstEnums' is enabled and the expression is itself an export, e.g. `export = Foo.Bar.Baz`.
-            if (ts.isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules || !(prop && isConstEnumOrConstEnumOnlyModule(prop)) || ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
+            if (ts.isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules ||
+                !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && node.parent.kind === 299 /* EnumMember */)) ||
+                ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
                 markAliasReferenced(parentSymbol, node);
             }
             var propType;
@@ -86000,15 +86006,20 @@ var ts;
                         return propertyDeclaration;
                     }
                 }
-                else if (ts.isMetaProperty(parent)) {
-                    var parentType = getTypeOfNode(parent);
-                    var propertyDeclaration = getPropertyOfType(parentType, node.escapedText);
-                    if (propertyDeclaration) {
-                        return propertyDeclaration;
-                    }
-                    if (parent.keywordToken === 103 /* NewKeyword */) {
+                else if (ts.isMetaProperty(parent) && parent.name === node) {
+                    if (parent.keywordToken === 103 /* NewKeyword */ && ts.idText(node) === "target") {
+                        // `target` in `new.target`
                         return checkNewTargetMetaProperty(parent).symbol;
                     }
+                    // The `meta` in `import.meta` could be given `getTypeOfNode(parent).symbol` (the `ImportMeta` interface symbol), but
+                    // we have a fake expression type made for other reasons already, whose transient `meta`
+                    // member should more exactly be the kind of (declarationless) symbol we want.
+                    // (See #44364 and #45031 for relevant implementation PRs)
+                    if (parent.keywordToken === 100 /* ImportKeyword */ && ts.idText(node) === "meta") {
+                        return getGlobalImportMetaExpressionType().members.get("meta");
+                    }
+                    // no other meta properties are valid syntax, thus no others should have symbols
+                    return undefined;
                 }
             }
             switch (node.kind) {
@@ -94686,7 +94697,7 @@ var ts;
             }
             resumeLexicalEnvironment();
             var needsSyntheticConstructor = !constructor && isDerivedClass;
-            var indexOfFirstStatementAfterSuper = 0;
+            var indexOfFirstStatementAfterSuperAndPrologue = 0;
             var prologueStatementCount = 0;
             var superStatementIndex = -1;
             var statements = [];
@@ -94695,8 +94706,11 @@ var ts;
                 superStatementIndex = ts.findSuperStatementIndex(constructor.body.statements, prologueStatementCount);
                 // If there was a super call, visit existing statements up to and including it
                 if (superStatementIndex >= 0) {
-                    indexOfFirstStatementAfterSuper = superStatementIndex + 1;
-                    statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, prologueStatementCount, indexOfFirstStatementAfterSuper - prologueStatementCount), true), statements.slice(prologueStatementCount), true);
+                    indexOfFirstStatementAfterSuperAndPrologue = superStatementIndex + 1;
+                    statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, prologueStatementCount, indexOfFirstStatementAfterSuperAndPrologue - prologueStatementCount), true), statements.slice(prologueStatementCount), true);
+                }
+                else if (prologueStatementCount >= 0) {
+                    indexOfFirstStatementAfterSuperAndPrologue = prologueStatementCount;
                 }
             }
             if (needsSyntheticConstructor) {
@@ -94732,22 +94746,20 @@ var ts;
                         }
                     }
                     if (parameterPropertyDeclarationCount > 0) {
-                        var parameterProperties = ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatementAfterSuper, parameterPropertyDeclarationCount);
+                        var parameterProperties = ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatementAfterSuperAndPrologue, parameterPropertyDeclarationCount);
                         // If there was a super() call found, add parameter properties immediately after it
                         if (superStatementIndex >= 0) {
                             ts.addRange(statements, parameterProperties);
                         }
-                        // If a synthetic super() call was added, add them just after it
-                        else if (needsSyntheticConstructor) {
-                            statements = __spreadArray(__spreadArray([
-                                statements[0]
-                            ], parameterProperties, true), statements.slice(1), true);
-                        }
-                        // Since there wasn't a super() call, add them to the top of the constructor
                         else {
-                            statements = __spreadArray(__spreadArray([], parameterProperties, true), statements, true);
+                            // Add add parameter properties to the top of the constructor after the prologue
+                            var superAndPrologueStatementCount = prologueStatementCount;
+                            // If a synthetic super() call was added, need to account for that
+                            if (needsSyntheticConstructor)
+                                superAndPrologueStatementCount++;
+                            statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, superAndPrologueStatementCount), true), parameterProperties, true), statements.slice(superAndPrologueStatementCount), true);
                         }
-                        indexOfFirstStatementAfterSuper += parameterPropertyDeclarationCount;
+                        indexOfFirstStatementAfterSuperAndPrologue += parameterPropertyDeclarationCount;
                     }
                 }
             }
@@ -94757,7 +94769,7 @@ var ts;
             addPropertyOrClassStaticBlockStatements(statements, properties, receiver);
             // Add existing statements after the initial prologues and super call
             if (constructor) {
-                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitBodyStatement, ts.isStatement, indexOfFirstStatementAfterSuper + prologueStatementCount));
+                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitBodyStatement, ts.isStatement, indexOfFirstStatementAfterSuperAndPrologue));
             }
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             return ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), 
@@ -98798,7 +98810,7 @@ var ts;
                 // ```
                 insertCaptureThisForNodeIfNeeded(prologue, constructor);
             }
-            var body = factory.createBlock(ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], existingPrologue, true), prologue, true), (superStatementIndex <= existingPrologue.length ? ts.emptyArray : ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, existingPrologue.length, superStatementIndex)), true), statements, true)), 
+            var body = factory.createBlock(ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], existingPrologue, true), prologue, true), (superStatementIndex <= existingPrologue.length ? ts.emptyArray : ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, existingPrologue.length, superStatementIndex - existingPrologue.length)), true), statements, true)), 
             /*location*/ constructor.body.statements), 
             /*multiLine*/ true);
             ts.setTextRange(body, constructor.body);
@@ -109955,6 +109967,7 @@ var ts;
             else {
                 printer.writeFile(sourceFile, writer, sourceMapGenerator);
             }
+            var sourceMapUrlPos;
             if (sourceMapGenerator) {
                 if (sourceMapDataList) {
                     sourceMapDataList.push({
@@ -109966,6 +109979,7 @@ var ts;
                 if (sourceMappingURL) {
                     if (!writer.isAtStartOfLine())
                         writer.rawWrite(newLine);
+                    sourceMapUrlPos = writer.getTextPos();
                     writer.writeComment("//# " + "sourceMappingURL" + "=" + sourceMappingURL); // Tools can sometimes see this line as a source mapping url comment
                 }
                 // Write the source map
@@ -109978,7 +109992,7 @@ var ts;
                 writer.writeLine();
             }
             // Write the output file
-            ts.writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles);
+            ts.writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos });
             // Reset state
             writer.clear();
         }
@@ -115445,7 +115459,11 @@ var ts;
             return newValue;
         };
         if (originalWriteFile) {
-            host.writeFile = function (fileName, data, writeByteOrderMark, onError, sourceFiles) {
+            host.writeFile = function (fileName, data) {
+                var rest = [];
+                for (var _i = 2; _i < arguments.length; _i++) {
+                    rest[_i - 2] = arguments[_i];
+                }
                 var key = toPath(fileName);
                 fileExistsCache.delete(key);
                 var value = readFileCache.get(key);
@@ -115459,7 +115477,7 @@ var ts;
                         sourceFileCache.delete(key);
                     }
                 }
-                originalWriteFile.call(host, fileName, data, writeByteOrderMark, onError, sourceFiles);
+                originalWriteFile.call.apply(originalWriteFile, __spreadArray([host, fileName, data], rest, false));
             };
         }
         // directoryExists
@@ -116392,6 +116410,7 @@ var ts;
             useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); },
             getFileIncludeReasons: function () { return fileReasons; },
             structureIsReused: structureIsReused,
+            writeFile: writeFile,
         };
         onProgramCreateComplete();
         // Add file processingDiagnostics
@@ -116889,7 +116908,7 @@ var ts;
                 getProjectReferenceRedirect: getProjectReferenceRedirect,
                 isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect,
                 getSymlinkCache: getSymlinkCache,
-                writeFile: writeFileCallback || (function (fileName, data, writeByteOrderMark, onError, sourceFiles) { return host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles); }),
+                writeFile: writeFileCallback || writeFile,
                 isEmitBlocked: isEmitBlocked,
                 readFile: function (f) { return host.readFile(f); },
                 fileExists: function (f) {
@@ -116909,6 +116928,9 @@ var ts;
                 getFileIncludeReasons: program.getFileIncludeReasons,
             };
         }
+        function writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
+            host.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
+        }
         function emitBuildInfo(writeFileCallback) {
             ts.Debug.assert(!ts.outFile(options));
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitBuildInfo", {}, /*separateBeginAndEnd*/ true);
@@ -119351,6 +119373,7 @@ var ts;
                 }
             }
         }
+        BuilderState.updateExportedModules = updateExportedModules;
         /**
          * Updates the exported modules from cache into state's exported modules map
          * This should be called whenever it is safe to commit the state of the builder
@@ -119774,6 +119797,18 @@ var ts;
         }
         return undefined;
     }
+    function removeDiagnosticsOfLibraryFiles(state) {
+        if (!state.cleanedDiagnosticsOfLibFiles) {
+            state.cleanedDiagnosticsOfLibFiles = true;
+            var program_1 = ts.Debug.checkDefined(state.program);
+            var options_2 = program_1.getCompilerOptions();
+            ts.forEach(program_1.getSourceFiles(), function (f) {
+                return program_1.isSourceFileDefaultLibrary(f) &&
+                    !ts.skipTypeChecking(f, options_2, program_1) &&
+                    removeSemanticDiagnosticsOf(state, f.resolvedPath);
+            });
+        }
+    }
     /**
      *  Handles semantic diagnostics and dts emit for affectedFile and files, that are referencing modules that export entities from affected file
      *  This is because even though js emit doesnt change, dts emit / type used can change resulting in need for dts emit and js change
@@ -119783,28 +119818,17 @@ var ts;
         removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
         // If affected files is everything except default library, then nothing more to do
         if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
-            if (!state.cleanedDiagnosticsOfLibFiles) {
-                state.cleanedDiagnosticsOfLibFiles = true;
-                var program_1 = ts.Debug.checkDefined(state.program);
-                var options_2 = program_1.getCompilerOptions();
-                ts.forEach(program_1.getSourceFiles(), function (f) {
-                    return program_1.isSourceFileDefaultLibrary(f) &&
-                        !ts.skipTypeChecking(f, options_2, program_1) &&
-                        removeSemanticDiagnosticsOf(state, f.resolvedPath);
-                });
-            }
+            removeDiagnosticsOfLibraryFiles(state);
             // When a change affects the global scope, all files are considered to be affected without updating their signature
             // That means when affected file is handled, its signature can be out of date
             // To avoid this, ensure that we update the signature for any affected file in this scenario.
             ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, ts.Debug.checkDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap);
             return;
         }
-        else {
-            ts.Debug.assert(state.hasCalledUpdateShapeSignature.has(affectedFile.resolvedPath) || ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.has(affectedFile.resolvedPath)), "Signature not updated for affected file: " + affectedFile.fileName);
-        }
-        if (!state.compilerOptions.assumeChangesOnlyAffectDirectDependencies) {
-            forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, function (state, path) { return handleDtsMayChangeOf(state, path, cancellationToken, computeHash, host); });
-        }
+        ts.Debug.assert(state.hasCalledUpdateShapeSignature.has(affectedFile.resolvedPath) || ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.has(affectedFile.resolvedPath)), "Signature not updated for affected file: " + affectedFile.fileName);
+        if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
+            return;
+        handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host);
     }
     /**
      * Handle the dts may change, so they need to be added to pending emit if dts emit is enabled,
@@ -119846,16 +119870,41 @@ var ts;
         var oldSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
         return newSignature !== oldSignature;
     }
+    function forEachKeyOfExportedModulesMap(state, filePath, fn) {
+        // Go through exported modules from cache first
+        var keys = state.currentAffectedFilesExportedModulesMap.getKeys(filePath);
+        var result = keys && ts.forEachKey(keys, fn);
+        if (result)
+            return result;
+        // If exported from path is not from cache and exported modules has path, all files referencing file exported from are affected
+        keys = state.exportedModulesMap.getKeys(filePath);
+        return keys && ts.forEachKey(keys, function (exportedFromPath) {
+            var _a;
+            // If the cache had an updated value, skip
+            return !state.currentAffectedFilesExportedModulesMap.hasKey(exportedFromPath) &&
+                !((_a = state.currentAffectedFilesExportedModulesMap.deletedKeys()) === null || _a === void 0 ? void 0 : _a.has(exportedFromPath)) ?
+                fn(exportedFromPath) :
+                undefined;
+        });
+    }
+    function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host) {
+        var _a;
+        if (!((_a = state.fileInfos.get(filePath)) === null || _a === void 0 ? void 0 : _a.affectsGlobalScope))
+            return false;
+        // Every file needs to be handled
+        ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program, /*firstSourceFile*/ undefined)
+            .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, computeHash, host); });
+        removeDiagnosticsOfLibraryFiles(state);
+        return true;
+    }
     /**
-     * Iterate on referencing modules that export entities from affected file
+     * Iterate on referencing modules that export entities from affected file and delete diagnostics and add pending emit
      */
-    function forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, fn) {
-        var _a, _b;
+    function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
         // If there was change in signature (dts output) for the changed file,
         // then only we need to handle pending file emit
-        if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath)) {
+        if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
             return;
-        }
         if (!isChangedSignature(state, affectedFile.resolvedPath))
             return;
         // Since isolated modules dont change js files, files affected by change in signature is itself
@@ -119868,7 +119917,9 @@ var ts;
                 var currentPath = queue.pop();
                 if (!seenFileNamesMap.has(currentPath)) {
                     seenFileNamesMap.set(currentPath, true);
-                    fn(state, currentPath);
+                    if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, host))
+                        return;
+                    handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, host);
                     if (isChangedSignature(state, currentPath)) {
                         var currentSourceFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
                         queue.push.apply(queue, ts.BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
@@ -119880,56 +119931,38 @@ var ts;
         var seenFileAndExportsOfFile = new ts.Set();
         // Go through exported modules from cache first
         // If exported modules has path, all files referencing file exported from are affected
-        (_a = state.currentAffectedFilesExportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            return forEachFilesReferencingPath(state, exportedFromPath, seenFileAndExportsOfFile, fn);
-        });
-        // If exported from path is not from cache and exported modules has path, all files referencing file exported from are affected
-        (_b = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _b === void 0 ? void 0 : _b.forEach(function (exportedFromPath) {
-            var _a;
-            // If the cache had an updated value, skip
-            return !state.currentAffectedFilesExportedModulesMap.hasKey(exportedFromPath) &&
-                !((_a = state.currentAffectedFilesExportedModulesMap.deletedKeys()) === null || _a === void 0 ? void 0 : _a.has(exportedFromPath)) &&
-                forEachFilesReferencingPath(state, exportedFromPath, seenFileAndExportsOfFile, fn);
+        forEachKeyOfExportedModulesMap(state, affectedFile.resolvedPath, function (exportedFromPath) {
+            if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, host))
+                return true;
+            var references = state.referencedMap.getKeys(exportedFromPath);
+            return references && ts.forEachKey(references, function (filePath) {
+                return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, host);
+            });
         });
     }
     /**
-     * Iterate on files referencing referencedPath
+     * handle dts and semantic diagnostics on file and iterate on anything that exports this file
+     * return true when all work is done and we can exit handling dts emit and semantic diagnostics
      */
-    function forEachFilesReferencingPath(state, referencedPath, seenFileAndExportsOfFile, fn) {
+    function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, host) {
         var _a;
-        (_a = state.referencedMap.getKeys(referencedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (filePath) {
-            return forEachFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, fn);
-        });
-    }
-    /**
-     * fn on file and iterate on anything that exports this file
-     */
-    function forEachFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, fn) {
-        var _a, _b, _c;
-        if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath)) {
-            return;
-        }
-        fn(state, filePath);
+        if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath))
+            return undefined;
+        if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host))
+            return true;
+        handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, host);
         ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap);
-        // Go through exported modules from cache first
         // If exported modules has path, all files referencing file exported from are affected
-        (_a = state.currentAffectedFilesExportedModulesMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            return forEachFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, fn);
-        });
-        // If exported from path is not from cache and exported modules has path, all files referencing file exported from are affected
-        (_b = state.exportedModulesMap.getKeys(filePath)) === null || _b === void 0 ? void 0 : _b.forEach(function (exportedFromPath) {
-            var _a;
-            // If the cache had an updated value, skip
-            return !state.currentAffectedFilesExportedModulesMap.hasKey(exportedFromPath) &&
-                !((_a = state.currentAffectedFilesExportedModulesMap.deletedKeys()) === null || _a === void 0 ? void 0 : _a.has(exportedFromPath)) &&
-                forEachFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, fn);
+        forEachKeyOfExportedModulesMap(state, filePath, function (exportedFromPath) {
+            return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, host);
         });
         // Remove diagnostics of files that import this file (without going to exports of referencing files)
-        (_c = state.referencedMap.getKeys(filePath)) === null || _c === void 0 ? void 0 : _c.forEach(function (referencingFilePath) {
+        (_a = state.referencedMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (referencingFilePath) {
             return !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file
-                fn(state, referencingFilePath);
-        } // Dont add to seen since this is not yet done with the export removal
-        );
+                handleDtsMayChangeOf(// Dont add to seen since this is not yet done with the export removal
+                state, referencingFilePath, cancellationToken, computeHash, host);
+        });
+        return undefined;
     }
     /**
      * This is called after completing operation on the next affected file.
@@ -120305,7 +120338,43 @@ var ts;
             return toAffectedFileEmitResult(state, 
             // When whole program is affected, do emit only once (eg when --out or --outFile is specified)
             // Otherwise just affected file
-            ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles || emitKind === 0 /* DtsOnly */, customTransformers), affected, emitKind, isPendingEmitFile);
+            ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, affected !== state.program && ts.getEmitDeclarations(state.compilerOptions) && !customTransformers ?
+                getWriteFileUpdatingSignatureCallback(writeFile) :
+                writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles || emitKind === 0 /* DtsOnly */, customTransformers), affected, emitKind, isPendingEmitFile);
+        }
+        function getWriteFileUpdatingSignatureCallback(writeFile) {
+            return function (fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
+                var _a;
+                if (ts.isDeclarationFileName(fileName)) {
+                    ts.Debug.assert((sourceFiles === null || sourceFiles === void 0 ? void 0 : sourceFiles.length) === 1);
+                    var file = sourceFiles[0];
+                    var info = state.fileInfos.get(file.resolvedPath);
+                    var signature = ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.get(file.resolvedPath)) || info.signature;
+                    if (signature === file.version) {
+                        var newSignature = (computeHash || ts.generateDjb2Hash)((data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text);
+                        if (newSignature !== file.version) { // Update it
+                            if (host.storeFilesChangingSignatureDuringEmit)
+                                (state.filesChangingSignature || (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath);
+                            if (state.exportedModulesMap)
+                                ts.BuilderState.updateExportedModules(file, file.exportedModulesFromDeclarationEmit, state.currentAffectedFilesExportedModulesMap || (state.currentAffectedFilesExportedModulesMap = ts.BuilderState.createManyToManyPathMap()));
+                            if (state.affectedFiles && state.affectedFilesIndex < state.affectedFiles.length) {
+                                state.currentAffectedFilesSignatures.set(file.resolvedPath, newSignature);
+                            }
+                            else {
+                                info.signature = newSignature;
+                                if (state.exportedModulesMap)
+                                    ts.BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
+                            }
+                        }
+                    }
+                }
+                if (writeFile)
+                    writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
+                else if (host.writeFile)
+                    host.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
+                else
+                    state.program.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
+            };
         }
         /**
          * Emits the JavaScript and declaration files.
@@ -120362,7 +120431,9 @@ var ts;
                     }
                 }
             }
-            return ts.Debug.checkDefined(state.program).emit(targetSourceFile, writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
+            return ts.Debug.checkDefined(state.program).emit(targetSourceFile, !ts.outFile(state.compilerOptions) && ts.getEmitDeclarations(state.compilerOptions) && !customTransformers ?
+                getWriteFileUpdatingSignatureCallback(writeFile) :
+                writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
         }
         /**
          * Return the semantic diagnostics for the next affected file or undefined if iteration is complete
@@ -122554,6 +122625,7 @@ var ts;
             createHash: ts.maybeBind(host, host.createHash),
             readDirectory: ts.maybeBind(host, host.readDirectory),
             disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
+            storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
         };
         function writeFile(fileName, text, writeByteOrderMark, onError) {
             try {
@@ -122613,6 +122685,7 @@ var ts;
             createHash: ts.maybeBind(system, system.createHash),
             createProgram: createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram,
             disableUseFileVersionAsSignature: system.disableUseFileVersionAsSignature,
+            storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
         };
     }
     ts.createProgramHost = createProgramHost;
@@ -122701,6 +122774,7 @@ var ts;
         var host = ts.createCompilerHostWorker(options, /*setParentNodes*/ undefined, system);
         host.createHash = ts.maybeBind(system, system.createHash);
         host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
+        host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
         ts.setGetSourceFileAsHashVersioned(host, system);
         ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName); });
         return host;
@@ -131769,22 +131843,44 @@ var ts;
             }
         }
         function createSnippetPrinter(printerOptions) {
+            var escapes;
             var baseWriter = ts.textChanges.createWriter(ts.getNewLineCharacter(printerOptions));
             var printer = ts.createPrinter(printerOptions, baseWriter);
-            var writer = __assign(__assign({}, baseWriter), { write: function (s) { return baseWriter.write(ts.escapeSnippetText(s)); }, nonEscapingWrite: baseWriter.write, writeLiteral: function (s) { return baseWriter.writeLiteral(ts.escapeSnippetText(s)); }, writeStringLiteral: function (s) { return baseWriter.writeStringLiteral(ts.escapeSnippetText(s)); }, writeSymbol: function (s, symbol) { return baseWriter.writeSymbol(ts.escapeSnippetText(s), symbol); }, writeParameter: function (s) { return baseWriter.writeParameter(ts.escapeSnippetText(s)); }, writeComment: function (s) { return baseWriter.writeComment(ts.escapeSnippetText(s)); }, writeProperty: function (s) { return baseWriter.writeProperty(ts.escapeSnippetText(s)); } });
+            var writer = __assign(__assign({}, baseWriter), { write: function (s) { return escapingWrite(s, function () { return baseWriter.write(s); }); }, nonEscapingWrite: baseWriter.write, writeLiteral: function (s) { return escapingWrite(s, function () { return baseWriter.writeLiteral(s); }); }, writeStringLiteral: function (s) { return escapingWrite(s, function () { return baseWriter.writeStringLiteral(s); }); }, writeSymbol: function (s, symbol) { return escapingWrite(s, function () { return baseWriter.writeSymbol(s, symbol); }); }, writeParameter: function (s) { return escapingWrite(s, function () { return baseWriter.writeParameter(s); }); }, writeComment: function (s) { return escapingWrite(s, function () { return baseWriter.writeComment(s); }); }, writeProperty: function (s) { return escapingWrite(s, function () { return baseWriter.writeProperty(s); }); } });
             return {
                 printSnippetList: printSnippetList,
                 printAndFormatSnippetList: printAndFormatSnippetList,
             };
+            // The formatter/scanner will have issues with snippet-escaped text,
+            // so instead of writing the escaped text directly to the writer,
+            // generate a set of changes that can be applied to the unescaped text
+            // to escape it post-formatting.
+            function escapingWrite(s, write) {
+                var escaped = ts.escapeSnippetText(s);
+                if (escaped !== s) {
+                    var start = baseWriter.getTextPos();
+                    write();
+                    var end = baseWriter.getTextPos();
+                    escapes = ts.append(escapes || (escapes = []), { newText: escaped, span: { start: start, length: end - start } });
+                }
+                else {
+                    write();
+                }
+            }
             /* Snippet-escaping version of `printer.printList`. */
             function printSnippetList(format, list, sourceFile) {
+                var unescaped = printUnescapedSnippetList(format, list, sourceFile);
+                return escapes ? ts.textChanges.applyChanges(unescaped, escapes) : unescaped;
+            }
+            function printUnescapedSnippetList(format, list, sourceFile) {
+                escapes = undefined;
                 writer.clear();
                 printer.writeList(format, list, sourceFile, writer);
                 return writer.getText();
             }
             function printAndFormatSnippetList(format, list, sourceFile, formatContext) {
                 var syntheticFile = {
-                    text: printSnippetList(format, list, sourceFile),
+                    text: printUnescapedSnippetList(format, list, sourceFile),
                     getLineAndCharacterOfPosition: function (pos) {
                         return ts.getLineAndCharacterOfPosition(this, pos);
                     },
@@ -131796,7 +131892,10 @@ var ts;
                     /* indentation */ 0, 
                     /* delta */ 0, __assign(__assign({}, formatContext), { options: formatOptions }));
                 });
-                return ts.textChanges.applyChanges(syntheticFile.text, changes);
+                var allChanges = escapes
+                    ? ts.stableSort(ts.concatenate(changes, escapes), function (a, b) { return ts.compareTextSpans(a.span, b.span); })
+                    : changes;
+                return ts.textChanges.applyChanges(syntheticFile.text, allChanges);
             }
         }
         function originToCompletionEntryData(origin) {

package/lib/tsserverlibrary.d.ts

@@ -2172,7 +2172,9 @@ declare namespace ts {
     export type ResolvedConfigFileName = string & {
         _isResolvedConfigFileName: never;
     };
-    export type WriteFileCallback = (fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: readonly SourceFile[]) => void;
+    export interface WriteFileCallbackData {
+    }
+    export type WriteFileCallback = (fileName: string, text: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: readonly SourceFile[], data?: WriteFileCallbackData) => void;
     export class OperationCanceledException {
     }
     export interface CancellationToken {