Framework for discover typings extensions

Author: weswigham

src/compiler/extensions.ts

@@ -1,10 +1,17 @@
 namespace ts {
 
+    export interface BaseProviderStatic {
+        readonly ["extension-kind"]: ExtensionKind;
+    }
+
     export namespace ExtensionKind {
+        export const TypeDiscovery: "type-discovery" = "type-discovery";
+        export type TypeDiscovery = "type-discovery";
     }
-    export type ExtensionKind = string;
+    export type ExtensionKind = ExtensionKind.TypeDiscovery;
 
     export interface ExtensionCollectionMap {
+        "type-discovery"?: TypeDiscoveryExtension[];
         [index: string]: Extension[] | undefined;
     }
 
@@ -21,7 +28,12 @@ namespace ts {
         length?: number;
     }
 
-    export type Extension = ExtensionBase;
+    export interface TypeDiscoveryExtension extends ExtensionBase {
+        kind: ExtensionKind.TypeDiscovery;
+        lookup: (searchDir: string, args: any) => string[];
+    }
+
+    export type Extension = TypeDiscoveryExtension;
 
     export interface ExtensionCache {
         getCompilerExtensions(): ExtensionCollectionMap;
@@ -89,6 +101,21 @@ namespace ts {
         completeProfile(/*enabled*/true, longTask);
     }
 
+    function verifyType(thing: any, type: string, diagnostics: Diagnostic[], extName: string, extMember: string, extKind: ExtensionKind) {
+        if (typeof thing !== type) {
+            diagnostics.push(createCompilerDiagnostic(
+                Diagnostics.Extension_0_exported_member_1_has_extension_kind_2_but_was_type_3_when_type_4_was_expected,
+                extName,
+                extMember,
+                extKind,
+                typeof thing,
+                type
+            ));
+            return false;
+        }
+        return true;
+    }
+
     export function createExtensionCache(options: CompilerOptions, host: ExtensionHost, resolvedExtensionNames?: Map<string>): ExtensionCache {
 
         const diagnostics: Diagnostic[] = [];
@@ -173,6 +200,12 @@ namespace ts {
                         kind: annotatedKind as ExtensionKind,
                     };
                     switch (ext.kind) {
+                        case ExtensionKind.TypeDiscovery: {
+                            const verified = verifyType(potentialExtension, "function", diagnostics, res.name, key, annotatedKind);
+                            if (!verified) return;
+                            (ext as TypeDiscoveryExtension).lookup = potentialExtension as any;
+                            break;
+                        }
                         default:
                             // Include a default case which just puts the extension unchecked onto the base extension
                             // This can allow language service extensions to query for custom extension kinds

src/services/jsTyping.ts

@@ -6,7 +6,7 @@
 /* @internal */
 namespace ts.JsTyping {
 
-    export interface TypingResolutionHost {
+    export interface TypingResolutionHost extends ExtensionHost {
         directoryExists: (path: string) => boolean;
         fileExists: (fileName: string) => boolean;
         readFile: (path: string, encoding?: string) => string;
@@ -35,6 +35,7 @@ namespace ts.JsTyping {
      * @param packageNameToTypingLocation is the map of package names to their cached typing locations
      * @param typingOptions are used to customize the typing inference process
      * @param compilerOptions are used as a source for typing inference
+     * @param cache is the optional extension cache to lookup type discovery extensions in - one will be made if it cannot be provided
      */
     export function discoverTypings(
         host: TypingResolutionHost,
@@ -43,7 +44,8 @@ namespace ts.JsTyping {
         safeListPath: Path,
         packageNameToTypingLocation: Map<string>,
         typingOptions: TypingOptions,
-        compilerOptions: CompilerOptions):
+        compilerOptions: CompilerOptions,
+        cache: ExtensionCache = createExtensionCache(compilerOptions, host)):
         { cachedTypingPaths: string[], newTypingNames: string[], filesToWatch: string[] } {
 
         // A typing name to typing file path mapping
@@ -88,6 +90,8 @@ namespace ts.JsTyping {
 
             const nodeModulesPath = combinePaths(searchDir, "node_modules");
             getTypingNamesFromNodeModuleFolder(nodeModulesPath);
+
+            getTypingNamesFromExtensions(searchDir, cache);
         }
         getTypingNamesFromSourceFileNames(fileNames);
 
@@ -223,5 +227,24 @@ namespace ts.JsTyping {
             mergeTypings(typingNames);
         }
 
+
+        function getTypingNamesFromExtensions(searchPath: string, cache: ExtensionCache) {
+            // We don't report issues loading type discovery extensions (if the host cares about them, it should load them in advance and pass in a cache)
+            const extensions = cache.getCompilerExtensions()["type-discovery"];
+            for (const extension of extensions) {
+                let results: string[];
+                try {
+                    startExtensionProfile(compilerOptions.extendedDiagnostics, extension.name, "lookup");
+                    results = extension.lookup(searchPath, extension.args);
+                    completeExtensionProfile(compilerOptions.extendedDiagnostics, extension.name, "lookup");
+                }
+                catch (e) {
+                    // There's presently no way to report errors during discover typings other than a hard failure (which is to be avoided)
+                }
+                if (results) {
+                    mergeTypings(results);
+                }
+            }
+        }
     }
 }