Lazy calculation of expensive file explaining diagnsotics and some caching to be used to share the diagnostic data

src/compiler/types.ts

@@ -4608,26 +4608,24 @@ export type FileIncludeReason =
 
 /** @internal */
 export const enum FilePreprocessingDiagnosticsKind {
- FilePreprocessingReferencedDiagnostic,
+ FilePreprocessingLibReferenceDiagnostic,
  FilePreprocessingFileExplainingDiagnostic,
  ResolutionDiagnostics,
 }
 
 /** @internal */
-export interface FilePreprocessingReferencedDiagnostic {
- kind: FilePreprocessingDiagnosticsKind.FilePreprocessingReferencedDiagnostic;
- reason: ReferencedFile;
- diagnostic: DiagnosticMessage;
- args?: DiagnosticArguments;
+export interface FilePreprocessingLibReferenceDiagnostic {
+ kind: FilePreprocessingDiagnosticsKind.FilePreprocessingLibReferenceDiagnostic;
+ reason: ReferencedFile & { kind: FileIncludeKind.LibReferenceDirective; };
 }
 
 /** @internal */
 export interface FilePreprocessingFileExplainingDiagnostic {
  kind: FilePreprocessingDiagnosticsKind.FilePreprocessingFileExplainingDiagnostic;
- file?: Path;
+ file: Path | undefined;
  fileProcessingReason: FileIncludeReason;
  diagnostic: DiagnosticMessage;
- args?: DiagnosticArguments;
+ args: DiagnosticArguments;
 }
 
 /** @internal */
@@ -4637,7 +4635,7 @@ export interface ResolutionDiagnostics {
 }
 
 /** @internal */
-export type FilePreprocessingDiagnostics = FilePreprocessingReferencedDiagnostic | FilePreprocessingFileExplainingDiagnostic | ResolutionDiagnostics;
+export type FilePreprocessingDiagnostics = FilePreprocessingLibReferenceDiagnostic | FilePreprocessingFileExplainingDiagnostic | ResolutionDiagnostics;
 
 /** @internal */
 export const enum EmitOnly {

src/compiler/watchPublic.ts

@@ -594,6 +594,7 @@ export function createWatchProgram<T extends BuilderProgram>(host: WatchCompiler
  });
  parsedConfigs = undefined;
  }
