typescript 5.3.0-dev.20231101 → 5.4.0-dev.20231103

package/lib/typescript.js

@@ -34,8 +34,8 @@ var ts = (() => {
   var init_corePublic = __esm({
     "src/compiler/corePublic.ts"() {
       "use strict";
-      versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-dev.20231101`;
+      versionMajorMinor = "5.4";
+      version = `${versionMajorMinor}.0-dev.20231103`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -112726,27 +112726,6 @@ ${lanes.join("\n")}
       (_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Emit, "emitBuildInfo", { buildInfoPath });
       emitBuildInfo(bundleBuildInfo, buildInfoPath);
       (_f = tracing) == null ? void 0 : _f.pop();
-      if (!emitSkipped && emittedFilesList) {
-        if (!emitOnly) {
-          if (jsFilePath) {
-            emittedFilesList.push(jsFilePath);
-          }
-          if (sourceMapFilePath) {
-            emittedFilesList.push(sourceMapFilePath);
-          }
-          if (buildInfoPath) {
-            emittedFilesList.push(buildInfoPath);
-          }
-        }
-        if (emitOnly !== 0 /* Js */) {
-          if (declarationFilePath) {
-            emittedFilesList.push(declarationFilePath);
-          }
-          if (declarationMapPath) {
-            emittedFilesList.push(declarationMapPath);
-          }
-        }
-      }
       function relativeToBuildInfo(path) {
         return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path, host.getCanonicalFileName));
       }
@@ -112774,6 +112753,7 @@ ${lanes.join("\n")}
         void 0,
         { buildInfo }
       );
+      emittedFilesList == null ? void 0 : emittedFilesList.push(buildInfoPath);
     }
     function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) {
       if (!sourceFileOrBundle || emitOnly || !jsFilePath) {
@@ -112819,6 +112799,12 @@ ${lanes.join("\n")}
       transform2.dispose();
       if (bundleBuildInfo)
         bundleBuildInfo.js = printer.bundleFileInfo;
+      if (emittedFilesList) {
+        emittedFilesList.push(jsFilePath);
+        if (sourceMapFilePath) {
+          emittedFilesList.push(sourceMapFilePath);
+        }
+      }
     }
     function emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo) {
       if (!sourceFileOrBundle || emitOnly === 0 /* Js */)
@@ -112849,33 +112835,33 @@ ${lanes.join("\n")}
           emitterDiagnostics.add(diagnostic);
         }
       }
-      const printerOptions = {
-        removeComments: compilerOptions.removeComments,
-        newLine: compilerOptions.newLine,
-        noEmitHelpers: true,
-        module: compilerOptions.module,
-        target: compilerOptions.target,
-        sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
-        inlineSourceMap: compilerOptions.inlineSourceMap,
-        extendedDiagnostics: compilerOptions.extendedDiagnostics,
-        onlyPrintJsDocStyle: true,
-        omitBraceSourceMapPositions: true,
-        writeBundleFileInfo: !!bundleBuildInfo,
-        recordInternalSection: !!bundleBuildInfo,
-        relativeToBuildInfo
-      };
-      const declarationPrinter = createPrinter(printerOptions, {
-        // resolver hooks
-        hasGlobalName: resolver.hasGlobalName,
-        // transform hooks
-        onEmitNode: declarationTransform.emitNodeWithNotification,
-        isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,
-        substituteNode: declarationTransform.substituteNode
-      });
       const declBlocked = !!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
       emitSkipped = emitSkipped || declBlocked;
       if (!declBlocked || forceDtsEmit) {
         Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform");
+        const printerOptions = {
+          removeComments: compilerOptions.removeComments,
+          newLine: compilerOptions.newLine,
+          noEmitHelpers: true,
+          module: compilerOptions.module,
+          target: compilerOptions.target,
+          sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
+          inlineSourceMap: compilerOptions.inlineSourceMap,
+          extendedDiagnostics: compilerOptions.extendedDiagnostics,
+          onlyPrintJsDocStyle: true,
+          omitBraceSourceMapPositions: true,
+          writeBundleFileInfo: !!bundleBuildInfo,
+          recordInternalSection: !!bundleBuildInfo,
+          relativeToBuildInfo
+        };
+        const declarationPrinter = createPrinter(printerOptions, {
+          // resolver hooks
+          hasGlobalName: resolver.hasGlobalName,
+          // transform hooks
+          onEmitNode: declarationTransform.emitNodeWithNotification,
+          isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,
+          substituteNode: declarationTransform.substituteNode
+        });
         printSourceFileOrBundle(
           declarationFilePath,
           declarationMapPath,
@@ -112889,10 +112875,16 @@ ${lanes.join("\n")}
             // Explicitly do not passthru either `inline` option
           }
         );
+        if (emittedFilesList) {
+          emittedFilesList.push(declarationFilePath);
+          if (declarationMapPath) {
+            emittedFilesList.push(declarationMapPath);
+          }
+        }
+        if (bundleBuildInfo)
+          bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;
       }
       declarationTransform.dispose();
-      if (bundleBuildInfo)
-        bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;
     }
     function collectLinkedAliases(node) {
       if (isExportAssignment(node)) {
@@ -123042,6 +123034,7 @@ ${lanes.join("\n")}
     const copyDeclarationFileDiagnostics = canCopySemanticDiagnostics && !compilerOptions.skipLibCheck === !oldCompilerOptions.skipLibCheck;
     const copyLibFileDiagnostics = copyDeclarationFileDiagnostics && !compilerOptions.skipDefaultLibCheck === !oldCompilerOptions.skipDefaultLibCheck;
     state.fileInfos.forEach((info, sourceFilePath) => {
+      var _a2;
       let oldInfo;
       let newReferences;
       if (!useOldState || // File wasn't present in old state
@@ -123051,22 +123044,28 @@ ${lanes.join("\n")}
       !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) || // Referenced file was deleted in the new program
       newReferences && forEachKey(newReferences, (path) => !state.fileInfos.has(path) && oldState.fileInfos.has(path))) {
         addFileToChangeSet(state, sourceFilePath);
-      } else if (canCopySemanticDiagnostics) {
+      } else {
         const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
-        if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics)
-          return;
-        if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics)
-          return;
-        const diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
-        if (diagnostics) {
-          state.semanticDiagnosticsPerFile.set(
+        const emitDiagnostics = (_a2 = oldState.emitDiagnosticsPerFile) == null ? void 0 : _a2.get(sourceFilePath);
+        if (emitDiagnostics) {
+          (state.emitDiagnosticsPerFile ?? (state.emitDiagnosticsPerFile = /* @__PURE__ */ new Map())).set(
             sourceFilePath,
-            oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : repopulateDiagnostics(diagnostics, newProgram)
+            oldState.hasReusableDiagnostic ? convertToDiagnostics(emitDiagnostics, newProgram) : repopulateDiagnostics(emitDiagnostics, newProgram)
           );
-          if (!state.semanticDiagnosticsFromOldState) {
-            state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set();
+        }
+        if (canCopySemanticDiagnostics) {
+          if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics)
+            return;
+          if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics)
+            return;
+          const diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
+          if (diagnostics) {
+            state.semanticDiagnosticsPerFile.set(
+              sourceFilePath,
+              oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : repopulateDiagnostics(diagnostics, newProgram)
+            );
+            (state.semanticDiagnosticsFromOldState ?? (state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set())).add(sourceFilePath);
           }
-          state.semanticDiagnosticsFromOldState.add(sourceFilePath);
         }
       }
       if (canCopyEmitSignatures) {
@@ -123203,7 +123202,9 @@ ${lanes.join("\n")}
       outSignature: state.outSignature,
       latestChangedDtsFile: state.latestChangedDtsFile,
       hasChangedEmitSignature: state.hasChangedEmitSignature,
-      changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : void 0
+      changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : void 0,
+      buildInfoEmitPending: state.buildInfoEmitPending,
+      emitDiagnosticsPerFile: state.emitDiagnosticsPerFile && new Map(state.emitDiagnosticsPerFile)
     };
   }
   function restoreBuilderProgramEmitState(state, savedEmitState) {
@@ -123214,6 +123215,8 @@ ${lanes.join("\n")}
     state.outSignature = savedEmitState.outSignature;
     state.latestChangedDtsFile = savedEmitState.latestChangedDtsFile;
     state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;
+    state.buildInfoEmitPending = savedEmitState.buildInfoEmitPending;
+    state.emitDiagnosticsPerFile = savedEmitState.emitDiagnosticsPerFile;
     if (savedEmitState.changedFilesSet)
       state.changedFilesSet = savedEmitState.changedFilesSet;
   }
@@ -123304,6 +123307,22 @@ ${lanes.join("\n")}
         return { affectedFile, emitKind: pendingKind };
     });
   }
+  function getNextPendingEmitDiagnosticsFile(state) {
+    var _a;
+    if (!((_a = state.emitDiagnosticsPerFile) == null ? void 0 : _a.size))
+      return void 0;
+    return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path) => {
+      var _a2;
+      const affectedFile = state.program.getSourceFileByPath(path);
+      if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
+        state.emitDiagnosticsPerFile.delete(path);
+        return void 0;
+      }
+      const seenKind = ((_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath)) || 0 /* None */;
+      if (!(seenKind & 24 /* AllDts */))
+        return { affectedFile, diagnostics, seenKind };
+    });
+  }
   function removeDiagnosticsOfLibraryFiles(state) {
     if (!state.cleanedDiagnosticsOfLibFiles) {
       state.cleanedDiagnosticsOfLibFiles = true;
@@ -123580,18 +123599,7 @@ ${lanes.join("\n")}
         return void 0;
       });
     }
-    let semanticDiagnosticsPerFile;
-    if (state.semanticDiagnosticsPerFile) {
-      for (const key of arrayFrom(state.semanticDiagnosticsPerFile.keys()).sort(compareStringsCaseSensitive)) {
-        const value = state.semanticDiagnosticsPerFile.get(key);
-        (semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(
-          value.length ? [
-            toFileId(key),
-            convertToReusableDiagnostics(value, relativeToBuildInfo)
-          ] : toFileId(key)
-        );
-      }
-    }
+    const semanticDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.semanticDiagnosticsPerFile);
     let affectedFilesPendingEmit;
     if ((_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.size) {
       const fullEmitForOptions = getBuilderFileEmit(state.compilerOptions);
@@ -123621,6 +123629,7 @@ ${lanes.join("\n")}
         (changeFileSet || (changeFileSet = [])).push(toFileId(path));
       }
     }
+    const emitDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.emitDiagnosticsPerFile);
     const program = {
       fileNames,
       fileInfos,
@@ -123630,6 +123639,7 @@ ${lanes.join("\n")}
       referencedMap,
       exportedModulesMap,
       semanticDiagnosticsPerFile,
+      emitDiagnosticsPerFile,
       affectedFilesPendingEmit,
       changeFileSet,
       emitSignatures,
@@ -123686,73 +123696,87 @@ ${lanes.join("\n")}
         if (optionInfo == null ? void 0 : optionInfo.affectsBuildInfo) {
           (result || (result = {}))[name] = convertToReusableCompilerOptionValue(
             optionInfo,
-            options[name],
-            relativeToBuildInfoEnsuringAbsolutePath
+            options[name]
           );
         }
       }
       return result;
     }
-  }
-  function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
-    if (option) {
-      Debug.assert(option.type !== "listOrElement");
-      if (option.type === "list") {
-        const values = value;
-        if (option.element.isFilePath && values.length) {
-          return values.map(relativeToBuildInfo);
+    function convertToReusableCompilerOptionValue(option, value) {
+      if (option) {
+        Debug.assert(option.type !== "listOrElement");
+        if (option.type === "list") {
+          const values = value;
+          if (option.element.isFilePath && values.length) {
+            return values.map(relativeToBuildInfoEnsuringAbsolutePath);
+          }
+        } else if (option.isFilePath) {
+          return relativeToBuildInfoEnsuringAbsolutePath(value);
         }
-      } else if (option.isFilePath) {
-        return relativeToBuildInfo(value);
       }
+      return value;
     }
-    return value;
-  }
-  function convertToReusableDiagnostics(diagnostics, relativeToBuildInfo) {
-    Debug.assert(!!diagnostics.length);
-    return diagnostics.map((diagnostic) => {
-      const result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
-      result.reportsUnnecessary = diagnostic.reportsUnnecessary;
-      result.reportDeprecated = diagnostic.reportsDeprecated;
-      result.source = diagnostic.source;
-      result.skippedOn = diagnostic.skippedOn;
-      const { relatedInformation } = diagnostic;
-      result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo)) : [] : void 0;
+    function convertToProgramBuildInfoDiagnostics(diagnostics) {
+      let result;
+      if (diagnostics) {
+        for (const key of arrayFrom(diagnostics.keys()).sort(compareStringsCaseSensitive)) {
+          const value = diagnostics.get(key);
+          (result || (result = [])).push(
+            value.length ? [
+              toFileId(key),
+              convertToReusableDiagnostics(value)
+            ] : toFileId(key)
+          );
+        }
+      }
       return result;
-    });
-  }
-  function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) {
-    const { file } = diagnostic;
-    return {
-      ...diagnostic,
-      file: file ? relativeToBuildInfo(file.resolvedPath) : void 0,
-      messageText: isString(diagnostic.messageText) ? diagnostic.messageText : convertToReusableDiagnosticMessageChain(diagnostic.messageText)
-    };
-  }
-  function convertToReusableDiagnosticMessageChain(chain) {
-    if (chain.repopulateInfo) {
+    }
+    function convertToReusableDiagnostics(diagnostics) {
+      Debug.assert(!!diagnostics.length);
+      return diagnostics.map((diagnostic) => {
+        const result = convertToReusableDiagnosticRelatedInformation(diagnostic);
+        result.reportsUnnecessary = diagnostic.reportsUnnecessary;
+        result.reportDeprecated = diagnostic.reportsDeprecated;
+        result.source = diagnostic.source;
+        result.skippedOn = diagnostic.skippedOn;
+        const { relatedInformation } = diagnostic;
+        result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r)) : [] : void 0;
+        return result;
+      });
+    }
+    function convertToReusableDiagnosticRelatedInformation(diagnostic) {
+      const { file } = diagnostic;
       return {
-        info: chain.repopulateInfo(),
-        next: convertToReusableDiagnosticMessageChainArray(chain.next)
+        ...diagnostic,
+        file: file ? relativeToBuildInfo(file.resolvedPath) : void 0,
+        messageText: isString(diagnostic.messageText) ? diagnostic.messageText : convertToReusableDiagnosticMessageChain(diagnostic.messageText)
       };
     }
-    const next = convertToReusableDiagnosticMessageChainArray(chain.next);
-    return next === chain.next ? chain : { ...chain, next };
-  }
-  function convertToReusableDiagnosticMessageChainArray(array) {
-    if (!array)
-      return array;
-    return forEach(array, (chain, index) => {
-      const reusable = convertToReusableDiagnosticMessageChain(chain);
-      if (chain === reusable)
-        return void 0;
-      const result = index > 0 ? array.slice(0, index - 1) : [];
-      result.push(reusable);
-      for (let i = index + 1; i < array.length; i++) {
-        result.push(convertToReusableDiagnosticMessageChain(array[i]));
+    function convertToReusableDiagnosticMessageChain(chain) {
+      if (chain.repopulateInfo) {
+        return {
+          info: chain.repopulateInfo(),
+          next: convertToReusableDiagnosticMessageChainArray(chain.next)
+        };
       }
-      return result;
-    }) || array;
+      const next = convertToReusableDiagnosticMessageChainArray(chain.next);
+      return next === chain.next ? chain : { ...chain, next };
+    }
+    function convertToReusableDiagnosticMessageChainArray(array) {
+      if (!array)
+        return array;
+      return forEach(array, (chain, index) => {
+        const reusable = convertToReusableDiagnosticMessageChain(chain);
+        if (chain === reusable)
+          return void 0;
+        const result = index > 0 ? array.slice(0, index - 1) : [];
+        result.push(reusable);
+        for (let i = index + 1; i < array.length; i++) {
+          result.push(convertToReusableDiagnosticMessageChain(array[i]));
+        }
+        return result;
+      }) || array;
+    }
   }
   function getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
     let host;
@@ -123861,6 +123885,14 @@ ${lanes.join("\n")}
         if (!outFile(state.compilerOptions)) {
           const pendingAffectedFile = getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles);
           if (!pendingAffectedFile) {
+            const pendingForDiagnostics = getNextPendingEmitDiagnosticsFile(state);
+            if (pendingForDiagnostics) {
+              (state.seenEmittedFiles ?? (state.seenEmittedFiles = /* @__PURE__ */ new Map())).set(pendingForDiagnostics.affectedFile.resolvedPath, pendingForDiagnostics.seenKind | 24 /* AllDts */);
+              return {
+                result: { emitSkipped: true, diagnostics: pendingForDiagnostics.diagnostics },
+                affected: pendingForDiagnostics.affectedFile
+              };
+            }
             if (!state.buildInfoEmitPending)
               return void 0;
             const affected2 = state.program;
@@ -123909,6 +123941,8 @@ ${lanes.join("\n")}
           (state.affectedFilesPendingEmit ?? (state.affectedFilesPendingEmit = /* @__PURE__ */ new Map())).set(affectedSourceFile.resolvedPath, pendingKind);
         else
           (_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.delete(affectedSourceFile.resolvedPath);
+        if (result.diagnostics.length)
+          (state.emitDiagnosticsPerFile ?? (state.emitDiagnosticsPerFile = /* @__PURE__ */ new Map())).set(affectedSourceFile.resolvedPath, result.diagnostics);
       } else {
         state.changedFilesSet.clear();
       }
@@ -124081,9 +124115,10 @@ ${lanes.join("\n")}
     }
   }
   function addToAffectedFilesPendingEmit(state, affectedFilePendingEmit, kind) {
-    var _a;
+    var _a, _b;
     const existingKind = ((_a = state.affectedFilesPendingEmit) == null ? void 0 : _a.get(affectedFilePendingEmit)) || 0 /* None */;
     (state.affectedFilesPendingEmit ?? (state.affectedFilesPendingEmit = /* @__PURE__ */ new Map())).set(affectedFilePendingEmit, existingKind | kind);
+    (_b = state.emitDiagnosticsPerFile) == null ? void 0 : _b.delete(affectedFilePendingEmit);
   }
   function toBuilderStateFileInfoForMultiEmit(fileInfo) {
     return isString(fileInfo) ? { version: fileInfo, signature: fileInfo, affectsGlobalScope: void 0, impliedFormat: void 0 } : isString(fileInfo.signature) ? fileInfo : { version: fileInfo.version, signature: fileInfo.signature === false ? void 0 : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
@@ -124148,7 +124183,8 @@ ${lanes.join("\n")}
         compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
         referencedMap: toManyToManyPathMap(program.referencedMap),
         exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
-        semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && arrayToMap(program.semanticDiagnosticsPerFile, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => isNumber(value) ? emptyArray : value[1]),
+        semanticDiagnosticsPerFile: toPerFileDiagnostics(program.semanticDiagnosticsPerFile),
+        emitDiagnosticsPerFile: toPerFileDiagnostics(program.emitDiagnosticsPerFile),
         hasReusableDiagnostic: true,
         affectedFilesPendingEmit: program.affectedFilesPendingEmit && arrayToMap(program.affectedFilesPendingEmit, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => toBuilderFileEmit(value, fullEmitForOptions)),
         changedFilesSet: new Set(map(program.changeFileSet, toFilePath)),
@@ -124201,6 +124237,9 @@ ${lanes.join("\n")}
       referenceMap.forEach(([fileId, fileIdListId]) => map2.set(toFilePath(fileId), toFilePathsSet(fileIdListId)));
       return map2;
     }
+    function toPerFileDiagnostics(diagnostics) {
+      return diagnostics && arrayToMap(diagnostics, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => isNumber(value) ? emptyArray : value[1]);
+    }
   }
   function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
     const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
@@ -127895,7 +127934,7 @@ ${lanes.join("\n")}
     }
   }
   function getUpToDateStatusWorker(state, project, resolvedPath) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!project.fileNames.length && !canJsonReportNoInputFiles(project.raw)) {
       return {
         type: 16 /* ContainerOnly */
@@ -127969,7 +128008,7 @@ ${lanes.join("\n")}
         };
       }
       if (buildInfo.program) {
-        if (((_a = buildInfo.program.changeFileSet) == null ? void 0 : _a.length) || (!project.options.noEmit ? (_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length : some(buildInfo.program.semanticDiagnosticsPerFile, isArray))) {
+        if (((_a = buildInfo.program.changeFileSet) == null ? void 0 : _a.length) || (!project.options.noEmit ? ((_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length) || ((_c = buildInfo.program.emitDiagnosticsPerFile) == null ? void 0 : _c.length) : some(buildInfo.program.semanticDiagnosticsPerFile, isArray))) {
           return {
             type: 8 /* OutOfDateBuildInfo */,
             buildInfoFile: buildInfoPath
@@ -164466,6 +164505,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       visitForDisplayParts(typeNode);
       return parts;
       function visitForDisplayParts(node) {
+        var _a, _b;
         if (!node) {
           return;
         }
@@ -164480,9 +164520,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         switch (node.kind) {
           case 80 /* Identifier */:
-            const identifier = node;
-            const identifierText = idText(identifier);
-            const name = identifier.symbol && identifier.symbol.declarations && identifier.symbol.declarations.length && getNameOfDeclaration(identifier.symbol.declarations[0]);
+            Debug.assertNode(node, isIdentifier);
+            const identifierText = idText(node);
+            const name = node.symbol && node.symbol.declarations && node.symbol.declarations.length && getNameOfDeclaration(node.symbol.declarations[0]);
             if (name) {
               parts.push(getNodeDisplayPart(identifierText, name));
             } else {
@@ -164490,252 +164530,307 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
             break;
           case 166 /* QualifiedName */:
-            const qualifiedName = node;
-            visitForDisplayParts(qualifiedName.left);
+            Debug.assertNode(node, isQualifiedName);
+            visitForDisplayParts(node.left);
             parts.push({ text: "." });
-            visitForDisplayParts(qualifiedName.right);
+            visitForDisplayParts(node.right);
             break;
           case 182 /* TypePredicate */:
-            const predicate = node;
-            if (predicate.assertsModifier) {
+            Debug.assertNode(node, isTypePredicateNode);
+            if (node.assertsModifier) {
               parts.push({ text: "asserts " });
             }
-            visitForDisplayParts(predicate.parameterName);
-            if (predicate.type) {
+            visitForDisplayParts(node.parameterName);
+            if (node.type) {
               parts.push({ text: " is " });
-              visitForDisplayParts(predicate.type);
+              visitForDisplayParts(node.type);
             }
             break;
           case 183 /* TypeReference */:
-            const typeReference = node;
-            visitForDisplayParts(typeReference.typeName);
-            if (typeReference.typeArguments) {
+            Debug.assertNode(node, isTypeReferenceNode);
+            visitForDisplayParts(node.typeName);
+            if (node.typeArguments) {
               parts.push({ text: "<" });
-              visitDisplayPartList(typeReference.typeArguments, ", ");
+              visitDisplayPartList(node.typeArguments, ", ");
               parts.push({ text: ">" });
             }
             break;
           case 168 /* TypeParameter */:
-            const typeParameter = node;
-            if (typeParameter.modifiers) {
-              visitDisplayPartList(typeParameter.modifiers, " ");
+            Debug.assertNode(node, isTypeParameterDeclaration);
+            if (node.modifiers) {
+              visitDisplayPartList(node.modifiers, " ");
             }
-            visitForDisplayParts(typeParameter.name);
-            if (typeParameter.constraint) {
+            visitForDisplayParts(node.name);
+            if (node.constraint) {
               parts.push({ text: " extends " });
-              visitForDisplayParts(typeParameter.constraint);
+              visitForDisplayParts(node.constraint);
             }
-            if (typeParameter.default) {
+            if (node.default) {
               parts.push({ text: " = " });
-              visitForDisplayParts(typeParameter.default);
+              visitForDisplayParts(node.default);
             }
             break;
           case 169 /* Parameter */:
-            const parameter = node;
-            if (parameter.modifiers) {
-              visitDisplayPartList(parameter.modifiers, " ");
+            Debug.assertNode(node, isParameter);
+            if (node.modifiers) {
+              visitDisplayPartList(node.modifiers, " ");
             }
-            if (parameter.dotDotDotToken) {
+            if (node.dotDotDotToken) {
               parts.push({ text: "..." });
             }
-            visitForDisplayParts(parameter.name);
-            if (parameter.questionToken) {
+            visitForDisplayParts(node.name);
+            if (node.questionToken) {
               parts.push({ text: "?" });
             }
-            if (parameter.type) {
+            if (node.type) {
               parts.push({ text: ": " });
-              visitForDisplayParts(parameter.type);
+              visitForDisplayParts(node.type);
             }
             break;
           case 185 /* ConstructorType */:
-            const constructorType = node;
+            Debug.assertNode(node, isConstructorTypeNode);
             parts.push({ text: "new " });
-            if (constructorType.typeParameters) {
-              parts.push({ text: "<" });
-              visitDisplayPartList(constructorType.typeParameters, ", ");
-              parts.push({ text: ">" });
-            }
-            parts.push({ text: "(" });
-            visitDisplayPartList(constructorType.parameters, ", ");
-            parts.push({ text: ")" });
+            visitParametersAndTypeParameters(node);
             parts.push({ text: " => " });
-            visitForDisplayParts(constructorType.type);
+            visitForDisplayParts(node.type);
             break;
           case 186 /* TypeQuery */:
-            const typeQuery = node;
+            Debug.assertNode(node, isTypeQueryNode);
             parts.push({ text: "typeof " });
-            visitForDisplayParts(typeQuery.exprName);
-            if (typeQuery.typeArguments) {
+            visitForDisplayParts(node.exprName);
+            if (node.typeArguments) {
               parts.push({ text: "<" });
-              visitDisplayPartList(typeQuery.typeArguments, ", ");
+              visitDisplayPartList(node.typeArguments, ", ");
               parts.push({ text: ">" });
             }
             break;
           case 187 /* TypeLiteral */:
-            const typeLiteral = node;
+            Debug.assertNode(node, isTypeLiteralNode);
             parts.push({ text: "{" });
-            if (typeLiteral.members.length) {
+            if (node.members.length) {
               parts.push({ text: " " });
-              visitDisplayPartList(typeLiteral.members, "; ");
+              visitDisplayPartList(node.members, "; ");
               parts.push({ text: " " });
             }
             parts.push({ text: "}" });
             break;
           case 188 /* ArrayType */:
+            Debug.assertNode(node, isArrayTypeNode);
             visitForDisplayParts(node.elementType);
             parts.push({ text: "[]" });
             break;
           case 189 /* TupleType */:
+            Debug.assertNode(node, isTupleTypeNode);
             parts.push({ text: "[" });
             visitDisplayPartList(node.elements, ", ");
             parts.push({ text: "]" });
             break;
           case 202 /* NamedTupleMember */:
-            const member = node;
-            if (member.dotDotDotToken) {
+            Debug.assertNode(node, isNamedTupleMember);
+            if (node.dotDotDotToken) {
               parts.push({ text: "..." });
             }
-            visitForDisplayParts(member.name);
-            if (member.questionToken) {
+            visitForDisplayParts(node.name);
+            if (node.questionToken) {
               parts.push({ text: "?" });
             }
             parts.push({ text: ": " });
-            visitForDisplayParts(member.type);
+            visitForDisplayParts(node.type);
             break;
           case 190 /* OptionalType */:
+            Debug.assertNode(node, isOptionalTypeNode);
             visitForDisplayParts(node.type);
             parts.push({ text: "?" });
             break;
           case 191 /* RestType */:
+            Debug.assertNode(node, isRestTypeNode);
             parts.push({ text: "..." });
             visitForDisplayParts(node.type);
             break;
           case 192 /* UnionType */:
+            Debug.assertNode(node, isUnionTypeNode);
             visitDisplayPartList(node.types, " | ");
             break;
           case 193 /* IntersectionType */:
+            Debug.assertNode(node, isIntersectionTypeNode);
             visitDisplayPartList(node.types, " & ");
             break;
           case 194 /* ConditionalType */:
-            const conditionalType = node;
-            visitForDisplayParts(conditionalType.checkType);
+            Debug.assertNode(node, isConditionalTypeNode);
+            visitForDisplayParts(node.checkType);
             parts.push({ text: " extends " });
-            visitForDisplayParts(conditionalType.extendsType);
+            visitForDisplayParts(node.extendsType);
             parts.push({ text: " ? " });
-            visitForDisplayParts(conditionalType.trueType);
+            visitForDisplayParts(node.trueType);
             parts.push({ text: " : " });
-            visitForDisplayParts(conditionalType.falseType);
+            visitForDisplayParts(node.falseType);
             break;
           case 195 /* InferType */:
+            Debug.assertNode(node, isInferTypeNode);
             parts.push({ text: "infer " });
             visitForDisplayParts(node.typeParameter);
             break;
           case 196 /* ParenthesizedType */:
+            Debug.assertNode(node, isParenthesizedTypeNode);
             parts.push({ text: "(" });
             visitForDisplayParts(node.type);
             parts.push({ text: ")" });
             break;
           case 198 /* TypeOperator */:
-            const typeOperator = node;
-            parts.push({ text: `${tokenToString(typeOperator.operator)} ` });
-            visitForDisplayParts(typeOperator.type);
+            Debug.assertNode(node, isTypeOperatorNode);
+            parts.push({ text: `${tokenToString(node.operator)} ` });
+            visitForDisplayParts(node.type);
             break;
           case 199 /* IndexedAccessType */:
-            const indexedAccess = node;
-            visitForDisplayParts(indexedAccess.objectType);
+            Debug.assertNode(node, isIndexedAccessTypeNode);
+            visitForDisplayParts(node.objectType);
             parts.push({ text: "[" });
-            visitForDisplayParts(indexedAccess.indexType);
+            visitForDisplayParts(node.indexType);
             parts.push({ text: "]" });
             break;
           case 200 /* MappedType */:
-            const mappedType = node;
+            Debug.assertNode(node, isMappedTypeNode);
             parts.push({ text: "{ " });
-            if (mappedType.readonlyToken) {
-              if (mappedType.readonlyToken.kind === 40 /* PlusToken */) {
+            if (node.readonlyToken) {
+              if (node.readonlyToken.kind === 40 /* PlusToken */) {
                 parts.push({ text: "+" });
-              } else if (mappedType.readonlyToken.kind === 41 /* MinusToken */) {
+              } else if (node.readonlyToken.kind === 41 /* MinusToken */) {
                 parts.push({ text: "-" });
               }
               parts.push({ text: "readonly " });
             }
             parts.push({ text: "[" });
-            visitForDisplayParts(mappedType.typeParameter);
-            if (mappedType.nameType) {
+            visitForDisplayParts(node.typeParameter);
+            if (node.nameType) {
               parts.push({ text: " as " });
-              visitForDisplayParts(mappedType.nameType);
+              visitForDisplayParts(node.nameType);
             }
             parts.push({ text: "]" });
-            if (mappedType.questionToken) {
-              if (mappedType.questionToken.kind === 40 /* PlusToken */) {
+            if (node.questionToken) {
+              if (node.questionToken.kind === 40 /* PlusToken */) {
                 parts.push({ text: "+" });
-              } else if (mappedType.questionToken.kind === 41 /* MinusToken */) {
+              } else if (node.questionToken.kind === 41 /* MinusToken */) {
                 parts.push({ text: "-" });
               }
               parts.push({ text: "?" });
             }
             parts.push({ text: ": " });
-            if (mappedType.type) {
-              visitForDisplayParts(mappedType.type);
+            if (node.type) {
+              visitForDisplayParts(node.type);
             }
             parts.push({ text: "; }" });
             break;
           case 201 /* LiteralType */:
+            Debug.assertNode(node, isLiteralTypeNode);
             visitForDisplayParts(node.literal);
             break;
           case 184 /* FunctionType */:
-            const functionType = node;
-            if (functionType.typeParameters) {
-              parts.push({ text: "<" });
-              visitDisplayPartList(functionType.typeParameters, ", ");
-              parts.push({ text: ">" });
-            }
-            parts.push({ text: "(" });
-            visitDisplayPartList(functionType.parameters, ", ");
-            parts.push({ text: ")" });
+            Debug.assertNode(node, isFunctionTypeNode);
+            visitParametersAndTypeParameters(node);
             parts.push({ text: " => " });
-            visitForDisplayParts(functionType.type);
+            visitForDisplayParts(node.type);
             break;
           case 205 /* ImportType */:
-            const importType = node;
-            if (importType.isTypeOf) {
+            Debug.assertNode(node, isImportTypeNode);
+            if (node.isTypeOf) {
               parts.push({ text: "typeof " });
             }
             parts.push({ text: "import(" });
-            visitForDisplayParts(importType.argument);
-            if (importType.assertions) {
+            visitForDisplayParts(node.argument);
+            if (node.assertions) {
               parts.push({ text: ", { assert: " });
-              visitDisplayPartList(importType.assertions.assertClause.elements, ", ");
+              visitDisplayPartList(node.assertions.assertClause.elements, ", ");
               parts.push({ text: " }" });
             }
             parts.push({ text: ")" });
-            if (importType.qualifier) {
+            if (node.qualifier) {
               parts.push({ text: "." });
-              visitForDisplayParts(importType.qualifier);
+              visitForDisplayParts(node.qualifier);
             }
-            if (importType.typeArguments) {
+            if (node.typeArguments) {
               parts.push({ text: "<" });
-              visitDisplayPartList(importType.typeArguments, ", ");
+              visitDisplayPartList(node.typeArguments, ", ");
               parts.push({ text: ">" });
             }
             break;
           case 171 /* PropertySignature */:
-            const propertySignature = node;
-            if (propertySignature.modifiers) {
-              visitDisplayPartList(propertySignature.modifiers, " ");
+            Debug.assertNode(node, isPropertySignature);
+            if ((_a = node.modifiers) == null ? void 0 : _a.length) {
+              visitDisplayPartList(node.modifiers, " ");
+              parts.push({ text: " " });
             }
-            visitForDisplayParts(propertySignature.name);
-            if (propertySignature.questionToken) {
+            visitForDisplayParts(node.name);
+            if (node.questionToken) {
               parts.push({ text: "?" });
             }
-            if (propertySignature.type) {
+            if (node.type) {
+              parts.push({ text: ": " });
+              visitForDisplayParts(node.type);
+            }
+            break;
+          case 173 /* MethodSignature */:
+            Debug.assertNode(node, isMethodSignature);
+            if ((_b = node.modifiers) == null ? void 0 : _b.length) {
+              visitDisplayPartList(node.modifiers, " ");
+              parts.push({ text: " " });
+            }
+            visitForDisplayParts(node.name);
+            if (node.questionToken) {
+              parts.push({ text: "?" });
+            }
+            visitParametersAndTypeParameters(node);
+            if (node.type) {
+              parts.push({ text: ": " });
+              visitForDisplayParts(node.type);
+            }
+            break;
+          case 179 /* CallSignature */:
+            Debug.assertNode(node, isCallSignatureDeclaration);
+            visitParametersAndTypeParameters(node);
+            if (node.type) {
               parts.push({ text: ": " });
-              visitForDisplayParts(propertySignature.type);
+              visitForDisplayParts(node.type);
             }
             break;
+          case 207 /* ArrayBindingPattern */:
+            Debug.assertNode(node, isArrayBindingPattern);
+            parts.push({ text: "[" });
+            visitDisplayPartList(node.elements, ", ");
+            parts.push({ text: "]" });
+            break;
+          case 206 /* ObjectBindingPattern */:
+            Debug.assertNode(node, isObjectBindingPattern);
+            parts.push({ text: "{" });
+            if (node.elements.length) {
+              parts.push({ text: " " });
+              visitDisplayPartList(node.elements, ", ");
+              parts.push({ text: " " });
+            }
+            parts.push({ text: "}" });
+            break;
+          case 208 /* BindingElement */:
+            Debug.assertNode(node, isBindingElement);
+            visitForDisplayParts(node.name);
+            break;
+          case 224 /* PrefixUnaryExpression */:
+            Debug.assertNode(node, isPrefixUnaryExpression);
+            parts.push({ text: tokenToString(node.operator) });
+            visitForDisplayParts(node.operand);
+            break;
           default:
             Debug.failBadSyntaxKind(node);
         }
       }
+      function visitParametersAndTypeParameters(signatureDeclaration) {
+        if (signatureDeclaration.typeParameters) {
+          parts.push({ text: "<" });
+          visitDisplayPartList(signatureDeclaration.typeParameters, ", ");
+          parts.push({ text: ">" });
+        }
+        parts.push({ text: "(" });
+        visitDisplayPartList(signatureDeclaration.parameters, ", ");
+        parts.push({ text: ")" });
+      }
       function visitDisplayPartList(nodes, separator) {
         nodes.forEach((node, index) => {
           if (index > 0) {