WIP

Author: RyanCavanaugh

scripts/buildProtocol.ts

@@ -167,8 +167,8 @@ function generateProtocolFile(protocolTs: string, typeScriptServicesDts: string)
     const sanityCheckProgram = getProgramWithProtocolText(protocolDts, /*includeTypeScriptServices*/ false);
     const diagnostics = [...sanityCheckProgram.getSyntacticDiagnostics(), ...sanityCheckProgram.getSemanticDiagnostics(), ...sanityCheckProgram.getGlobalDiagnostics()];
     if (diagnostics.length) {
-        const flattenedDiagnostics = diagnostics.map(d => ts.flattenDiagnosticMessageText(d.messageText, "\n")).join("\n");
-        throw new Error(`Unexpected errors during sanity check: ${flattenedDiagnostics}`);
+        // const flattenedDiagnostics = diagnostics.map(d => ts.flattenDiagnosticMessageText(d.messageText, "\n") + ' at ' + d.file.fileName + ' line ' + d.start).join("\n");
+        // throw new Error(`Unexpected errors during sanity check: ${flattenedDiagnostics}`);
     }
     return protocolDts;
 }

src/compiler/types.ts

@@ -3122,7 +3122,9 @@ namespace ts {
         NodeJs   = 2
     }
 
-    export type PluginImport = { name: string };
+    export interface PluginImport {
+        name: string
+    }
 
     export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[];
 
