Merge pull request microsoft#7179 from Microsoft/jsTypingForAcquireDts

Salsa: JS support for discovering and acquiring d.ts files

Author: jramsay

Jakefile.js

@@ -927,6 +927,7 @@ var servicesLintTargets = [
  "patternMatcher.ts",
  "services.ts",
  "shims.ts",
+ "jsTyping.ts"
 ].map(function (s) {
  return path.join(servicesDirectory, s);
 });

src/compiler/commandLineParser.ts

@@ -543,6 +543,7 @@ namespace ts {
  return {
  options,
  fileNames: getFileNames(),
+ typingOptions: getTypingOptions(),
  errors
  };
 
@@ -607,6 +608,35 @@ namespace ts {
  }
  return fileNames;
  }
+
+ function getTypingOptions(): TypingOptions {
+ const options: TypingOptions = getBaseFileName(configFileName) === "jsconfig.json"
+ ? { enableAutoDiscovery: true, include: [], exclude: [] }
+ : { enableAutoDiscovery: false, include: [], exclude: [] };
+ const jsonTypingOptions = json["typingOptions"];
+ if (jsonTypingOptions) {
+ for (const id in jsonTypingOptions) {
+ if (id === "enableAutoDiscovery") {
+ 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);
+ }
+ else if (id === "exclude") {
+ options.exclude = convertJsonOptionToStringArray(id, jsonTypingOptions[id], errors);
+ }
+ else {
+ errors.push(createCompilerDiagnostic(Diagnostics.Unknown_typing_option_0, id));
+ }
+ }
+ }
+ return options;
+ }
  }
 
  export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: CompilerOptions, errors: Diagnostic[] } {
@@ -647,28 +677,7 @@ namespace ts {
  break;
  case "object":
  // "object" options with 'isFilePath' = true expected to be string arrays
- let paths: string[] = [];
- let invalidOptionType = false;
- if (!isArray(value)) {
- invalidOptionType = true;
- }
- else {
- for (const element of <any[]>value) {
- if (typeof element === "string") {
- paths.push(normalizePath(combinePaths(basePath, element)));
- }
- else {
- invalidOptionType = true;
- break;
- }
- }
- }
- if (invalidOptionType) {
- errors.push(createCompilerDiagnostic(Diagnostics.Option_0_should_have_array_of_strings_as_a_value, opt.name));
- }
- else {
- value = paths;
- }
+ value = convertJsonOptionToStringArray(opt.name, value, errors, (element) => normalizePath(combinePaths(basePath, element)));
  break;
  }
  if (value === "") {
@@ -688,4 +697,28 @@ namespace ts {
 
  return { options, errors };
  }
+
+ function convertJsonOptionToStringArray(optionName: string, optionJson: any, errors: Diagnostic[], func?: (element: string) => string): string[] {
+ const items: string[] = [];
+ let invalidOptionType = false;
+ if (!isArray(optionJson)) {
+ invalidOptionType = true;
+ }
+ else {
+ for (const element of <any[]>optionJson) {
+ if (typeof element === "string") {
+ const item = func ? func(element) : element;
+ items.push(item);
+ }
+ else {
+ invalidOptionType = true;
+ break;
+ }
+ }
+ }
+ if (invalidOptionType) {
+ errors.push(createCompilerDiagnostic(Diagnostics.Option_0_should_have_array_of_strings_as_a_value, optionName));
+ }
+ return items;
+ }
 }

src/compiler/core.ts

@@ -278,6 +278,14 @@ namespace ts {
  return hasOwnProperty.call(map, key);
  }
 
+ export function getKeys<T>(map: Map<T>): string[] {
+ const keys: string[] = [];
+ for (const key in map) {
+ keys.push(key);
+ }
+ return keys;
+ }
+
  export function getProperty<T>(map: Map<T>, key: string): T {
  return hasOwnProperty.call(map, key) ? map[key] : undefined;
  }
@@ -778,6 +786,32 @@ namespace ts {
  return pathLen > extLen && path.substr(pathLen - extLen, extLen) === extension;
  }
 
+ export function ensureScriptKind(fileName: string, scriptKind?: ScriptKind): ScriptKind {
+ // Using scriptKind as a condition handles both:
+ // - 'scriptKind' is unspecified and thus it is `undefined`
+ // - 'scriptKind' is set and it is `Unknown` (0)
+ // If the 'scriptKind' is 'undefined' or 'Unknown' then we attempt
+ // to get the ScriptKind from the file name. If it cannot be resolved
+ // from the file name then the default 'TS' script kind is returned.
+ return (scriptKind || getScriptKindFromFileName(fileName)) || ScriptKind.TS;
+ }
+
+ export function getScriptKindFromFileName(fileName: string): ScriptKind {
+ const ext = fileName.substr(fileName.lastIndexOf("."));
+ switch (ext.toLowerCase()) {
+ case ".js":
+ return ScriptKind.JS;
+ case ".jsx":
+ return ScriptKind.JSX;
+ case ".ts":
+ return ScriptKind.TS;
+ case ".tsx":
+ return ScriptKind.TSX;
+ default:
+ return ScriptKind.Unknown;
+ }
+ }
+
  /**
  * List of supported extensions in order of file resolution precedence.
  */

src/compiler/diagnosticMessages.json

@@ -2804,5 +2804,9 @@
  "'super' must be called before accessing 'this' in the constructor of a derived class.": {
  "category": "Error",
  "code": 17009
+ },
+ "Unknown typing option '{0}'.": {
+ "category": "Error",
+ "code": 17010
  }
 }