+ builderProgram = undefined!;
  }
 
  function getResolutionCache() {

src/testRunner/unittests/helpers.ts

@@ -21,6 +21,7 @@ export interface NamedSourceText {
 export interface ProgramWithSourceTexts extends ts.Program {
  sourceTexts?: readonly NamedSourceText[];
  host: TestCompilerHost;
+ version: number;
 }
 
 export interface TestCompilerHost extends ts.CompilerHost {
@@ -102,7 +103,7 @@ function createSourceFileWithText(fileName: string, sourceText: SourceText, targ
  return file;
 }
 
-export function createTestCompilerHost(texts: readonly NamedSourceText[], target: ts.ScriptTarget, oldProgram?: ProgramWithSourceTexts, useGetSourceFileByPath?: boolean) {
+export function createTestCompilerHost(texts: readonly NamedSourceText[], target: ts.ScriptTarget, oldProgram?: ProgramWithSourceTexts, useGetSourceFileByPath?: boolean, useCaseSensitiveFileNames?: boolean) {
  const files = ts.arrayToMap(texts, t => t.name, t => {
  if (oldProgram) {
  let oldFile = oldProgram.getSourceFile(t.name) as SourceFileWithText;
@@ -115,52 +116,64 @@ export function createTestCompilerHost(texts: readonly NamedSourceText[], target
  }
  return createSourceFileWithText(t.name, t.text, target);
  });
- const useCaseSensitiveFileNames = ts.sys && ts.sys.useCaseSensitiveFileNames;
+ if (useCaseSensitiveFileNames === undefined) useCaseSensitiveFileNames = ts.sys && ts.sys.useCaseSensitiveFileNames;
  const getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
+ const filesByPath = ts.mapEntries(files, (fileName, file) => [ts.toPath(fileName, "", getCanonicalFileName), file]);
  const trace: string[] = [];
  const result: TestCompilerHost = {
  trace: s => trace.push(s),
  getTrace: () => trace,
  clearTrace: () => trace.length = 0,
- getSourceFile: fileName => files.get(fileName),
+ getSourceFile: fileName => filesByPath.get(ts.toPath(fileName, "", getCanonicalFileName)),
  getDefaultLibFileName: () => "lib.d.ts",
  writeFile: ts.notImplemented,
  getCurrentDirectory: () => "",
  getDirectories: () => [],
  getCanonicalFileName,
  useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
  getNewLine: () => ts.sys ? ts.sys.newLine : newLine,
- fileExists: fileName => files.has(fileName),
+ fileExists: fileName => filesByPath.has(ts.toPath(fileName, "", getCanonicalFileName)),
  readFile: fileName => {
- const file = files.get(fileName);
+ const file = filesByPath.get(ts.toPath(fileName, "", getCanonicalFileName));
  return file && file.text;
  },
  };
  if (useGetSourceFileByPath) {
- const filesByPath = ts.mapEntries(files, (fileName, file) => [ts.toPath(fileName, "", getCanonicalFileName), file]);
  result.getSourceFileByPath = (_fileName, path) => filesByPath.get(path);
  }
  return result;
 }
 
-export function newProgram(texts: NamedSourceText[], rootNames: string[], options: ts.CompilerOptions, useGetSourceFileByPath?: boolean): ProgramWithSourceTexts {
- const host = createTestCompilerHost(texts, options.target!, /*oldProgram*/ undefined, useGetSourceFileByPath);
- const program = ts.createProgram(rootNames, options, host) as ProgramWithSourceTexts;
- program.sourceTexts = texts;
- program.host = host;
- return program;
+export function newProgram(texts: NamedSourceText[], rootNames: string[], options: ts.CompilerOptions, useGetSourceFileByPath?: boolean, useCaseSensitiveFileNames?: boolean): ProgramWithSourceTexts {
+ const host = createTestCompilerHost(texts, options.target!, /*oldProgram*/ undefined, useGetSourceFileByPath, useCaseSensitiveFileNames);
+ return programToProgramWithSourceTexts(
+ ts.createProgram(rootNames, options, host),
+ texts,
+ host,
+ 1,
+ );
 }
 
-export function updateProgram(oldProgram: ProgramWithSourceTexts, rootNames: readonly string[], options: ts.CompilerOptions, updater: (files: NamedSourceText[]) => void, newTexts?: NamedSourceText[], useGetSourceFileByPath?: boolean) {
+function programToProgramWithSourceTexts(program: ts.Program, texts: NamedSourceText[], host: TestCompilerHost, version: number): ProgramWithSourceTexts {
+ const result = program as ProgramWithSourceTexts;
+ result.sourceTexts = texts;
+ result.host = host;
+ result.version = version;
+ return result;
+}
+
+export function updateProgram(oldProgram: ProgramWithSourceTexts, rootNames: readonly string[], options: ts.CompilerOptions, updater: (files: NamedSourceText[]) => void, newTexts?: NamedSourceText[], useGetSourceFileByPath?: boolean, useCaseSensitiveFileNames?: boolean) {
  if (!newTexts) {
  newTexts = oldProgram.sourceTexts!.slice(0);
  }
  updater(newTexts);
- const host = createTestCompilerHost(newTexts, options.target!, oldProgram, useGetSourceFileByPath);
- const program = ts.createProgram(rootNames, options, host, oldProgram) as ProgramWithSourceTexts;
- program.sourceTexts = newTexts;
- program.host = host;
- return program;
+ const host = createTestCompilerHost(newTexts, options.target!, oldProgram, useGetSourceFileByPath, useCaseSensitiveFileNames);
+ return programToProgramWithSourceTexts(
+ ts.createProgram(rootNames, options, host, oldProgram),
+ newTexts,
+ host,
+ oldProgram.version + 1,
+ );
 }
 
 export function updateProgramText(files: readonly NamedSourceText[], fileName: string, newProgramText: string) {

src/testRunner/unittests/helpers/forceConsistentCasingInFileNames.ts

@@ -0,0 +1,33 @@
+import { dedent } from "../../_namespaces/Utils";
+import { jsonToReadableText } from "../helpers";
+import {
+ FsContents,
+ libContent,
+} from "./contents";
+import { libFile } from "./virtualFileSystemWithWatch";
+
+export function getFsContentsForMultipleErrorsForceConsistentCasingInFileNames(): FsContents {
+ return {
+ "/home/src/projects/project/src/struct.d.ts": dedent`
+ import * as xs1 from "fp-ts/lib/Struct";
+ import * as xs2 from "fp-ts/lib/struct";
+ import * as xs3 from "./Struct";
+ import * as xs4 from "./struct";
+ `,
+ "/home/src/projects/project/src/anotherFile.ts": dedent`
+ import * as xs1 from "fp-ts/lib/Struct";
+ import * as xs2 from "fp-ts/lib/struct";
+ import * as xs3 from "./Struct";
+ import * as xs4 from "./struct";
+ `,
+ "/home/src/projects/project/src/oneMore.ts": dedent`
+ import * as xs1 from "fp-ts/lib/Struct";
+ import * as xs2 from "fp-ts/lib/struct";
+ import * as xs3 from "./Struct";
+ import * as xs4 from "./struct";
+ `,
+ "/home/src/projects/project/tsconfig.json": jsonToReadableText({}),
+ "/home/src/projects/project/node_modules/fp-ts/lib/struct.d.ts": `export function foo(): void`,
+ [libFile.path]: libContent,
+ };
+}

src/testRunner/unittests/helpers/libraryResolution.ts

@@ -91,3 +91,46 @@ export function getCommandLineArgsForLibResolution(withoutConfig: true | undefin
  ["project1/core.d.ts", "project1/utils.d.ts", "project1/file.ts", "project1/index.ts", "project1/file2.ts", "--lib", "es5,dom", "--traceResolution", "--explainFiles"] :
  ["-p", "project1", "--explainFiles"];
 }
+
+function getFsContentsForLibResolutionUnknown(): FsContents {
+ return {
+ "/home/src/projects/project1/utils.d.ts": `export const y = 10;`,
+ "/home/src/projects/project1/file.ts": `export const file = 10;`,
+ "/home/src/projects/project1/core.d.ts": `export const core = 10;`,
+ "/home/src/projects/project1/index.ts": `export const x = "type1";`,
+ "/home/src/projects/project1/file2.ts": dedent`
+ /// <reference lib="webworker2"/>
+ /// <reference lib="unknownlib"/>
+ /// <reference lib="scripthost"/>
+ `,
+ "/home/src/projects/project1/tsconfig.json": jsonToReadableText({
+ compilerOptions: {
+ composite: true,
+ traceResolution: true,
+ },
+ }),
+ "/home/src/lib/lib.d.ts": libContent,
+ "/home/src/lib/lib.webworker.d.ts": "interface WebWorkerInterface { }",
+ "/home/src/lib/lib.scripthost.d.ts": "interface ScriptHostInterface { }",
+ };
+}
+
+export function getFsForLibResolutionUnknown() {
+ return loadProjectFromFiles(
+ getFsContentsForLibResolutionUnknown(),
+ {
+ cwd: "/home/src/projects",
+ executingFilePath: "/home/src/lib/tsc.js",
+ },
+ );
+}
+
+export function getSysForLibResolutionUnknown() {
+ return createWatchedSystem(
+ getFsContentsForLibResolutionUnknown(),
+ {
+ currentDirectory: "/home/src/projects",
+ executingFilePath: "/home/src/lib/tsc.js",
+ },
+ );
+}