- replacing TryParseJson with existing readConfig

- push error for invalid enableAutoDiscovery option
- adding interfaces for jsons
- removing updateNotFoundTypings
- node_modules normalize file names before using
- adding safeListPath to discoverTypings

Author: jramsay

src/compiler/commandLineParser.ts

@@ -503,7 +503,7 @@ namespace ts {
      *
      * This method replace comment content by whitespace rather than completely remove them to keep positions in json parsing error reporting accurate.
      */
-    export function removeComments(jsonText: string): string {
+    function removeComments(jsonText: string): string {
         let output = "";
         const scanner = createScanner(ScriptTarget.ES5, /* skipTrivia */ false, LanguageVariant.Standard, jsonText);
         let token: SyntaxKind;
@@ -614,6 +614,9 @@ namespace ts {
                         if (typeof jsonTypingOptions[id] === "boolean") {
                             options.enableAutoDiscovery = jsonTypingOptions[id];
                         }
+                        else {
+                            errors.push(createCompilerDiagnostic(Diagnostics.Unknown_typing_option_0, id));
+                        }
                     }
                     else if (id === "include") {
                         options.include = convertJsonOptionToStringArray(id, jsonTypingOptions[id], errors);

src/services/jsTyping.ts

@@ -13,35 +13,47 @@ namespace ts.JsTyping {
         readDirectory: (path: string, extension?: string, exclude?: string[], depth?: number) => string[];
     };
 
+    interface TsdJson {
+        version: string;
+        repo: string;
+        ref: string;
+        path: string;
+        installed?: Map<TsdInstalledItem>;
+    };
+
+    interface TsdInstalledItem {
+        commit: string;
+    };
+
+    interface PackageJson {
+        _requiredBy?: string[];
+        dependencies?: Map<string>;
+        devDependencies?: Map<string>;
+        name: string;
+        optionalDependencies?: Map<string>;
+        peerDependencies?: Map<string>;
+        typings?: string;
+    };
+
     // A map of loose file names to library names
     // that we are confident require typings
     let safeList: Map<string>;
-    const notFoundTypingNames: string[] = [];
-
-    function tryParseJson(jsonPath: string, host: TypingResolutionHost): any {
-        if (host.fileExists(jsonPath)) {
-            try {
-                const contents = removeComments(host.readFile(jsonPath));
-                return JSON.parse(contents);
-            }
-            catch (e) { }
-        }
-        return undefined;
-    }
 
     /**
      * @param host is the object providing I/O related operations.
      * @param fileNames are the file names that belong to the same project.
-     * @param globalCachePath is used to get the safe list file path and as cache path if the project root path isn't specified.
-     * @param projectRootPath is the path to the project root directory. This is used for the local typings cache.
+     * @param cachePath is the path to the typings cache
+     * @param projectRootPath is the path to the project root directory
+     * @param safeListPath is the path used to retrieve the safe list
      * @param typingOptions are used for customizing the typing inference process.
      * @param compilerOptions are used as a source of typing inference.
      */
     export function discoverTypings(
         host: TypingResolutionHost,
         fileNames: string[],
-        globalCachePath: Path,
+        cachePath: Path,
         projectRootPath: Path,
+        safeListPath: Path,
         typingOptions: TypingOptions,
         compilerOptions: CompilerOptions):
         { cachedTypingPaths: string[], newTypingNames: string[], filesToWatch: string[] } {
@@ -53,13 +65,12 @@ namespace ts.JsTyping {
             return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] };
         }
 
-        const cachePath = projectRootPath || globalCachePath;
         // Only infer typings for .js and .jsx files
         fileNames = filter(map(fileNames, normalizePath), f => scriptKindIs(f, /*LanguageServiceHost*/ undefined, ScriptKind.JS, ScriptKind.JSX));
 
-        const safeListFilePath = combinePaths(globalCachePath, "safeList.json");
-        if (!safeList && host.fileExists(safeListFilePath)) {
-            safeList = tryParseJson(safeListFilePath, host);
+        if (!safeList) {
+            const result = readConfigFile(safeListPath, host.readFile);
+            if (result.config) { safeList = result.config; }
         }
 
         const filesToWatch: string[] = [];
@@ -86,26 +97,20 @@ namespace ts.JsTyping {
                 const nodeModulesPath = combinePaths(searchDir, "node_modules");
                 getTypingNamesFromNodeModuleFolder(nodeModulesPath, filesToWatch);
             }
-
             getTypingNamesFromSourceFileNames(fileNames);
-            getTypingNamesFromCompilerOptions(compilerOptions);
         }
 
         const typingsPath = combinePaths(cachePath, "typings");
         const tsdJsonPath = combinePaths(cachePath, "tsd.json");
-        const tsdJsonDict = tryParseJson(tsdJsonPath, host);
-        if (tsdJsonDict) {
-            for (const notFoundTypingName of notFoundTypingNames) {
-                if (hasProperty(inferredTypings, notFoundTypingName) && !inferredTypings[notFoundTypingName]) {
-                    delete inferredTypings[notFoundTypingName];
-                }
-            }
+        const result = readConfigFile(tsdJsonPath, host.readFile);
+        if (result.config) {
+            const tsdJson: TsdJson = result.config;
 
             // The "installed" property in the tsd.json serves as a registry of installed typings. Each item
             // of this object has a key of the relative file path, and a value that contains the corresponding
             // commit hash.
-            if (hasProperty(tsdJsonDict, "installed")) {
-                for (const cachedTypingPath in tsdJsonDict.installed) {
+            if (tsdJson.installed) {
+                for (const cachedTypingPath in tsdJson.installed) {
                     // Assuming the cachedTypingPath has the format of "[package name]/[file name]"
                     const cachedTypingName = cachedTypingPath.substr(0, cachedTypingPath.indexOf("/"));
                     // If the inferred[cachedTypingName] is already not null, which means we found a corresponding
@@ -153,20 +158,21 @@ namespace ts.JsTyping {
          * Get the typing info from common package manager json files like package.json or bower.json
          */
         function getTypingNamesFromJson(jsonPath: string, filesToWatch: string[]) {
-            const jsonDict = tryParseJson(jsonPath, host);
-            if (jsonDict) {
+            const result = readConfigFile(jsonPath, host.readFile);
+            if (result.config) {
+                const jsonConfig: PackageJson = result.config;
                 filesToWatch.push(jsonPath);
-                if (hasProperty(jsonDict, "dependencies")) {
-                    mergeTypings(getKeys(jsonDict.dependencies));
+                if (jsonConfig.dependencies) {
+                    mergeTypings(getKeys(jsonConfig.dependencies));
                 }
-                if (hasProperty(jsonDict, "devDependencies")) {
-                    mergeTypings(getKeys(jsonDict.devDependencies));
+                if (jsonConfig.devDependencies) {
+                    mergeTypings(getKeys(jsonConfig.devDependencies));
                 }
-                if (hasProperty(jsonDict, "optionalDependencies")) {
-                    mergeTypings(getKeys(jsonDict.optionalDependencies));
+                if (jsonConfig.optionalDependencies) {
+                    mergeTypings(getKeys(jsonConfig.optionalDependencies));
                 }
-                if (hasProperty(jsonDict, "peerDependencies")) {
-                    mergeTypings(getKeys(jsonDict.peerDependencies));
+                if (jsonConfig.peerDependencies) {
+                    mergeTypings(getKeys(jsonConfig.peerDependencies));
                 }
             }
         }
@@ -205,75 +211,36 @@ namespace ts.JsTyping {
             }
 
             const typingNames: string[] = [];
-            const jsonFiles = host.readDirectory(nodeModulesPath, "*.json", /*exclude*/ undefined, /*depth*/ 2);
-            for (const jsonFile of jsonFiles) {
-                if (getBaseFileName(jsonFile) !== "package.json") { continue; }
-                const packageJsonDict = tryParseJson(jsonFile, host);
-                if (!packageJsonDict) { continue; }
-
-                filesToWatch.push(jsonFile);
-
-                // npm 3 has the package.json contains a "_requiredBy" field
+            const fileNames = host.readDirectory(nodeModulesPath, "*.json", /*exclude*/ undefined, /*depth*/ 2);
+            for (const fileName of fileNames) {
+                const normalizedFileName = normalizePath(fileName);
+                if (getBaseFileName(normalizedFileName) !== "package.json") { continue; }
+                const result = readConfigFile(normalizedFileName, host.readFile);
+                if (!result.config) { continue; }
+                const packageJson: PackageJson = result.config;
+                filesToWatch.push(normalizedFileName);
+
+                // npm 3's package.json contains a "_requiredBy" field
                 // we should include all the top level module names for npm 2, and only module names whose
                 // "_requiredBy" field starts with "#" or equals "/" for npm 3.
-                if (packageJsonDict._requiredBy &&
-                    filter(packageJsonDict._requiredBy, (r: string) => r[0] === "#" || r === "/").length === 0) {
+                if (packageJson._requiredBy &&
+                    filter(packageJson._requiredBy, (r: string) => r[0] === "#" || r === "/").length === 0) {
                     continue;
                 }
 
                 // If the package has its own d.ts typings, those will take precedence. Otherwise the package name will be used
                 // to download d.ts files from DefinitelyTyped
-                const packageName = packageJsonDict["name"];
-                if (hasProperty(packageJsonDict, "typings")) {
-                    const absolutePath = getNormalizedAbsolutePath(packageJsonDict.typings, getDirectoryPath(jsonFile));
-                    inferredTypings[packageName] = absolutePath;
+                if (!packageJson.name) { continue; }
+                if (packageJson.typings) {
+                    const absolutePath = getNormalizedAbsolutePath(packageJson.typings, getDirectoryPath(normalizedFileName));
+                    inferredTypings[packageJson.name] = absolutePath;
                 }
                 else {
-                    typingNames.push(packageName);
+                    typingNames.push(packageJson.name);
                 }
             }
             mergeTypings(typingNames);
         }
 
-        function getTypingNamesFromCompilerOptions(options: CompilerOptions) {
-            const typingNames: string[] = [];
-            if (!options) {
-                return;
-            }
-            mergeTypings(typingNames);
-        }
-    }
-
-    /**
-     * Keep a list of typings names that we know cannot be obtained at the moment (could be because
-     * of network issues or because the package doesn't hava a d.ts file in DefinitelyTyped), so
-     * that we won't try again next time within this session.
-     * @param newTypingNames The list of new typings that the host attempted to acquire
-     * @param cachePath The path to the tsd.json cache
-     * @param host The object providing I/O related operations.
-     */
-    export function updateNotFoundTypingNames(newTypingNames: string[], cachePath: string, host: TypingResolutionHost): void {
-        const tsdJsonPath = combinePaths(cachePath, "tsd.json");
-        const cacheTsdJsonDict = tryParseJson(tsdJsonPath, host);
-        if (cacheTsdJsonDict) {
-            const installedTypingFiles = hasProperty(cacheTsdJsonDict, "installed")
-                ? getKeys(cacheTsdJsonDict.installed)
-                : [];
-            const newMissingTypingNames =
-                filter(newTypingNames, name => notFoundTypingNames.indexOf(name) < 0 && !isInstalled(name, installedTypingFiles));
-            for (const newMissingTypingName of newMissingTypingNames) {
-                notFoundTypingNames.push(newMissingTypingName);
-            }
-        }
-    }
-
-    function isInstalled(typing: string, installedKeys: string[]) {
-        const typingPrefix = typing + "/";
-        for (const key of installedKeys) {
-            if (key.indexOf(typingPrefix) === 0) {
-                return true;
-            }
-        }
-        return false;
     }
 }

src/services/shims.ts

@@ -232,8 +232,7 @@ namespace ts {
         getPreProcessedFileInfo(fileName: string, sourceText: IScriptSnapshot): string;
         getTSConfigFileInfo(fileName: string, sourceText: IScriptSnapshot): string;
         getDefaultCompilationSettings(): string;
-        discoverTypings(fileNamesJson: string, globalCachePath: string, projectRootPath: string, typingOptionsJson: string, compilerOptionsJson: string): string;
-        updateNotFoundTypingNames(newTypingsJson: string, globalCachePath: string, projectRootPath: string): string;
+        discoverTypings(fileNamesJson: string, cachePath: string, projectRootPath: string, safeListPath: string, typingOptionsJson: string, compilerOptionsJson: string): string;
     }
 
     function logInternalError(logger: Logger, err: Error) {
@@ -988,31 +987,22 @@ namespace ts {
             );
         }
 
-        public discoverTypings(fileNamesJson: string, globalCachePath: string, projectRootPath: string, typingOptionsJson: string, compilerOptionsJson: string): string {
+        public discoverTypings(fileNamesJson: string, cachePath: string, projectRootPath: string, safeListPath: string, typingOptionsJson: string, compilerOptionsJson: string): string {
             const getCanonicalFileName = createGetCanonicalFileName(/*useCaseSensitivefileNames:*/ false);
             return this.forwardJSONCall("discoverTypings()", () => {
-                const cachePath = projectRootPath ? projectRootPath : globalCachePath;
                 const typingOptions = <TypingOptions>JSON.parse(typingOptionsJson);
-
                 const compilerOptions = <CompilerOptions>JSON.parse(compilerOptionsJson);
                 const fileNames: string[] = JSON.parse(fileNamesJson);
                 return ts.JsTyping.discoverTypings(
                     this.host,
                     fileNames,
-                    toPath(globalCachePath, globalCachePath, getCanonicalFileName),
                     toPath(cachePath, cachePath, getCanonicalFileName),
+                    toPath(projectRootPath, projectRootPath, getCanonicalFileName),
+                    toPath(safeListPath, safeListPath, getCanonicalFileName),
                     typingOptions,
                     compilerOptions);
             });
         }
-
-        public updateNotFoundTypingNames(newTypingsJson: string, globalCachePath: string, projectRootPath: string): string {
-            return this.forwardJSONCall("updateNotFoundTypingNames()", () => {
-                const newTypingNames: string[] = JSON.parse(newTypingsJson);
-                const cachePath = projectRootPath ? projectRootPath : globalCachePath;
-                ts.JsTyping.updateNotFoundTypingNames(newTypingNames, cachePath, this.host);
-            });
-        }
     }
 
     export class TypeScriptServicesFactory implements ShimFactory {