Bringing back excludes error and fixing faulty test

microsoft · riknoll · Jun 20, 2016 · Dec 3, 2015 · Dec 7, 2015 · Dec 7, 2015
commit c340c88706939febc9e6a52f28e3089b94294973
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -713,6 +713,9 @@ namespace ts {
                     errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "exclude", "Array"));
                 }
             }
+            else if (hasProperty(json, "excludes")) {
+                errors.push(createCompilerDiagnostic(Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
+            }
             else {
                 // By default, exclude common package folders
                 excludeSpecs = ["node_modules", "bower_components", "jspm_packages"];

diff --git a/src/harness/virtualFileSystem.ts b/src/harness/virtualFileSystem.ts
@@ -1,4 +1,5 @@
 /// <reference path="harness.ts" />
+/// <reference path="..\compiler\commandLineParser.ts"/>
 namespace Utils {
     export class VirtualFileSystemEntry {
         fileSystem: VirtualFileSystem;
@@ -157,4 +158,29 @@ namespace Utils {
             return directory;
         }
     }
+
+    export class MockParseConfigHost extends VirtualFileSystem implements ts.ParseConfigHost {
+        constructor(currentDirectory: string, ignoreCase: boolean, files: string[]) {
+            super(currentDirectory, ignoreCase);
+            for (const file of files) {
+                this.addFile(file);
+            }
+        }
+
+        readDirectory(path: string, extensions: string[], excludes: string[], includes: string[]) {
+            return ts.matchFiles(path, extensions, excludes, includes, this.useCaseSensitiveFileNames, this.currentDirectory, (path: string) => this.getAccessibleFileSystemEntries(path));
+        }
+
+        getAccessibleFileSystemEntries(path: string) {
+            const entry = this.traversePath(path);
+            if (entry && entry.isDirectory()) {
+                const directory = <VirtualDirectory>entry;
+                return {
+                    files: ts.map(directory.getFiles(), f => f.name),
+                    directories: ts.map(directory.getDirectories(), d => d.name)
+                };
+            }
+            return { files: [], directories: [] };
+        }
+    }
 }
diff --git a/tests/cases/unittests/matchFiles.ts b/tests/cases/unittests/matchFiles.ts
@@ -3,33 +3,8 @@
 /// <reference path="..\..\..\src\harness\virtualFileSystem.ts" />
 
 namespace ts {
-    class MockParseConfigHost extends Utils.VirtualFileSystem implements ParseConfigHost {
-        constructor(currentDirectory: string, ignoreCase: boolean, files: string[]) {
-            super(currentDirectory, ignoreCase);
-            for (const file of files) {
-                this.addFile(file);
-            }
-        }
-
-        readDirectory(path: string, extensions: string[], excludes: string[], includes: string[]) {
-            return matchFiles(path, extensions, excludes, includes, this.useCaseSensitiveFileNames, this.currentDirectory, (path: string) => this.getAccessibleFileSystemEntries(path));
-        }
-
-        getAccessibleFileSystemEntries(path: string) {
-            const entry = this.traversePath(path);
-            if (entry && entry.isDirectory()) {
-                const directory = <Utils.VirtualDirectory>entry;
-                return {
-                    files: map(directory.getFiles(), f => f.name),
-                    directories: map(directory.getDirectories(), d => d.name)
-                };
-            }
-            return { files: [], directories: [] };
-        }
-    }
-
     const caseInsensitiveBasePath = "c:/dev/";
-    const caseInsensitiveHost = new MockParseConfigHost(caseInsensitiveBasePath, /*useCaseSensitiveFileNames*/ false, [
+    const caseInsensitiveHost = new Utils.MockParseConfigHost(caseInsensitiveBasePath, /*useCaseSensitiveFileNames*/ false, [
         "c:/dev/a.ts",
         "c:/dev/a.d.ts",
         "c:/dev/a.js",
@@ -53,7 +28,7 @@ namespace ts {
     ]);
 
     const caseSensitiveBasePath = "/dev/";
-    const caseSensitiveHost = new MockParseConfigHost(caseSensitiveBasePath, /*useCaseSensitiveFileNames*/ true, [
+    const caseSensitiveHost = new Utils.MockParseConfigHost(caseSensitiveBasePath, /*useCaseSensitiveFileNames*/ true, [
         "/dev/a.ts",
         "/dev/a.d.ts",
         "/dev/a.js",
@@ -76,7 +51,7 @@ namespace ts {
         "/dev/js/b.js",
     ]);
 
-    const caseInsensitiveMixedExtensionHost = new MockParseConfigHost(caseInsensitiveBasePath, /*useCaseSensitiveFileNames*/ false, [
+    const caseInsensitiveMixedExtensionHost = new Utils.MockParseConfigHost(caseInsensitiveBasePath, /*useCaseSensitiveFileNames*/ false, [
         "c:/dev/a.ts",
         "c:/dev/a.d.ts",
         "c:/dev/a.js",

diff --git a/tests/cases/unittests/tsconfigParsing.ts b/tests/cases/unittests/tsconfigParsing.ts
@@ -2,31 +2,6 @@
 /// <reference path="..\..\..\src\compiler\commandLineParser.ts" />
 
 namespace ts {
-    class MockParseConfigHost extends Utils.VirtualFileSystem implements ParseConfigHost {
-        constructor(currentDirectory: string, ignoreCase: boolean, files: string[]) {
-            super(currentDirectory, ignoreCase);
-            for (const file of files) {
-                this.addFile(file);
-            }
-        }
-
-        readDirectory(path: string, extensions: string[], excludes: string[], includes: string[]) {
-            return matchFiles(path, extensions, excludes, includes, this.useCaseSensitiveFileNames, this.currentDirectory, (path: string) => this.getAccessibleFileSystemEntries(path));
-        }
-
-        getAccessibleFileSystemEntries(path: string) {
-            const entry = this.traversePath(path);
-            if (entry && entry.isDirectory()) {
-                const directory = <Utils.VirtualDirectory>entry;
-                return {
-                    files: map(directory.getFiles(), f => f.name),
-                    directories: map(directory.getDirectories(), d => d.name)
-                };
-            }
-            return { files: [], directories: [] };
-        }
-    }
-
     describe('parseConfigFileTextToJson', () => {
         function assertParseResult(jsonText: string, expectedConfigObject: { config?: any; error?: Diagnostic }) {
             let parsed = ts.parseConfigFileTextToJson("/apath/tsconfig.json", jsonText);
@@ -41,13 +16,14 @@ namespace ts {
 
         function assertParseErrorWithExcludesKeyword(jsonText: string) {
              let parsed = ts.parseConfigFileTextToJson("/apath/tsconfig.json", jsonText);
-             let parsedCommand = ts.parseJsonConfigFileContent(parsed, ts.sys, "tests/cases/unittests");
-             assert.isTrue(undefined !== parsedCommand.errors);
+             let parsedCommand = ts.parseJsonConfigFileContent(parsed.config, ts.sys, "tests/cases/unittests");
+             assert.isTrue(parsedCommand.errors && parsedCommand.errors.length === 1 &&
+                parsedCommand.errors[0].code === ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude.code);
         }
 
         function assertParseFileList(jsonText: string, configFileName: string, basePath: string, allFileList: string[], expectedFileList: string[]) {
             const json = JSON.parse(jsonText);
-            const host: ParseConfigHost = new MockParseConfigHost(basePath, true, allFileList);
+            const host: ParseConfigHost = new Utils.MockParseConfigHost(basePath, true, allFileList);
             const parsed = ts.parseJsonConfigFileContent(json, host, basePath, /*existingOptions*/ undefined, configFileName);
             assert.isTrue(arrayIsEqualTo(parsed.fileNames.sort(), expectedFileList.sort()));
         }
@@ -125,27 +101,27 @@ namespace ts {
             assertParseResult(
                 `{
                     "compilerOptions": {
-                        "lib": "es5"
+                        "lib": ["es5"]
                     }
                 }`, {
-                    config: { compilerOptions: { lib: "es5" } }
+                    config: { compilerOptions: { lib: ["es5"] } }
                 });
 
             assertParseResult(
                 `{
                     "compilerOptions": {
-                        "lib": "es5,es6"
+                        "lib": ["es5", "es6"]
                     }
                 }`, {
-                    config: { compilerOptions: { lib: "es5,es6" } }
+                    config: { compilerOptions: { lib: ["es5", "es6"] } }
                 });
         });
 
         it("returns error when tsconfig have excludes", () => {
             assertParseErrorWithExcludesKeyword(
                 `{
                     "compilerOptions": {
-                        "lib": "es5"
+                        "lib": ["es5"]
                     },
                     "excludes": [
                         "foge.ts"