Merge branch 'master' into transitiveReferences

Author: sheetalkamat

CONTRIBUTING.md

@@ -194,6 +194,6 @@ to establish the new baselines as the desired behavior. This will change the fil
 ## Localization
 
 All strings the user may see are stored in [`diagnosticMessages.json`](./src/compiler/diagnosticMessages.json).
-If you make changes to it, run `jake generate-diagnostics` to push them to the `Diagnostic` interface in [`diagnosticInformationMap.generated.ts`](./src/compiler/diagnosticInformationMap.generated.ts).
+If you make changes to it, run `jake generate-diagnostics` to push them to the `Diagnostic` interface in `diagnosticInformationMap.generated.ts`.
 
 See [coding guidelines on diagnostic messages](https://github.com/Microsoft/TypeScript/wiki/Coding-guidelines#diagnostic-messages).

src/compiler/checker.ts

@@ -2512,11 +2512,16 @@ namespace ts {
         // via wildcard, and to handle extension priority.
         const wildcardFileMap = createMap<string>();
 
+        // Wildcard paths of json files (provided via the "includes" array in tsconfig.json) are stored in a
+        // file map with a possibly case insensitive key. We use this map to store paths matched
+        // via wildcard of *.json kind
+        const wildCardJsonFileMap = createMap<string>();
         const { filesSpecs, validatedIncludeSpecs, validatedExcludeSpecs, wildcardDirectories } = spec;
 
         // Rather than requery this for each file and filespec, we query the supported extensions
         // once and store it on the expansion context.
         const supportedExtensions = getSupportedExtensions(options, extraFileExtensions);
+        const supportedExtensionsWithJsonIfResolveJsonModule = getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
 
         // Literal files are always included verbatim. An "include" or "exclude" specification cannot
         // remove a literal file.
@@ -2527,8 +2532,25 @@ namespace ts {
             }
         }
 
+        let jsonOnlyIncludeRegexes: ReadonlyArray<RegExp> | undefined;
         if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) {
-            for (const file of host.readDirectory(basePath, supportedExtensions, validatedExcludeSpecs, validatedIncludeSpecs, /*depth*/ undefined)) {
+            for (const file of host.readDirectory(basePath, supportedExtensionsWithJsonIfResolveJsonModule, validatedExcludeSpecs, validatedIncludeSpecs, /*depth*/ undefined)) {
+                if (fileExtensionIs(file, Extension.Json)) {
+                    // Valid only if *.json specified
+                    if (!jsonOnlyIncludeRegexes) {
+                        const includes = validatedIncludeSpecs.filter(s => endsWith(s, Extension.Json));
+                        const includeFilePatterns = map(getRegularExpressionsForWildcards(includes, basePath, "files"), pattern => `^${pattern}$`);
+                        jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map(pattern => getRegexFromPattern(pattern, host.useCaseSensitiveFileNames)) : emptyArray;
+                    }
+                    const includeIndex = findIndex(jsonOnlyIncludeRegexes, re => re.test(file));
+                    if (includeIndex !== -1) {
+                        const key = keyMapper(file);
+                        if (!literalFileMap.has(key) && !wildCardJsonFileMap.has(key)) {
+                            wildCardJsonFileMap.set(key, file);
+                        }
+                    }
+                    continue;
+                }
                 // If we have already included a literal or wildcard path with a
                 // higher priority extension, we should skip this file.
                 //
@@ -2556,7 +2578,7 @@ namespace ts {
         const wildcardFiles = arrayFrom(wildcardFileMap.values());
 
         return {
-            fileNames: literalFiles.concat(wildcardFiles),
+            fileNames: literalFiles.concat(wildcardFiles, arrayFrom(wildCardJsonFileMap.values())),
             wildcardDirectories,
             spec
         };

src/compiler/commandLineParser.ts

@@ -1602,8 +1602,9 @@ namespace ts {
             return value;
         }
 
-        export function assertNever(member: never, message?: string, stackCrawlMark?: AnyFunction): never {
-            return fail(message || `Illegal value: ${member}`, stackCrawlMark || assertNever);
+        export function assertNever(member: never, message = "Illegal value:", stackCrawlMark?: AnyFunction): never {
+            const detail = "kind" in member && "pos" in member ? "SyntaxKind: " + showSyntaxKind(member as Node) : JSON.stringify(member);
+            return fail(`${message} ${detail}`, stackCrawlMark || assertNever);
         }
 
         export function getFunctionName(func: AnyFunction) {

src/compiler/core.ts

@@ -2485,10 +2485,6 @@
         "category": "Error",
         "code": 2732
     },
-    "Index '{0}' is out-of-bounds in tuple of length {1}.": {
-        "category": "Error",
-        "code": 2733
-    },
     "It is highly likely that you are missing a semicolon.": {
         "category": "Error",
         "code": 2734

src/compiler/diagnosticMessages.json

@@ -52,7 +52,9 @@ namespace ts {
         else {
             const ownOutputFilePath = getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile, options));
             // If json file emits to the same location skip writing it, if emitDeclarationOnly skip writing it
-            const jsFilePath = options.emitDeclarationOnly ? undefined : ownOutputFilePath;
+            const isJsonEmittedToSameLocation = isJsonSourceFile(sourceFile) &&
+                comparePaths(sourceFile.fileName, ownOutputFilePath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;
+            const jsFilePath = options.emitDeclarationOnly || isJsonEmittedToSameLocation ? undefined : ownOutputFilePath;
             const sourceMapFilePath = !jsFilePath || isJsonSourceFile(sourceFile) ? undefined : getSourceMapFilePath(jsFilePath, options);
             // For legacy reasons (ie, we have baselines capturing the behavior), js files don't report a .d.ts output path - this would only matter if `declaration` and `allowJs` were both on, which is currently an error
             const isJs = isSourceFileJS(sourceFile);

src/compiler/emitter.ts

@@ -1482,7 +1482,15 @@ namespace ts {
                     // which would be a candidate for improved error reporting.
                     return token() === SyntaxKind.OpenBracketToken || isLiteralPropertyName();
                 case ParsingContext.ObjectLiteralMembers:
-                    return token() === SyntaxKind.OpenBracketToken || token() === SyntaxKind.AsteriskToken || token() === SyntaxKind.DotDotDotToken || isLiteralPropertyName();
+                    switch (token()) {
+                        case SyntaxKind.OpenBracketToken:
+                        case SyntaxKind.AsteriskToken:
+                        case SyntaxKind.DotDotDotToken:
+                        case SyntaxKind.DotToken: // Not an object literal member, but don't want to close the object (see `tests/cases/fourslash/completionsDotInObjectLiteral.ts`)
+                            return true;
+                        default:
+                            return isLiteralPropertyName();
+                    }
                 case ParsingContext.RestProperties:
                     return isLiteralPropertyName();
                 case ParsingContext.ObjectBindingElements:

src/compiler/parser.ts

@@ -630,7 +630,7 @@ namespace ts {
         const programDiagnostics = createDiagnosticCollection();
         const currentDirectory = host.getCurrentDirectory();
         const supportedExtensions = getSupportedExtensions(options);
-        const supportedExtensionsWithJsonIfResolveJsonModule = options.resolveJsonModule ? [...supportedExtensions, Extension.Json] : undefined;
+        const supportedExtensionsWithJsonIfResolveJsonModule = getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
 
         // Map storing if there is emit blocking diagnostics for given input
         const hasEmitBlockingDiagnostics = createMap<boolean>();
@@ -1994,7 +1994,7 @@ namespace ts {
             refFile?: SourceFile): SourceFile | undefined {
 
             if (hasExtension(fileName)) {
-                if (!options.allowNonTsExtensions && !forEach(supportedExtensionsWithJsonIfResolveJsonModule || supportedExtensions, extension => fileExtensionIs(host.getCanonicalFileName(fileName), extension))) {
+                if (!options.allowNonTsExtensions && !forEach(supportedExtensionsWithJsonIfResolveJsonModule, extension => fileExtensionIs(host.getCanonicalFileName(fileName), extension))) {
                     if (fail) fail(Diagnostics.File_0_has_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + supportedExtensions.join("', '") + "'");
                     return undefined;
                 }
@@ -2060,6 +2060,7 @@ namespace ts {
             redirect.resolvedPath = resolvedPath;
             redirect.originalFileName = originalFileName;
             redirect.redirectInfo = { redirectTarget, unredirected };
+            sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
             Object.defineProperties(redirect, {
                 id: {
                     get(this: SourceFile) { return this.redirectInfo!.redirectTarget.id; },

src/compiler/program.ts

@@ -36,23 +36,6 @@ namespace ts {
         Low = 250
     }
 
-    function getPriorityValues(highPriorityValue: number): [number, number, number] {
-        const mediumPriorityValue = highPriorityValue * 2;
-        const lowPriorityValue = mediumPriorityValue * 4;
-        return [highPriorityValue, mediumPriorityValue, lowPriorityValue];
-    }
-
-    function pollingInterval(watchPriority: PollingInterval): number {
-        return pollingIntervalsForPriority[watchPriority];
-    }
-
-    const pollingIntervalsForPriority = getPriorityValues(250);
-
-    /* @internal */
-    export function watchFileUsingPriorityPollingInterval(host: System, fileName: string, callback: FileWatcherCallback, watchPriority: PollingInterval): FileWatcher {
-        return host.watchFile!(fileName, callback, pollingInterval(watchPriority));
-    }
-
     /* @internal */
     export type HostWatchFile = (fileName: string, callback: FileWatcherCallback, pollingInterval: PollingInterval | undefined) => FileWatcher;
     /* @internal */

src/compiler/sys.ts

@@ -4078,6 +4078,7 @@ namespace ts {
         templateType?: Type;
         modifiersType?: Type;
         resolvedApparentType?: Type;
+        instantiating?: boolean;
     }
 
     export interface EvolvingArrayType extends ObjectType {