Merge branch 'master' into watchOptions

Author: sheetalkamat

src/compiler/checker.ts

@@ -187,7 +187,7 @@ namespace ts {
             description: Diagnostics.Generates_corresponding_d_ts_file,
         },
         {
-            name: "emitDeclarationsOnly",
+            name: "emitDeclarationOnly",
             type: "boolean",
             category: Diagnostics.Advanced_Options,
             description: Diagnostics.Only_emit_d_ts_declaration_files,

src/compiler/commandLineParser.ts

@@ -2989,7 +2989,7 @@ namespace ts {
      */
     export function matchedText(pattern: Pattern, candidate: string): string {
         Debug.assert(isPatternMatch(pattern, candidate));
-        return candidate.substr(pattern.prefix.length, candidate.length - pattern.suffix.length);
+        return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);
     }
 
     /** Return the object corresponding to the best pattern to match `candidate`. */

src/compiler/core.ts

@@ -135,7 +135,7 @@ namespace ts {
 
         function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle) {
             // Make sure not to write js file and source map file if any of them cannot be written
-            if (!host.isEmitBlocked(jsFilePath) && !compilerOptions.noEmit && !compilerOptions.emitDeclarationsOnly) {
+            if (!host.isEmitBlocked(jsFilePath) && !compilerOptions.noEmit && !compilerOptions.emitDeclarationOnly) {
                 if (!emitOnlyDtsFiles) {
                     printSourceFileOrBundle(jsFilePath, sourceMapFilePath, sourceFileOrBundle);
                 }

src/compiler/emitter.ts

@@ -2986,7 +2986,7 @@ namespace ts {
                 return parseFunctionOrConstructorType(SyntaxKind.ConstructorType);
             }
             const type = parseUnionTypeOrHigher();
-            if (!noConditionalTypes && parseOptional(SyntaxKind.ExtendsKeyword)) {
+            if (!noConditionalTypes && !scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.ExtendsKeyword)) {
                 const node = <ConditionalTypeNode>createNode(SyntaxKind.ConditionalType, type.pos);
                 node.checkType = type;
                 // The type following 'extends' is not permitted to be another conditional type

src/compiler/parser.ts

@@ -2201,13 +2201,13 @@ namespace ts {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs"));
             }
 
-            if (options.emitDeclarationsOnly) {
+            if (options.emitDeclarationOnly) {
                 if (!options.declaration) {
-                    createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDeclarationsOnly", "declarations");
+                    createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDeclarationOnly", "declarations");
                 }
 
                 if (options.noEmit) {
-                    createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "emitDeclarationsOnly", "noEmit");
+                    createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "emitDeclarationOnly", "noEmit");
                 }
             }
 
@@ -2233,7 +2233,7 @@ namespace ts {
                 const emitHost = getEmitHost();
                 const emitFilesSeen = createMap<true>();
                 forEachEmittedFile(emitHost, (emitFileNames) => {
-                    if (!options.emitDeclarationsOnly) {
+                    if (!options.emitDeclarationOnly) {
                         verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen);
                     }
                     verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen);

src/compiler/program.ts

@@ -1638,7 +1638,7 @@ namespace ts {
         multiLine?: boolean;
     }
 
-    export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression | ParenthesizedExpression;
+    export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
     export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
 
     export interface PropertyAccessExpression extends MemberExpression, NamedDeclaration {
@@ -2027,6 +2027,7 @@ namespace ts {
 
     export interface ClassDeclaration extends ClassLikeDeclarationBase, DeclarationStatement {
         kind: SyntaxKind.ClassDeclaration;
+        /** May be undefined in `export default class { ... }`. */
         name?: Identifier;
     }
 
@@ -3310,6 +3311,7 @@ namespace ts {
         immediateTarget?: Symbol;           // Immediate target of an alias. May be another alias. Do not access directly, use `checker.getImmediateAliasedSymbol` instead.
         target?: Symbol;                    // Resolved (non-alias) target of an alias
         type?: Type;                        // Type of value symbol
+        uniqueESSymbolType?: Type;          // UniqueESSymbol type for a symbol
         declaredType?: Type;                // Type of class, interface, enum, type alias, or type parameter
         typeParameters?: TypeParameter[];   // Type parameters of type alias (undefined if non-generic)
         outerTypeParameters?: TypeParameter[];  // Outer type parameters of anonymous object type
@@ -3903,6 +3905,7 @@ namespace ts {
     }
 
     export const enum InferenceFlags {
+        None            =      0,  // No special inference behaviors
         InferUnionTypes = 1 << 0,  // Infer union types for disjoint candidates (otherwise unknownType)
         NoDefault       = 1 << 1,  // Infer unknownType for no inferences (otherwise anyType or emptyObjectType)
         AnyDefault      = 1 << 2,  // Infer anyType for no inferences (otherwise emptyObjectType)
@@ -4024,7 +4027,7 @@ namespace ts {
         /** configFile is set as non enumerable property so as to avoid checking of json source files */
         /* @internal */ readonly configFile?: JsonSourceFile;
         declaration?: boolean;
-        emitDeclarationsOnly?: boolean;
+        emitDeclarationOnly?: boolean;
         declarationDir?: string;
         /* @internal */ diagnostics?: boolean;
         /* @internal */ extendedDiagnostics?: boolean;

src/compiler/types.ts

@@ -3286,7 +3286,7 @@ namespace ts {
             && isClassLike(node.parent.parent);
     }
 
-    export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
+    export function isEntityNameExpression(node: Node): node is EntityNameExpression {
         return node.kind === SyntaxKind.Identifier ||
             node.kind === SyntaxKind.PropertyAccessExpression && isEntityNameExpression((<PropertyAccessExpression>node).expression);
     }

src/compiler/utilities.ts

@@ -420,6 +420,8 @@ namespace ts {
         }
     }
 
+    const initialVersion = 1;
+
     /**
      * Creates the watch from the host for root files and compiler options
      */
@@ -429,19 +431,25 @@ namespace ts {
      */
     export function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfConfigFile<T>): WatchOfConfigFile<T>;
     export function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfFilesAndCompilerOptions<T> & WatchCompilerHostOfConfigFile<T>): WatchOfFilesAndCompilerOptions<T> | WatchOfConfigFile<T> {
-        interface HostFileInfo {
+        interface FilePresentOnHost {
             version: number;
             sourceFile: SourceFile;
             fileWatcher: FileWatcher;
         }
+        type FileMissingOnHost = number;
+        interface FilePresenceUnknownOnHost {
+            version: number;
+        }
+        type FileMayBePresentOnHost = FilePresentOnHost | FilePresenceUnknownOnHost;
+        type HostFileInfo = FilePresentOnHost | FileMissingOnHost | FilePresenceUnknownOnHost;
 
         let builderProgram: T;
         let reloadLevel: ConfigFileProgramReloadLevel;                      // level to indicate if the program needs to be reloaded from config file/just filenames etc
         let missingFilesMap: Map<FileWatcher>;                              // Map of file watchers for the missing files
         let watchedWildcardDirectories: Map<WildcardDirectoryWatcher>;      // map of watchers for the wild card directories in the config file
         let timerToUpdateProgram: any;                                      // timer callback to recompile the program
 
-        const sourceFilesCache = createMap<HostFileInfo | string>();        // Cache that stores the source file and version info
+        const sourceFilesCache = createMap<HostFileInfo>();                 // Cache that stores the source file and version info
         let missingFilePathsRequestedForRelease: Path[];                    // These paths are held temparirly so that we can remove the entry from source file cache if the file is not tracked by missing files
         let hasChangedCompilerOptions = false;                              // True if the compiler options have changed between compilations
         let hasChangedAutomaticTypeDirectiveNames = false;                  // True if the automatic type directives have changed
@@ -629,11 +637,20 @@ namespace ts {
             return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
         }
 
+        function isFileMissingOnHost(hostSourceFile: HostFileInfo): hostSourceFile is FileMissingOnHost {
+            return typeof hostSourceFile === "number";
+        }
+
+        function isFilePresentOnHost(hostSourceFile: FileMayBePresentOnHost): hostSourceFile is FilePresentOnHost {
+            return !!(hostSourceFile as FilePresentOnHost).sourceFile;
+        }
+
         function fileExists(fileName: string) {
             const path = toPath(fileName);
-            const hostSourceFileInfo = sourceFilesCache.get(path);
-            if (hostSourceFileInfo !== undefined) {
-                return !isString(hostSourceFileInfo);
+            // If file is missing on host from cache, we can definitely say file doesnt exist
+            // otherwise we need to ensure from the disk
+            if (isFileMissingOnHost(sourceFilesCache.get(path))) {
+                return true;
             }
 
             return directoryStructureHost.fileExists(fileName);
@@ -642,39 +659,42 @@ namespace ts {
         function getVersionedSourceFileByPath(fileName: string, path: Path, languageVersion: ScriptTarget, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile {
             const hostSourceFile = sourceFilesCache.get(path);
             // No source file on the host
-            if (isString(hostSourceFile)) {
+            if (isFileMissingOnHost(hostSourceFile)) {
                 return undefined;
             }
 
             // Create new source file if requested or the versions dont match
-            if (!hostSourceFile || shouldCreateNewSourceFile || hostSourceFile.version.toString() !== hostSourceFile.sourceFile.version) {
+            if (!hostSourceFile || shouldCreateNewSourceFile || !isFilePresentOnHost(hostSourceFile) || hostSourceFile.version.toString() !== hostSourceFile.sourceFile.version) {
                 const sourceFile = getNewSourceFile();
                 if (hostSourceFile) {
                     if (shouldCreateNewSourceFile) {
                         hostSourceFile.version++;
                     }
+
                     if (sourceFile) {
-                        hostSourceFile.sourceFile = sourceFile;
+                        // Set the source file and create file watcher now that file was present on the disk
+                        (hostSourceFile as FilePresentOnHost).sourceFile = sourceFile;
                         sourceFile.version = hostSourceFile.version.toString();
-                        if (!hostSourceFile.fileWatcher) {
-                            hostSourceFile.fileWatcher = watchFilePath(host, fileName, onSourceFileChange, PollingInterval.Low, path);
+                        if (!(hostSourceFile as FilePresentOnHost).fileWatcher) {
+                            (hostSourceFile as FilePresentOnHost).fileWatcher = watchFilePath(host, fileName, onSourceFileChange, PollingInterval.Low, path);
                         }
                     }
                     else {
                         // There is no source file on host any more, close the watch, missing file paths will track it
-                        hostSourceFile.fileWatcher.close();
-                        sourceFilesCache.set(path, hostSourceFile.version.toString());
+                        if (isFilePresentOnHost(hostSourceFile)) {
+                            hostSourceFile.fileWatcher.close();
+                        }
+                        sourceFilesCache.set(path, hostSourceFile.version);
                     }
                 }
                 else {
-                    let fileWatcher: FileWatcher;
                     if (sourceFile) {
-                        sourceFile.version = "1";
-                        fileWatcher = watchFilePath(host, fileName, onSourceFileChange, PollingInterval.Low, path);
-                        sourceFilesCache.set(path, { sourceFile, version: 1, fileWatcher });
+                        sourceFile.version = initialVersion.toString();
+                        const fileWatcher = watchFilePath(host, fileName, onSourceFileChange, PollingInterval.Low, path);
+                        sourceFilesCache.set(path, { sourceFile, version: initialVersion, fileWatcher });
                     }
                     else {
-                        sourceFilesCache.set(path, "0");
+                        sourceFilesCache.set(path, initialVersion);
                     }
                 }
                 return sourceFile;
@@ -699,20 +719,22 @@ namespace ts {
             }
         }
 
-        function removeSourceFile(path: Path) {
+        function nextSourceFileVersion(path: Path) {
             const hostSourceFile = sourceFilesCache.get(path);
             if (hostSourceFile !== undefined) {
-                if (!isString(hostSourceFile)) {
-                    hostSourceFile.fileWatcher.close();
-                    resolutionCache.invalidateResolutionOfFile(path);
+                if (isFileMissingOnHost(hostSourceFile)) {
+                    // The next version, lets set it as presence unknown file
+                    sourceFilesCache.set(path, { version: Number(hostSourceFile) + 1 });
+                }
+                else {
+                    hostSourceFile.version++;
                 }
-                sourceFilesCache.delete(path);
             }
         }
 
         function getSourceVersion(path: Path): string {
             const hostSourceFile = sourceFilesCache.get(path);
-            return !hostSourceFile || isString(hostSourceFile) ? undefined : hostSourceFile.version.toString();
+            return !hostSourceFile || isFileMissingOnHost(hostSourceFile) ? undefined : hostSourceFile.version.toString();
         }
 
         function onReleaseOldSourceFile(oldSourceFile: SourceFile, _oldOptions: CompilerOptions) {
@@ -723,10 +745,10 @@ namespace ts {
             // there was version update and new source file was created.
             if (hostSourceFileInfo) {
                 // record the missing file paths so they can be removed later if watchers arent tracking them
-                if (isString(hostSourceFileInfo)) {
+                if (isFileMissingOnHost(hostSourceFileInfo)) {
                     (missingFilePathsRequestedForRelease || (missingFilePathsRequestedForRelease = [])).push(oldSourceFile.path);
                 }
-                else if (hostSourceFileInfo.sourceFile === oldSourceFile) {
+                else if ((hostSourceFileInfo as FilePresentOnHost).sourceFile === oldSourceFile) {
                     sourceFilesCache.delete(oldSourceFile.path);
                     resolutionCache.removeResolutionsOfFile(oldSourceFile.path);
                 }
@@ -810,27 +832,12 @@ namespace ts {
 
         function onSourceFileChange(fileName: string, eventKind: FileWatcherEventKind, path: Path) {
             updateCachedSystemWithFile(fileName, path, eventKind);
-            const hostSourceFile = sourceFilesCache.get(path);
-            if (hostSourceFile) {
-                // Update the cache
-                if (eventKind === FileWatcherEventKind.Deleted) {
-                    resolutionCache.invalidateResolutionOfFile(path);
-                    if (!isString(hostSourceFile)) {
-                        hostSourceFile.fileWatcher.close();
-                        sourceFilesCache.set(path, (++hostSourceFile.version).toString());
-                    }
-                }
-                else {
-                    // Deleted file created
-                    if (isString(hostSourceFile)) {
-                        sourceFilesCache.delete(path);
-                    }
-                    else {
-                        // file changed - just update the version
-                        hostSourceFile.version++;
-                    }
-                }
+
+            // Update the source file cache
+            if (eventKind === FileWatcherEventKind.Deleted && sourceFilesCache.get(path)) {
+                resolutionCache.invalidateResolutionOfFile(path);
             }
+            nextSourceFileVersion(path);
 
             // Update the program
             scheduleProgramUpdate();
@@ -858,7 +865,7 @@ namespace ts {
                 missingFilesMap.delete(missingFilePath);
 
                 // Delete the entry in the source files cache so that new source file is created
-                removeSourceFile(missingFilePath);
+                nextSourceFileVersion(missingFilePath);
 
                 // When a missing file is created, we should update the graph.
                 scheduleProgramUpdate();
@@ -887,17 +894,10 @@ namespace ts {
                     const fileOrDirectoryPath = toPath(fileOrDirectory);
 
                     // Since the file existance changed, update the sourceFiles cache
-                    const result = cachedDirectoryStructureHost && cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
-
-                    // Instead of deleting the file, mark it as changed instead
-                    // Many times node calls add/remove/file when watching directories recursively
-                    const hostSourceFile = sourceFilesCache.get(fileOrDirectoryPath);
-                    if (hostSourceFile && !isString(hostSourceFile) && (result ? result.fileExists : directoryStructureHost.fileExists(fileOrDirectory))) {
-                        hostSourceFile.version++;
-                    }
-                    else {
-                        removeSourceFile(fileOrDirectoryPath);
+                    if (cachedDirectoryStructureHost) {
+                        cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
                     }
+                    nextSourceFileVersion(fileOrDirectoryPath);
 
                     // If the the added or created file or directory is not supported file name, ignore the file
                     // But when watched directory is added/removed, we need to reload the file list