[mlir-vscode] Don't emit errors if the user didn't set the server path

[rriddle]

Summary

This avoids emitting errors in situations where the user doesn't have a server
setup, and doesn't mean to (e.g. when they merely want syntax highlighting).

mlir/utils/vscode/src/extension.ts

export function activate(context: vscode.ExtensionContext) {
   context.subscriptions.push(outputChannel);
 
   const mlirContext = new MLIRContext();
   context.subscriptions.push(mlirContext);
 
   // Initialize the commands of the extension.
   context.subscriptions.push(
       vscode.commands.registerCommand('mlir.restart', async () => {
-        // Dispose and reactivate the context. This is essentially the same as
-        // the start of the extension, but we don't re-emit warnings for
-        // uninitialized settings.
+        // Dispose and reactivate the context.
         mlirContext.dispose();
-        await mlirContext.activate(outputChannel,
-                                   /*warnOnEmptyServerPath=*/ false);
+        await mlirContext.activate(outputChannel);
       }));
 
-  mlirContext.activate(outputChannel, /*warnOnEmptyServerPath=*/ true);
+  mlirContext.activate(outputChannel);
 }

mlir/utils/vscode/src/mlirContext.ts

  */
 export class MLIRContext implements vscode.Disposable {
   subscriptions: vscode.Disposable[] = [];
   workspaceFolders: Map<string, WorkspaceFolderContext> = new Map();
 
   /**
    *  Activate the MLIR context, and start the language clients.
    */
-  async activate(outputChannel: vscode.OutputChannel,
-                 warnOnEmptyServerPath: boolean) {
+  async activate(outputChannel: vscode.OutputChannel) {
     // This lambda is used to lazily start language clients for the given
     // document. It removes the need to pro-actively start language clients for
     // every folder within the workspace and every language type we provide.
     const startClientOnOpenDocument = async (document: vscode.TextDocument) => {
       if (document.uri.scheme !== 'file') {
         return;
       }
       let serverSettingName: string;
const startClientOnOpenDocument = async (document: vscode.TextDocument) => {
       if (!folderContext) {
         folderContext = new WorkspaceFolderContext();
         this.workspaceFolders.set(workspaceFolderStr, folderContext);
       }
       // Start the client for this language if necessary.
       if (!folderContext.clients.has(document.languageId)) {
         let client = await this.activateWorkspaceFolder(
             workspaceFolder, serverSettingName, document.languageId,
-            outputChannel, warnOnEmptyServerPath);
+            outputChannel);
         folderContext.clients.set(document.languageId, client);
       }
     };
     // Process any existing documents.
     vscode.workspace.textDocuments.forEach(startClientOnOpenDocument);
 
     // Watch any new documents to spawn servers when necessary.
     this.subscriptions.push(
export class MLIRContext implements vscode.Disposable {
   }
 
   /**
    *  Activate the language client for the given language in the given workspace
    *  folder.
    */
   async activateWorkspaceFolder(workspaceFolder: vscode.WorkspaceFolder,
                                 serverSettingName: string, languageName: string,
-                                outputChannel: vscode.OutputChannel,
-                                warnOnEmptyServerPath: boolean):
+                                outputChannel: vscode.OutputChannel):
       Promise<vscodelc.LanguageClient> {
     const [server, serverPath] = await this.startLanguageClient(
-        workspaceFolder, outputChannel, warnOnEmptyServerPath,
-        serverSettingName, languageName);
+        workspaceFolder, outputChannel, serverSettingName, languageName);
 
     // Watch for configuration changes on this folder.
     await configWatcher.activate(this, workspaceFolder, serverSettingName,
                                  serverPath);
     return server;
   }
 
   /**
    *  Start a new language client for the given language. Returns an array
    *  containing the opened server, or null if the server could not be started,
    *  and the resolved server path.
    */
   async startLanguageClient(workspaceFolder: vscode.WorkspaceFolder,
                             outputChannel: vscode.OutputChannel,
-                            warnOnEmptyServerPath: boolean,
                             serverSettingName: string, languageName: string):
       Promise<[ vscodelc.LanguageClient, string ]> {
     const clientTitle = languageName.toUpperCase() + ' Language Client';
 
     // Get the path of the lsp-server that is used to provide language
     // functionality.
     var serverPath =
         await this.resolveServerPath(serverSettingName, workspaceFolder);
 
-    // If we aren't emitting warnings on an empty server path, and the server
-    // path is empty, bail.
-    if (!warnOnEmptyServerPath && serverPath === '') {
+    // If the server path is empty, bail. We don't emit errors if the user
+    // hasn't explicitly configured the server.
+    if (serverPath === '') {
       return [ null, serverPath ];
     }
 
     // Check that the file actually exists.
-    if (serverPath === '' || !fs.existsSync(serverPath)) {
+    if (!fs.existsSync(serverPath)) {
       vscode.window
           .showErrorMessage(
               `${clientTitle}: Unable to resolve path for '${
                   serverSettingName}', please ensure the path is correct`,
               "Open Setting")
           .then((value) => {
             if (value === "Open Setting") {
               vscode.commands.executeCommand(