Initial support for globs in tsconfig.json

microsoft · riknoll · Jun 20, 2016 · Dec 3, 2015 · Dec 7, 2015 · Dec 7, 2015
commit f9ae3e4f2b529a2f59a0fd0f9dae1bb01c94f9a7
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -25,6 +25,7 @@ namespace ts {
             contains,
             remove,
             forEachValue: forEachValueInMap,
+            reduce,
             clear
         };
 
@@ -34,6 +35,10 @@ namespace ts {
             }
         }
 
+        function reduce<U>(callback: (memo: U, value: T, key: Path) => U, initial: U) {
+            return reduceProperties(files, callback, initial);
+        }
+
         // path should already be well-formed so it does not need to be normalized
         function get(path: Path): T {
             return files[toKey(path)];
@@ -490,6 +495,24 @@ namespace ts {
         return a < b ? Comparison.LessThan : Comparison.GreaterThan;
     }
 
+    export function compareStrings(a: string, b: string, ignoreCase?: boolean): Comparison {
+        if (a === b) return Comparison.EqualTo;
+        if (a === undefined) return Comparison.LessThan;
+        if (b === undefined) return Comparison.GreaterThan;
+        if (ignoreCase) {
+            if (String.prototype.localeCompare) {
+                const result = a.localeCompare(b, /*locales*/ undefined, { usage: "sort", sensitivity: "accent" });
+                return result < 0 ? Comparison.LessThan : result > 0 ? Comparison.GreaterThan : Comparison.EqualTo;
+            }
+
+            a = a.toUpperCase();
+            b = b.toUpperCase();
+            if (a === b) return Comparison.EqualTo;
+        }
+
+        return a < b ? Comparison.LessThan : Comparison.GreaterThan;
+    }
+
     function getDiagnosticFileName(diagnostic: Diagnostic): string {
         return diagnostic.file ? diagnostic.file.fileName : undefined;
     }
@@ -756,6 +779,49 @@ namespace ts {
         return path1 + directorySeparator + path2;
     }
 
+    /**
+     * Removes a trailing directory separator from a path.
+     * @param path The path.
+     */
+    export function removeTrailingDirectorySeparator(path: string) {
+        if (path.charAt(path.length - 1) === directorySeparator) {
+            return path.substr(0, path.length - 1);
+        }
+
+        return path;
+    }
+
+    /**
+     * Adds a trailing directory separator to a path, if it does not already have one.
+     * @param path The path.
+     */
+    export function ensureTrailingDirectorySeparator(path: string) {
+        if (path.charAt(path.length - 1) !== directorySeparator) {
+            return path + directorySeparator;
+        }
+
+        return path;
+    }
+
+    export function comparePaths(a: string, b: string, currentDirectory: string, ignoreCase?: boolean) {
+        if (a === b) return Comparison.EqualTo;
+        if (a === undefined) return Comparison.LessThan;
+        if (b === undefined) return Comparison.GreaterThan;
+        a = removeTrailingDirectorySeparator(a);
+        b = removeTrailingDirectorySeparator(b);
+        const aComponents = getNormalizedPathComponents(a, currentDirectory);
+        const bComponents = getNormalizedPathComponents(b, currentDirectory);
+        const sharedLength = Math.min(aComponents.length, bComponents.length);
+        for (let i = 0; i < sharedLength; ++i) {
+            const result = compareStrings(aComponents[i], bComponents[i], ignoreCase);
+            if (result !== Comparison.EqualTo) {
+                return result;
+            }
+        }
+
+        return compareValues(aComponents.length, bComponents.length);
+    }
+
     export function fileExtensionIs(path: string, extension: string): boolean {
         const pathLen = path.length;
         const extLen = extension.length;
@@ -794,6 +860,10 @@ namespace ts {
         return path;
     }
 
+    export function changeExtension<T extends string | Path>(path: T, newExtension: string): T {
+        return <T>(removeFileExtension(path) + newExtension);
+    }
+
     const backslashOrDoubleQuote = /[\"\\]/g;
     const escapedCharsRegExp = /[\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
     const escapedCharsMap: Map<string> = {

diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -2020,6 +2020,10 @@
         "category": "Error",
         "code": 5009
     },
+    "File specification cannot contain multiple recursive directory wildcards ('**'): '{0}'.": {
+        "category": "Error",
+        "code": 5011
+    },
     "Cannot read file '{0}': {1}": {
         "category": "Error",
         "code": 5012

diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
@@ -17,6 +17,8 @@ namespace ts {
         getExecutingFilePath(): string;
         getCurrentDirectory(): string;
         readDirectory(path: string, extension?: string, exclude?: string[]): string[];
+        readFileNames(path: string): string[];
+        readDirectoryNames(path: string): string[];
         getMemoryUsage?(): number;
         exit(exitCode?: number): void;
     }
@@ -155,6 +157,16 @@ namespace ts {
                 }
             }
 
+            function readFileNames(path: string): string[] {
+                const folder = fso.GetFolder(path || ".");
+                return getNames(folder.files);
+            }
+
+            function readDirectoryNames(path: string): string[] {
+                const folder = fso.GetFolder(path || ".");
+                return getNames(folder.directories);
+            }
+
             return {
                 args,
                 newLine: "\r\n",
@@ -185,6 +197,8 @@ namespace ts {
                     return new ActiveXObject("WScript.Shell").CurrentDirectory;
                 },
                 readDirectory,
+                readFileNames,
+                readDirectoryNames,
                 exit(exitCode?: number): void {
                     try {
                         WScript.Quit(exitCode);
@@ -281,7 +295,7 @@ namespace ts {
             // REVIEW: for now this implementation uses polling.
             // The advantage of polling is that it works reliably
             // on all os and with network mounted files.
-            // For 90 referenced files, the average time to detect 
+            // For 90 referenced files, the average time to detect
             // changes is 2*msInterval (by default 5 seconds).
             // The overhead of this is .04 percent (1/2500) with
             // average pause of < 1 millisecond (and max
@@ -381,6 +395,30 @@ namespace ts {
                 }
             }
 
+            function readFileNames(path: string): string[] {
+                const entries = _fs.readdirSync(path || ".");
+                const files: string[] = [];
+                for (const entry of entries) {
+                    const stat = _fs.statSync(combinePaths(path, entry));
+                    if (stat.isFile()) {
+                        files.push(entry);
+                    }
+                }
+                return files.sort();
+            }
+
+            function readDirectoryNames(path: string): string[] {
+                const entries = _fs.readdirSync(path || ".");
+                const directories: string[] = [];
+                for (const entry of entries) {
+                    const stat = _fs.statSync(combinePaths(path, entry));
+                    if (stat.isDirectory()) {
+                        directories.push(entry);
+                    }
+                }
+                return directories.sort();
+            }
+
             return {
                 args: process.argv.slice(2),
                 newLine: _os.EOL,
@@ -406,7 +444,7 @@ namespace ts {
                     };
                 },
                 watchDirectory: (path, callback, recursive) => {
-                    // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows 
+                    // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
                     // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
                     return _fs.watch(
                         path,
@@ -426,7 +464,7 @@ namespace ts {
                     return _path.resolve(path);
                 },
                 fileExists(path: string): boolean {
-                    return _fs.existsSync(path);
+                    return _fs.existsSync(path) && _fs.statSync(path).isFile();
                 },
                 directoryExists(path: string) {
                     return _fs.existsSync(path) && _fs.statSync(path).isDirectory();
@@ -443,6 +481,8 @@ namespace ts {
                     return process.cwd();
                 },
                 readDirectory,
+                readFileNames,
+                readDirectoryNames,
                 getMemoryUsage() {
                     if (global.gc) {
                         global.gc();

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -14,6 +14,7 @@ namespace ts {
         remove(fileName: Path): void;
 
         forEachValue(f: (key: Path, v: T) => void): void;
+        reduce<U>(f: (memo: U, value: T, key: Path) => U, initial: U): U;
         clear(): void;
     }
 
@@ -1582,7 +1583,27 @@ namespace ts {
     }
 
     export interface ParseConfigHost {
+        useCaseSensitiveFileNames: boolean;
+
         readDirectory(rootDir: string, extension: string, exclude: string[]): string[];
+
+        /**
+          * Gets a value indicating whether the specified path exists.
+          * @param path The path to test.
+          */
+        fileExists(path: string): boolean;
+
+        /**
+         * Reads the files names in the directory.
+         * @param rootDir The directory path.
+         */
+        readFileNames(rootDir: string): string[];
+
+        /**
+         * Reads the directory names in the directory.
+         * @param rootDir The directory path.
+         */
+        readDirectoryNames(rootDir: string): string[];
     }
 
     export interface WriteFileCallback {

diff --git a/src/harness/external/chai.d.ts b/src/harness/external/chai.d.ts
@@ -167,6 +167,9 @@ declare module chai {
     module assert {
         function equal(actual: any, expected: any, message?: string): void;
         function notEqual(actual: any, expected: any, message?: string): void;
+        function deepEqual(actual: any, expected: any, message?: string): void;
+        function notDeepEqual(actual: any, expected: any, message?: string): void;
+        function lengthOf(object: any[], length: number, message?: string): void;
         function isTrue(value: any, message?: string): void;
         function isFalse(value: any, message?: string): void;
         function isNull(value: any, message?: string): void;

diff --git a/src/harness/harness.ts b/src/harness/harness.ts
@@ -1,7 +1,7 @@
 
 //
 // Copyright (c) Microsoft Corporation.  All rights reserved.
-// 
+//
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -282,7 +282,7 @@ namespace Utils {
                         break;
 
                     case "parserContextFlags":
-                        // Clear the flag that are produced by aggregating child values..  That is ephemeral 
+                        // Clear the flag that are produced by aggregating child values..  That is ephemeral
                         // data we don't care about in the dump.  We only care what the parser set directly
                         // on the ast.
                         let value = n.parserContextFlags & ts.ParserContextFlags.ParserGeneratedFlags;
@@ -356,7 +356,7 @@ namespace Utils {
         assert.equal(node1.kind, node2.kind, "node1.kind !== node2.kind");
         assert.equal(node1.flags, node2.flags, "node1.flags !== node2.flags");
 
-        // call this on both nodes to ensure all propagated flags have been set (and thus can be 
+        // call this on both nodes to ensure all propagated flags have been set (and thus can be
         // compared).
         assert.equal(ts.containsParseError(node1), ts.containsParseError(node2));
         assert.equal(node1.parserContextFlags, node2.parserContextFlags, "node1.parserContextFlags !== node2.parserContextFlags");
@@ -436,6 +436,8 @@ namespace Harness {
         getExecutingFilePath(): string;
         exit(exitCode?: number): void;
         readDirectory(path: string, extension?: string, exclude?: string[]): string[];
+        readDirectoryNames(path: string): string[];
+        readFileNames(path: string): string[];
     }
     export var IO: IO;
 
@@ -474,6 +476,8 @@ namespace Harness {
             export const fileExists: typeof IO.fileExists = fso.FileExists;
             export const log: typeof IO.log = global.WScript && global.WScript.StdOut.WriteLine;
             export const readDirectory: typeof IO.readDirectory = (path, extension, exclude) => ts.sys.readDirectory(path, extension, exclude);
+            export const readDirectoryNames: typeof IO.readDirectoryNames = path => ts.sys.readDirectoryNames(path);
+            export const readFileNames: typeof IO.readFileNames = path => ts.sys.readFileNames(path);
 
             export function createDirectory(path: string) {
                 if (directoryExists(path)) {
@@ -544,6 +548,8 @@ namespace Harness {
             export const log: typeof IO.log = s => console.log(s);
 
             export const readDirectory: typeof IO.readDirectory = (path, extension, exclude) => ts.sys.readDirectory(path, extension, exclude);
+            export const readDirectoryNames: typeof IO.readDirectoryNames = path => ts.sys.readDirectoryNames(path);
+            export const readFileNames: typeof IO.readFileNames = path => ts.sys.readFileNames(path);
 
             export function createDirectory(path: string) {
                 if (!directoryExists(path)) {
@@ -752,6 +758,14 @@ namespace Harness {
             export function readDirectory(path: string, extension?: string, exclude?: string[]) {
                 return listFiles(path).filter(f => !extension || ts.fileExtensionIs(f, extension));
             }
+
+            export function readDirectoryNames(path: string): string[] {
+                return [];
+            }
+
+            export function readFileNames(path: string) {
+                return readDirectory(path);
+            }
         }
     }
 
@@ -777,7 +791,7 @@ namespace Harness {
         (emittedFile: string, emittedLine: number, emittedColumn: number, sourceFile: string, sourceLine: number, sourceColumn: number, sourceName: string): void;
     }
 
-    // Settings 
+    // Settings
     export let userSpecifiedRoot = "";
     export let lightMode = false;
 
@@ -816,7 +830,7 @@ namespace Harness {
             fileName: string,
             sourceText: string,
             languageVersion: ts.ScriptTarget) {
-            // We'll only assert invariants outside of light mode. 
+            // We'll only assert invariants outside of light mode.
             const shouldAssertInvariants = !Harness.lightMode;
 
             // Only set the parent nodes if we're asserting invariants.  We don't need them otherwise.
@@ -911,7 +925,7 @@ namespace Harness {
             libFiles?: string;
         }
 
-        // Additional options not already in ts.optionDeclarations 
+        // Additional options not already in ts.optionDeclarations
         const harnessOptionDeclarations: ts.CommandLineOption[] = [
             { name: "allowNonTsExtensions", type: "boolean" },
             { name: "useCaseSensitiveFileNames", type: "boolean" },
@@ -1149,7 +1163,7 @@ namespace Harness {
                 errLines.forEach(e => outputLines.push(e));
 
                 // do not count errors from lib.d.ts here, they are computed separately as numLibraryDiagnostics
-                // if lib.d.ts is explicitly included in input files and there are some errors in it (i.e. because of duplicate identifiers) 
+                // if lib.d.ts is explicitly included in input files and there are some errors in it (i.e. because of duplicate identifiers)
                 // then they will be added twice thus triggering 'total errors' assertion with condition
                 // 'totalErrorsReportedInNonLibraryFiles + numLibraryDiagnostics + numTest262HarnessDiagnostics, diagnostics.length