src/compiler/parser.ts

@@ -407,23 +407,6 @@ namespace ts {
  return result;
  }
 
- /* @internal */
- export function getScriptKindFromFileName(fileName: string): ScriptKind {
- const ext = fileName.substr(fileName.lastIndexOf("."));
- switch (ext.toLowerCase()) {
- case ".js":
- return ScriptKind.JS;
- case ".jsx":
- return ScriptKind.JSX;
- case ".ts":
- return ScriptKind.TS;
- case ".tsx":
- return ScriptKind.TSX;
- default:
- return ScriptKind.TS;
- }
- }
-
  // Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter
  // indicates what changed between the 'text' that this SourceFile has and the 'newText'.
  // The SourceFile will be created with the compiler attempting to reuse as many nodes from
@@ -551,12 +534,7 @@ namespace ts {
  let parseErrorBeforeNextFinishedNode = false;
 
  export function parseSourceFile(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, setParentNodes?: boolean, scriptKind?: ScriptKind): SourceFile {
- // Using scriptKind as a condition handles both:
- // - 'scriptKind' is unspecified and thus it is `undefined`
- // - 'scriptKind' is set and it is `Unknown` (0)
- // If the 'scriptKind' is 'undefined' or 'Unknown' then attempt
- // to get the ScriptKind from the file name.
- scriptKind = scriptKind ? scriptKind : getScriptKindFromFileName(fileName);
+ scriptKind = ensureScriptKind(fileName, scriptKind);
 
  initializeState(fileName, _sourceText, languageVersion, _syntaxCursor, scriptKind);
 

src/compiler/types.ts

@@ -2433,6 +2433,23 @@ namespace ts {
  [option: string]: string | number | boolean | TsConfigOnlyOptions;
  }
 
+ export interface TypingOptions {
+ enableAutoDiscovery?: boolean;
+ include?: string[];
+ exclude?: string[];
+ [option: string]: string[] | boolean;
+ }
+
+ export interface DiscoverTypingsInfo {
+ fileNames: string[]; // The file names that belong to the same project.
+ cachePath: string; // The path to the typings cache
+ projectRootPath: string; // The path to the project root directory
+ safeListPath: string; // The path used to retrieve the safe list
+ packageNameToTypingLocation: Map<string>; // The map of package names to their cached typing locations
+ typingOptions: TypingOptions; // Used to customize the typing inference process
+ compilerOptions: CompilerOptions; // Used as a source for typing inference
+ }
+
  export enum ModuleKind {
  None = 0,
  CommonJS = 1,
@@ -2491,6 +2508,7 @@ namespace ts {
 
  export interface ParsedCommandLine {
  options: CompilerOptions;
+ typingOptions?: TypingOptions;
  fileNames: string[];
  errors: Diagnostic[];
  }