Api for creating program in watch mode and using builder to get incremental emit/semantic diagnostics

Jakefile.js

@@ -1199,23 +1199,12 @@ task("update-sublime", ["local", serverFile], function () {
 });
 
 var tslintRuleDir = "scripts/tslint/rules";
-var tslintRules = [
- "booleanTriviaRule",
- "debugAssertRule",
- "nextLineRule",
- "noBomRule",
- "noDoubleSpaceRule",
- "noIncrementDecrementRule",
- "noInOperatorRule",
- "noTypeAssertionWhitespaceRule",
- "objectLiteralSurroundingSpaceRule",
- "typeOperatorSpacingRule",
-];
+var tslintRules = fs.readdirSync(tslintRuleDir);
 var tslintRulesFiles = tslintRules.map(function (p) {
- return path.join(tslintRuleDir, p + ".ts");
+ return path.join(tslintRuleDir, p);
 });
 var tslintRulesOutFiles = tslintRules.map(function (p) {
- return path.join(builtLocalDirectory, "tslint/rules", p + ".js");
+ return path.join(builtLocalDirectory, "tslint/rules", p.replace(".ts", ".js"));
 });
 var tslintFormattersDir = "scripts/tslint/formatters";
 var tslintFormatters = [

src/compiler/checker.ts

@@ -749,10 +749,12 @@ namespace ts {
  return _jsxNamespace;
  }
 
- function getEmitResolver(sourceFile: SourceFile, cancellationToken: CancellationToken) {
+ function getEmitResolver(sourceFile: SourceFile, cancellationToken: CancellationToken, ignoreDiagnostics?: boolean) {
  // Ensure we have all the type information in place for this file so that all the
  // emitter questions of this resolver will return the right information.
- getDiagnostics(sourceFile, cancellationToken);
+ if (!ignoreDiagnostics) {
+ getDiagnostics(sourceFile, cancellationToken);
+ }
  return emitResolver;
  }
 

src/compiler/core.ts

@@ -1461,6 +1461,9 @@ namespace ts {
  /** Returns its argument. */
  export function identity<T>(x: T) { return x; }
 
+ /** Returns lower case string */
+ export function toLowerCase(x: string) { return x.toLowerCase(); }
+
  /** Throws an error because a function is not implemented. */
  export function notImplemented(): never {
  throw new Error("Not implemented");
@@ -2931,9 +2934,7 @@ namespace ts {
 
  export type GetCanonicalFileName = (fileName: string) => string;
  export function createGetCanonicalFileName(useCaseSensitiveFileNames: boolean): GetCanonicalFileName {
- return useCaseSensitiveFileNames
- ? ((fileName) => fileName)
- : ((fileName) => fileName.toLowerCase());
+ return useCaseSensitiveFileNames ? identity : toLowerCase;
  }
 
  /**
@@ -3058,223 +3059,10 @@ namespace ts {
 
  export function assertTypeIsNever(_: never): void { } // tslint:disable-line no-empty
 
- export interface FileAndDirectoryExistence {
- fileExists: boolean;
- directoryExists: boolean;
- }
-
- export interface CachedDirectoryStructureHost extends DirectoryStructureHost {
- /** Returns the queried result for the file exists and directory exists if at all it was done */
- addOrDeleteFileOrDirectory(fileOrDirectory: string, fileOrDirectoryPath: Path): FileAndDirectoryExistence | undefined;
- addOrDeleteFile(fileName: string, filePath: Path, eventKind: FileWatcherEventKind): void;
- clearCache(): void;
- }
-
- interface MutableFileSystemEntries {
- readonly files: string[];
- readonly directories: string[];
- }
-
  export const emptyFileSystemEntries: FileSystemEntries = {
  files: emptyArray,
  directories: emptyArray
  };
- export function createCachedDirectoryStructureHost(host: DirectoryStructureHost): CachedDirectoryStructureHost {
- const cachedReadDirectoryResult = createMap<MutableFileSystemEntries>();
- const getCurrentDirectory = memoize(() => host.getCurrentDirectory());
- const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
- return {
- useCaseSensitiveFileNames: host.useCaseSensitiveFileNames,
- newLine: host.newLine,
- readFile: (path, encoding) => host.readFile(path, encoding),
- write: s => host.write(s),
- writeFile,
- fileExists,
- directoryExists,
- createDirectory,
- getCurrentDirectory,
- getDirectories,
- readDirectory,
- addOrDeleteFileOrDirectory,
- addOrDeleteFile,
- clearCache,
- exit: code => host.exit(code)
- };
-
- function toPath(fileName: string) {
- return ts.toPath(fileName, getCurrentDirectory(), getCanonicalFileName);
- }
-
- function getCachedFileSystemEntries(rootDirPath: Path): MutableFileSystemEntries | undefined {
- return cachedReadDirectoryResult.get(rootDirPath);
- }
-
- function getCachedFileSystemEntriesForBaseDir(path: Path): MutableFileSystemEntries | undefined {
- return getCachedFileSystemEntries(getDirectoryPath(path));
- }
-
- function getBaseNameOfFileName(fileName: string) {
- return getBaseFileName(normalizePath(fileName));
- }
-
- function createCachedFileSystemEntries(rootDir: string, rootDirPath: Path) {
- const resultFromHost: MutableFileSystemEntries = {
- files: map(host.readDirectory(rootDir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/["*.*"]), getBaseNameOfFileName) || [],
- directories: host.getDirectories(rootDir) || []
- };
-
- cachedReadDirectoryResult.set(rootDirPath, resultFromHost);
- return resultFromHost;
- }
-
- /**
- * If the readDirectory result was already cached, it returns that
- * Otherwise gets result from host and caches it.
- * The host request is done under try catch block to avoid caching incorrect result
- */
- function tryReadDirectory(rootDir: string, rootDirPath: Path): MutableFileSystemEntries | undefined {
- const cachedResult = getCachedFileSystemEntries(rootDirPath);
- if (cachedResult) {
- return cachedResult;
- }
-
- try {
- return createCachedFileSystemEntries(rootDir, rootDirPath);
- }
- catch (_e) {
- // If there is exception to read directories, dont cache the result and direct the calls to host
- Debug.assert(!cachedReadDirectoryResult.has(rootDirPath));
- return undefined;
- }
- }
-
- function fileNameEqual(name1: string, name2: string) {
- return getCanonicalFileName(name1) === getCanonicalFileName(name2);
- }
-
- function hasEntry(entries: ReadonlyArray<string>, name: string) {
- return some(entries, file => fileNameEqual(file, name));
- }
-
- function updateFileSystemEntry(entries: string[], baseName: string, isValid: boolean) {
- if (hasEntry(entries, baseName)) {
- if (!isValid) {
- return filterMutate(entries, entry => !fileNameEqual(entry, baseName));
- }
- }
- else if (isValid) {
- return entries.push(baseName);
- }
- }
-
- function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void {
- const path = toPath(fileName);
- const result = getCachedFileSystemEntriesForBaseDir(path);
- if (result) {
- updateFilesOfFileSystemEntry(result, getBaseNameOfFileName(fileName), /*fileExists*/ true);
- }
- return host.writeFile(fileName, data, writeByteOrderMark);
- }
-
- function fileExists(fileName: string): boolean {
- const path = toPath(fileName);
- const result = getCachedFileSystemEntriesForBaseDir(path);
- return result && hasEntry(result.files, getBaseNameOfFileName(fileName)) ||
- host.fileExists(fileName);
- }
-
- function directoryExists(dirPath: string): boolean {
- const path = toPath(dirPath);
- return cachedReadDirectoryResult.has(path) || host.directoryExists(dirPath);
- }
-
- function createDirectory(dirPath: string) {
- const path = toPath(dirPath);
- const result = getCachedFileSystemEntriesForBaseDir(path);
- const baseFileName = getBaseNameOfFileName(dirPath);
- if (result) {
- updateFileSystemEntry(result.directories, baseFileName, /*isValid*/ true);
- }
- host.createDirectory(dirPath);
- }
-
- function getDirectories(rootDir: string): string[] {
- const rootDirPath = toPath(rootDir);
- const result = tryReadDirectory(rootDir, rootDirPath);
- if (result) {
- return result.directories.slice();
- }
- return host.getDirectories(rootDir);
- }
-
- function readDirectory(rootDir: string, extensions?: ReadonlyArray<string>, excludes?: ReadonlyArray<string>, includes?: ReadonlyArray<string>, depth?: number): string[] {
- const rootDirPath = toPath(rootDir);
- const result = tryReadDirectory(rootDir, rootDirPath);
- if (result) {
- return matchFiles(rootDir, extensions, excludes, includes, host.useCaseSensitiveFileNames, getCurrentDirectory(), depth, getFileSystemEntries);
- }
- return host.readDirectory(rootDir, extensions, excludes, includes, depth);
-
- function getFileSystemEntries(dir: string) {
- const path = toPath(dir);
- if (path === rootDirPath) {
- return result;
- }
- return tryReadDirectory(dir, path) || emptyFileSystemEntries;
- }
- }
-
- function addOrDeleteFileOrDirectory(fileOrDirectory: string, fileOrDirectoryPath: Path) {
- const existingResult = getCachedFileSystemEntries(fileOrDirectoryPath);
- if (existingResult) {
- // Just clear the cache for now
- // For now just clear the cache, since this could mean that multiple level entries might need to be re-evaluated
- clearCache();
- }
- else {
- // This was earlier a file (hence not in cached directory contents)
- // or we never cached the directory containing it
- const parentResult = getCachedFileSystemEntriesForBaseDir(fileOrDirectoryPath);
- if (parentResult) {
- const baseName = getBaseNameOfFileName(fileOrDirectory);
- if (parentResult) {
- const fsQueryResult: FileAndDirectoryExistence = {
- fileExists: host.fileExists(fileOrDirectoryPath),
- directoryExists: host.directoryExists(fileOrDirectoryPath)
- };
- if (fsQueryResult.directoryExists || hasEntry(parentResult.directories, baseName)) {
- // Folder added or removed, clear the cache instead of updating the folder and its structure
- clearCache();
- }
- else {
- // No need to update the directory structure, just files
- updateFilesOfFileSystemEntry(parentResult, baseName, fsQueryResult.fileExists);
- }
- return fsQueryResult;
- }
- }
- }
- }
-
- function addOrDeleteFile(fileName: string, filePath: Path, eventKind: FileWatcherEventKind) {
- if (eventKind === FileWatcherEventKind.Changed) {
- return;
- }
-
- const parentResult = getCachedFileSystemEntriesForBaseDir(filePath);
- if (parentResult) {
- updateFilesOfFileSystemEntry(parentResult, getBaseNameOfFileName(fileName), eventKind === FileWatcherEventKind.Created);
- }
- }
-
- function updateFilesOfFileSystemEntry(parentResult: MutableFileSystemEntries, baseName: string, fileExists: boolean) {
- updateFileSystemEntry(parentResult.files, baseName, fileExists);
- }
-
- function clearCache() {
- cachedReadDirectoryResult.clear();
- }
- }
 
  export function singleElementArray<T>(t: T | undefined): T[] | undefined {
  return t === undefined ? undefined : [t];

src/compiler/declarationEmitter.ts

@@ -2000,7 +2000,7 @@ namespace ts {
  export function writeDeclarationFile(declarationFilePath: string, sourceFileOrBundle: SourceFile | Bundle, host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, emitOnlyDtsFiles: boolean) {
  const emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFileOrBundle, emitOnlyDtsFiles);
  const emitSkipped = emitDeclarationResult.reportedDeclarationError || host.isEmitBlocked(declarationFilePath) || host.getCompilerOptions().noEmit;
- if (!emitSkipped) {
+ if (!emitSkipped || emitOnlyDtsFiles) {
  const sourceFiles = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle.sourceFiles : [sourceFileOrBundle];
  const declarationOutput = emitDeclarationResult.referencesOutput
  + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo);

src/compiler/program.ts

@@ -1,7 +1,6 @@
 /// <reference path="sys.ts" />
 /// <reference path="emitter.ts" />
 /// <reference path="core.ts" />
-/// <reference path="builder.ts" />
 
 namespace ts {
  const ignoreDiagnosticCommentRegEx = /(^\s*$)|(^\s*\/\/\/?\s*(@ts-ignore)?)/;
@@ -1141,32 +1140,34 @@ namespace ts {
  function emitWorker(program: Program, sourceFile: SourceFile, writeFileCallback: WriteFileCallback, cancellationToken: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult {
  let declarationDiagnostics: ReadonlyArray<Diagnostic> = [];
 
- if (options.noEmit) {
- return { diagnostics: declarationDiagnostics, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true };
- }
-
- // If the noEmitOnError flag is set, then check if we have any errors so far. If so,
- // immediately bail out. Note that we pass 'undefined' for 'sourceFile' so that we
- // get any preEmit diagnostics, not just the ones
- if (options.noEmitOnError) {
- const diagnostics = [
- ...program.getOptionsDiagnostics(cancellationToken),
- ...program.getSyntacticDiagnostics(sourceFile, cancellationToken),
- ...program.getGlobalDiagnostics(cancellationToken),
- ...program.getSemanticDiagnostics(sourceFile, cancellationToken)
- ];
-
- if (diagnostics.length === 0 && program.getCompilerOptions().declaration) {
- declarationDiagnostics = program.getDeclarationDiagnostics(/*sourceFile*/ undefined, cancellationToken);
+ if (!emitOnlyDtsFiles) {
+ if (options.noEmit) {
+ return { diagnostics: declarationDiagnostics, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true };
  }
 
- if (diagnostics.length > 0 || declarationDiagnostics.length > 0) {
- return {
- diagnostics: concatenate(diagnostics, declarationDiagnostics),
- sourceMaps: undefined,
- emittedFiles: undefined,
- emitSkipped: true
- };
+ // If the noEmitOnError flag is set, then check if we have any errors so far. If so,
+ // immediately bail out. Note that we pass 'undefined' for 'sourceFile' so that we
+ // get any preEmit diagnostics, not just the ones
+ if (options.noEmitOnError) {
+ const diagnostics = [
+ ...program.getOptionsDiagnostics(cancellationToken),
+ ...program.getSyntacticDiagnostics(sourceFile, cancellationToken),
+ ...program.getGlobalDiagnostics(cancellationToken),
+ ...program.getSemanticDiagnostics(sourceFile, cancellationToken)
+ ];
+
+ if (diagnostics.length === 0 && program.getCompilerOptions().declaration) {
+ declarationDiagnostics = program.getDeclarationDiagnostics(/*sourceFile*/ undefined, cancellationToken);
+ }
+
+ if (diagnostics.length > 0 || declarationDiagnostics.length > 0) {
+ return {
+ diagnostics: concatenate(diagnostics, declarationDiagnostics),
+ sourceMaps: undefined,
+ emittedFiles: undefined,
+ emitSkipped: true
+ };
+ }
  }
  }
 
@@ -1178,7 +1179,7 @@ namespace ts {
  // This is because in the -out scenario all files need to be emitted, and therefore all
  // files need to be type checked. And the way to specify that all files need to be type
  // checked is to not pass the file to getEmitResolver.
- const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);
+ const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile, cancellationToken, emitOnlyDtsFiles);
 
  performance.mark("beforeEmit");