Cleanup

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") + ' at ' + d.file.fileName + ' line ' + d.start).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

@@ -3309,7 +3309,7 @@ namespace ts {
     /* @internal */
     export interface CommandLineOptionBase {
         name: string;
-        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
+        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
         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
@@ -3330,13 +3330,13 @@ namespace ts {
 
     /* @internal */
     export interface TsConfigOnlyOption extends CommandLineOptionBase {
-        type: "object" | "json";
+        type: "object";
     }
 
     /* @internal */
     export interface CommandLineOptionOfListType extends CommandLineOptionBase {
         type: "list";
-        element: CommandLineOptionOfCustomType | CommandLineOptionOfPrimitiveType;
+        element: CommandLineOptionOfCustomType | CommandLineOptionOfPrimitiveType | TsConfigOnlyOption;
     }
 
     /* @internal */

src/harness/fourslash.ts

@@ -245,12 +245,40 @@ namespace FourSlash {
             }
         }
 
+        static mockResolveModule(moduleName: string, _initialDir: string, _host: ts.server.ServerHost, log: (message: string) => void): ts.server.PluginModule {
+            log(`Mock resolving ${moduleName}`);
+            return {
+                create(_proj: any, langSvc: any, _config: any) {
+                    // tslint:disable-next-line:no-null-keyword
+                    const proxy = Object.create(null);
+                    for (const k of Object.keys(langSvc)) {
+                        proxy[k] = function () {
+                            return langSvc[k].apply(langSvc, arguments);
+                        };
+                    }
+
+                    proxy.getQuickInfoAtPosition = function () {
+                        const parts = langSvc.getQuickInfoAtPosition.apply(langSvc, arguments);
+                        if (parts.displayParts.length > 0) {
+                            parts.displayParts[0].text = "Proxied";
+                        }
+                        parts.displayParts.push({ text: "Check", kind: "punctuation" });
+                        return parts;
+                    };
+
+                    return proxy;
+                }
+            };
+        }
+
         constructor(private basePath: string, private testType: FourSlashTestType, public testData: FourSlashData) {
             // Create a new Services Adapter
             this.cancellationToken = new TestCancellationToken();
             let compilationOptions = convertGlobalOptionsToCompilerOptions(this.testData.globalOptions);
             compilationOptions.skipDefaultLibCheck = true;
 
+            ts.server.Project.resolveModule = TestState.mockResolveModule;
+
             // Initialize the language service with all the scripts
             let startResolveFileRef: FourSlashFile;
 
@@ -480,7 +508,7 @@ namespace FourSlash {
                 endPos = endMarker.position;
             }
 
-            errors.forEach(function(error: ts.Diagnostic) {
+            errors.forEach(function (error: ts.Diagnostic) {
                 if (predicate(error.start, error.start + error.length, startPos, endPos)) {
                     exists = true;
                 }
@@ -497,7 +525,7 @@ namespace FourSlash {
                 Harness.IO.log("Unexpected error(s) found.  Error list is:");
             }
 
-            errors.forEach(function(error: ts.Diagnostic) {
+            errors.forEach(function (error: ts.Diagnostic) {
                 Harness.IO.log("  minChar: " + error.start +
                     ", limChar: " + (error.start + error.length) +
                     ", message: " + ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine()) + "\n");

src/server/editorServices.ts

@@ -1040,7 +1040,6 @@ namespace ts.server {
                 if (!project.languageServiceEnabled) {
                     project.enableLanguageService();
                 }
-                
                 this.watchConfigDirectoryForProject(project, projectOptions);
                 this.updateNonInferredProject(project, projectOptions.files, fileNamePropertyReader, projectOptions.compilerOptions, projectOptions.typingOptions, projectOptions.compileOnSave, configFileErrors);
             }

src/server/project.ts

@@ -171,6 +171,10 @@ namespace ts.server {
         };
     }
 
+    export interface PluginModule {
+        create(proj: Project, languageService: LanguageService, config: any): LanguageService;
+    }
+
     export abstract class Project {
         private rootFiles: ScriptInfo[] = [];
         private rootFilesMap: FileMap<ScriptInfo> = createFileMap<ScriptInfo>();
@@ -234,20 +238,21 @@ namespace ts.server {
             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);
+            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) {
+                    }
+                    catch (e) {
                         log(`Require failed: ${e}`);
                     }
                     loaded = true;
                 }
                 else {
-                    searchPath = normalizePath(combinePaths(searchPath, '..'));
+                    searchPath = normalizePath(combinePaths(searchPath, ".."));
                     log(`Walking up to probe ${searchPath}`);
                 }
             }
@@ -873,34 +878,35 @@ namespace ts.server {
             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;
             }
 
-            if (typeof require === 'undefined') {
-                this.projectService.logger.info('Plugins were requested but not running in node environment. Nothing will be loaded');
+            if (typeof require === "undefined") {
+                this.projectService.logger.info("Plugins were requested but not running in node environment. Nothing will be loaded");
                 return;
             }
 
             for (const pluginConfigEntry of options.plugins) {
-                const searchPath = combinePaths(this.configFileName, '../node_modules');
-                const resolvedModule = Project.resolveModule(pluginConfigEntry.name, searchPath, host, log);
+                const searchPath = combinePaths(this.configFileName, "..");
+                const resolvedModule = <PluginModule>Project.resolveModule(pluginConfigEntry.name, searchPath, host, log);
                 if (resolvedModule) {
                     this.enableProxy(resolvedModule, pluginConfigEntry);
                 }
             }
         }
 
-        private enableProxy(pluginModule: any, configEntry: PluginImport) {
-            this.languageService = pluginModule.create(this, this.languageService, configEntry);
+        private enableProxy(pluginModule: PluginModule, configEntry: PluginImport) {
+            try {
+                this.languageService = pluginModule.create(this, this.languageService, configEntry);
+            }
+            catch (e) {
+                this.projectService.logger.info(`Plugin activation failed: ${e}`);
+            }
         }
 
         getProjectRootPath() {

src/server/utilities.ts

@@ -173,11 +173,6 @@ namespace ts.server {
         compilerOptions?: CompilerOptions;
         typingOptions?: TypingOptions;
         compileOnSave?: boolean;
-
-        /**
-         * Additional behavior
-         */
-        "ng-templates"?: string[];
     }
 
     export function isInferredProjectName(name: string) {

tests/cases/fourslash/server/ngProxy1.ts

@@ -16,4 +16,4 @@
 //// 
 
 goTo.marker();
-debug.printCurrentQuickInfo();
+verify.quickInfoIs('Proxied x: number[]Check');