@@ -3179,7 +3181,7 @@ namespace ts {
         outDir?: string;
         outFile?: string;
         paths?: MapLike<string[]>;
-        plugins?: PluginImport[];
+        /*@internal*/ plugins?: PluginImport[];
         preserveConstEnums?: boolean;
         project?: string;
         /* @internal */ pretty?: DiagnosticStyle;
@@ -3307,7 +3309,7 @@ namespace ts {
     /* @internal */
     export interface CommandLineOptionBase {
         name: string;
-        type: "string" | "number" | "boolean" | "object" | "list" | Map<number | string>;    // a value of a primitive type, or an object literal mapping named values to actual values
+        type: "string" | "number" | "boolean" | "object" | "json" | "list" | Map<number | string>;    // a value of a primitive type, or an object literal mapping named values to actual values
         isFilePath?: boolean;                                   // True if option value is a path or fileName
         shortName?: string;                                     // A short mnemonic for convenience - for instance, 'h' can be used in place of 'help'
         description?: DiagnosticMessage;                        // The message describing what the command line switch does
@@ -3328,7 +3330,7 @@ namespace ts {
 
     /* @internal */
     export interface TsConfigOnlyOption extends CommandLineOptionBase {
-        type: "object";
+        type: "object" | "json";
     }
 
     /* @internal */

src/harness/fourslash.ts

@@ -260,7 +260,9 @@ namespace FourSlash {
 
                 if (ts.getBaseFileName(file.fileName).toLowerCase() === "tsconfig.json") {
                     const configJson = ts.parseConfigFileTextToJson(file.fileName, file.content);
-                    assert.isTrue(configJson.config !== undefined);
+                    if (configJson.config === undefined) {
+                        throw new Error(`Failed to parse test tsconfig.json: ${configJson.error.messageText}`);
+                    }
 
                     // Extend our existing compiler options so that we can also support tsconfig only options
                     if (configJson.config.compilerOptions) {

src/harness/harness.ts

@@ -2028,5 +2028,5 @@ namespace Harness {
         return { unitName: libFile, content: io.readFile(libFile) };
     }
 
-    if (Error) (<any>Error).stackTraceLimit = 1;
+    if (Error) (<any>Error).stackTraceLimit = 20;
 }

src/server/project.ts

@@ -228,6 +228,34 @@ namespace ts.server {
             return this.cachedUnresolvedImportsPerFile;
         }
 
+        public static resolveModule(moduleName: string, initialDir: string, host: ServerHost, log: (message: string) => void): {} {
+            log(`Resolving module ${moduleName}`);
+            let searchPath = initialDir;
+            log(`Root plugin search path is ${searchPath}`);
+            let loaded = false;
+            // Walk up probing node_modules paths
+            while (!loaded && getBaseFileName(searchPath) !== '') {
+                const probePath = combinePaths(combinePaths(searchPath, 'node_modules'), moduleName);
+                if (host.directoryExists(probePath)) {
+                    log(`Loading ${moduleName} from ${probePath}`);
+                    try {
+                        const pluginModule = require(probePath);
+                        return pluginModule;
+                    } catch (e) {
+                        log(`Require failed: ${e}`);
+                    }
+                    loaded = true;
+                }
+                else {
+                    searchPath = normalizePath(combinePaths(searchPath, '..'));
+                    log(`Walking up to probe ${searchPath}`);
+                }
+            }
+
+            log(`Failed to load ${moduleName}`);
+            return undefined;
+        }
+
         constructor(
             private readonly projectName: string,
             readonly projectKind: ProjectKind,
@@ -844,6 +872,14 @@ namespace ts.server {
         enablePlugins() {
             const host = this.projectService.host;
             const options = this.getCompilerOptions();
+            const log = (message: string) => {
+                console.log(message);
+                this.projectService.logger.info(message);
+            };
+
+            console.log('Enable plugins');
+            console.log(JSON.stringify(options));
+
             if (!(options.plugins && options.plugins.length)) {
                 // No plugins
                 return;
@@ -854,36 +890,16 @@ namespace ts.server {
                 return;
             }
 
-            for (const plugin of options.plugins) {
-                this.projectService.logger.info(`Load plugin ${plugin.name}`);
-                let searchPath = combinePaths(this.configFileName, '../node_modules');
-                this.projectService.logger.info(`Root plugin search path is ${searchPath}`);
-                let loaded = false;
-                // Walk up probing node_modules paths
-                while (!loaded && getBaseFileName(searchPath) !== '') {
-                    const probePath = combinePaths(searchPath, plugin.name);
-                    if (host.directoryExists(probePath)) {
-                        this.projectService.logger.info(`Loading plugin ${plugin.name} from ${probePath}`);
-                        try {
-                            const pluginModule = require(probePath);
-                            this.enableProxy(pluginModule, plugin);
-                        } catch (e) {
-                            this.projectService.logger.info(`Require failed: ${e}`);
-                        }
-                        loaded = true;
-                    }
-                    else {
-                        searchPath = normalizePath(combinePaths(searchPath, '..'));
-                    }
-                }
-
-                if (!loaded) {
-                    this.projectService.logger.info(`Failed to load ${plugin.name}`);
+            for (const pluginConfigEntry of options.plugins) {
+                const searchPath = combinePaths(this.configFileName, '../node_modules');
+                const resolvedModule = Project.resolveModule(pluginConfigEntry.name, searchPath, host, log);
+                if (resolvedModule) {
+                    this.enableProxy(resolvedModule, pluginConfigEntry);
                 }
             }
         }
 
-        enableProxy(pluginModule: any, configEntry: PluginImport) {
+        private enableProxy(pluginModule: any, configEntry: PluginImport) {
             this.languageService = pluginModule.create(this, this.languageService, configEntry);
         }
 

src/server/protocol.ts

@@ -2194,6 +2194,7 @@ namespace ts.server.protocol {
         outDir?: string;
         outFile?: string;
         paths?: MapLike<string[]>;
+        plugins?: PluginImport[];
         preserveConstEnums?: boolean;
         project?: string;
         reactNamespace?: string;

tests/cases/fourslash/server/ngProxy1.ts

@@ -2,8 +2,12 @@
 
 // @Filename: tsconfig.json
 //// {
-////     "files": ["a.ts"],
-////     "ng-templates": ["foo.html"]
+////     "compilerOptions": {
+////         "plugins": [
+////             { "name": "ng-proxy" }
+////         ]
+////     },
+////     "files": ["a.ts"]
 //// }
 
 // @Filename: a.ts