[WIP] Persist resolutions and program information and reuse it when building program incrementally or during editor

src/compiler/builderPublic.ts

@@ -41,6 +41,11 @@ namespace ts {
          */
         /*@internal*/
         getProgramOrUndefined(): Program | undefined;
+        /**
+         * Returns current program that could be undefined if the program was released
+         */
+        /*@internal*/
+        getProgramOrProgramFromBuildInfoOrUndefined(): Program | ProgramFromBuildInfo | undefined;
         /**
          * Releases reference to the program, making all the other operations that need program to fail.
          */

src/compiler/builderState.ts

@@ -146,7 +146,7 @@ namespace ts {
 
             // Handle type reference directives
             if (sourceFile.resolvedTypeReferenceDirectiveNames) {
-                sourceFile.resolvedTypeReferenceDirectiveNames.forEach((resolvedTypeReferenceDirective) => {
+                sourceFile.resolvedTypeReferenceDirectiveNames.forEach(({ resolvedTypeReferenceDirective }) => {
                     if (!resolvedTypeReferenceDirective) {
                         return;
                     }

src/compiler/checker.ts

@@ -300,7 +300,7 @@ namespace ts {
                 if (!sf.resolvedModules) return;
 
                 forEachEntry(sf.resolvedModules, r => {
-                    if (r && r.packageId) set.add(r.packageId.name);
+                    if (r.resolvedModule?.packageId) set.add(r.resolvedModule.packageId.name);
                 });
             });
             return set;
@@ -40338,11 +40338,11 @@ namespace ts {
             if (resolvedTypeReferenceDirectives) {
                 // populate reverse mapping: file path -> type reference directive that was resolved to this file
                 fileToDirective = new Map<string, string>();
-                resolvedTypeReferenceDirectives.forEach((resolvedDirective, key) => {
-                    if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
+                resolvedTypeReferenceDirectives.forEach(({ resolvedTypeReferenceDirective }, key) => {
+                    if (!resolvedTypeReferenceDirective || !resolvedTypeReferenceDirective.resolvedFileName) {
                         return;
                     }
-                    const file = host.getSourceFile(resolvedDirective.resolvedFileName);
+                    const file = host.getSourceFile(resolvedTypeReferenceDirective.resolvedFileName);
                     if (file) {
                         // Add the transitive closure of path references loaded by this file (as long as they are not)
                         // part of an existing type reference.

src/compiler/commandLineParser.ts

@@ -280,6 +280,13 @@ namespace ts {
             isCommandLineOnly: true,
             description: Diagnostics.The_locale_used_when_displaying_messages_to_the_user_e_g_en_us
         },
+        {
+            name: "cleanPersistedProgram",
+            type: "boolean",
+            isCommandLineOnly: true,
+            category: Diagnostics.Modules,
+            description: Diagnostics.Clean_persisted_program_information_in_tsbuildinfo_file,
+        },
     ];
 
     /* @internal */
@@ -967,6 +974,13 @@ namespace ts {
             // so pass --noResolve to avoid reporting missing file errors.
             transpileOptionValue: true
         },
+        {
+            name: "persistResolutions",
+            type: "boolean",
+            affectsModuleResolution: true,
+            category: Diagnostics.Modules,
+            description: Diagnostics.Save_module_and_type_reference_directive_resolution_information_in_tsbuildinfo_file,
+        },
         {
             name: "stripInternal",
             type: "boolean",

src/compiler/core.ts

@@ -848,7 +848,9 @@ namespace ts {
         return true;
     }
 
-    export function arrayIsEqualTo<T>(array1: readonly T[] | undefined, array2: readonly T[] | undefined, equalityComparer: (a: T, b: T, index: number) => boolean = equateValues): boolean {
+    export function arrayIsEqualTo<T>(array1: readonly T[] | undefined, array2: readonly T[] | undefined, equalityComparer?: (a: T, b: T, index: number) => boolean): boolean;
+    export function arrayIsEqualTo<T, U>(array1: readonly T[] | undefined, array2: readonly U[] | undefined, equalityComparer: (a: T, b: U, index: number) => boolean): boolean;
+    export function arrayIsEqualTo<T, U = T>(array1: readonly T[] | undefined, array2: readonly U[] | undefined, equalityComparer: (a: T, b: U, index: number) => boolean = equateValues as any): boolean {
         if (!array1 || !array2) {
             return array1 === array2;
         }

src/compiler/diagnosticMessages.json

@@ -4919,6 +4919,14 @@
         "code": 6257
     },
 
+    "Save module and type reference directive resolution information in '.tsbuildinfo' file.": {
+        "category": "Message",
+        "code": 6258
+    },
+    "Clean persisted program information in '.tsbuildinfo' file.": {
+        "category": "Message",
+        "code": 6259
+    },
 
     "Projects to reference": {
         "category": "Message",

src/compiler/emitter.ts

@@ -28,7 +28,8 @@ namespace ts {
             const prepends = host.getPrependNodes();
             if (sourceFiles.length || prepends.length) {
                 const bundle = factory.createBundle(sourceFiles, prepends);
-                const result = action(getOutputPathsFor(bundle, host, forceDtsEmit), bundle);
+                const outputPaths = getOutputPathsFor(bundle, host, forceDtsEmit);
+                const result = action(!onlyBuildInfo ? outputPaths : { buildInfoPath: outputPaths.buildInfoPath }, bundle);
                 if (result) {
                     return result;
                 }
@@ -385,7 +386,7 @@ namespace ts {
                 return;
             }
             const version = ts.version; // Extracted into a const so the form is stable between namespace and module
-            writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText({ bundle, program, version }), /*writeByteOrderMark*/ false);
+            writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText({ bundle: bundle && (bundle.js || bundle.dts) ? bundle : undefined, program, version }), /*writeByteOrderMark*/ false);
         }
 
         function emitJsFileOrBundle(