[mlir][PDLL] Add initial support for a PDLL compilation database

[rriddle]

Summary

The compilation database acts in a similar way to the compilation database
(compile_commands.json) used by clang-tidy, i.e. it provides additional
information about the compilation of project files to help the language
server. The main piece of information provided by the PDLL compilation
database in this commit is the set of include directories used when processing
the input .pdll file. This allows for the server to properly process .pdll files
that use includes anchored by the include directories set up in the build system.

The structure of the textual form of a compilation database is a yaml file
containing documents of the following form:

--- !FileInfo:
  filepath: <string> - Absolute file path of the file.
  includes: <string> - Semi-colon delimited list of include directories.

This commit also adds support to cmake for automatically generating
a pdll_compile_commands.yml file at the top-level of the build
directory.

[jpienaar]

Nice, thanks!

mlir/lib/Tools/mlir-pdll-lsp-server/CompilationDatabase.cpp

50

This doesn't feel like consistent auto usage

74

Do we care about overlap?

mlir/lib/Tools/mlir-pdll-lsp-server/CompilationDatabase.h

40

Construct from ?

45

s/this file/'filename'/ ? ("this" always feels overloaded unless referring to object)

mlir/lib/Tools/mlir-pdll-lsp-server/MlirPdllLspServerMain.cpp

59

YAML instead of .yml? (Type more important than file extension)

[rriddle]

mlir/lib/Tools/mlir-pdll-lsp-server/CompilationDatabase.cpp

74

Not really IMO, given that such a situation would imply some misconfiguration in compilation databases (these files are intended to be absolute paths). Ignoring them doesn't really "harm" anyone, but added a log message.

mlir/cmake/modules/AddMLIR.cmake

 include(GNUInstallDirs)
 include(LLVMDistributionSupport)
 
 function(mlir_tablegen ofn)
   tablegen(MLIR ${ARGV})
   set(TABLEGEN_OUTPUT ${TABLEGEN_OUTPUT} ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
       PARENT_SCOPE)
 endfunction()
 
+# Clear out any pre-existing compile_commands file before processing. This
+# allows for generating a clean compile_commands on each configure.
+file(REMOVE ${CMAKE_BINARY_DIR}/pdll_compile_commands.yml)
+
 # Declare a PDLL library in the current directory.
 function(add_mlir_pdll_library target inputFile ofn)
   set(LLVM_TARGET_DEFINITIONS ${inputFile})
 
   tablegen(MLIR_PDLL ${ofn} -x=cpp ${ARGN})
   set(TABLEGEN_OUTPUT ${TABLEGEN_OUTPUT} ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
       PARENT_SCOPE)
 
+  # Get the current set of include paths for this pdll file.
+  cmake_parse_arguments(ARG "" "" "DEPENDS;EXTRA_INCLUDES" ${ARGN})
+  get_directory_property(tblgen_includes INCLUDE_DIRECTORIES)
+  list(APPEND tblgen_includes ${ARG_EXTRA_INCLUDES})
+  # Filter out any empty include items.
+  list(REMOVE_ITEM tblgen_includes "")
+
+  # Build the absolute path for the current input file.
+  if (IS_ABSOLUTE ${LLVM_TARGET_DEFINITIONS})
+    set(LLVM_TARGET_DEFINITIONS_ABSOLUTE ${inputFile})
+  else()
+    set(LLVM_TARGET_DEFINITIONS_ABSOLUTE ${CMAKE_CURRENT_SOURCE_DIR}/${inputFile})
+  endif()
+
+  # Append the includes used for this file to the pdll_compilation_commands
+  # file.
+  file(APPEND ${CMAKE_BINARY_DIR}/pdll_compile_commands.yml
+      "--- !FileInfo:\n"
+      "  filepath: \"${LLVM_TARGET_DEFINITIONS_ABSOLUTE}\"\n"
+      "  includes: \"${CMAKE_CURRENT_SOURCE_DIR};${tblgen_includes}\"\n"
+  )
+  
   add_public_tablegen_target(${target})
 endfunction()
 
 # Declare a dialect in the include directory
 function(add_mlir_dialect dialect dialect_namespace)
   set(LLVM_TARGET_DEFINITIONS ${dialect}.td)
   mlir_tablegen(${dialect}.h.inc -gen-op-decls)
   mlir_tablegen(${dialect}.cpp.inc -gen-op-defs)

mlir/lib/Tools/mlir-pdll-lsp-server/CMakeLists.txt

 llvm_add_library(MLIRPdllLspServerLib
+  CompilationDatabase.cpp
   LSPServer.cpp
   PDLLServer.cpp
   MlirPdllLspServerMain.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Tools/mlir-pdll-lsp-server
 
   LINK_LIBS PUBLIC
   MLIRPDLLParser
   MLIRLspServerSupportLib
   )

mlir/lib/Tools/mlir-pdll-lsp-server/CompilationDatabase.h

+//===- CompilationDatabase.h - PDLL Compilation Database --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_COMPILATIONDATABASE_H_
+#define LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_COMPILATIONDATABASE_H_
+
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/StringMap.h"
+#include <memory>
+#include <string>
+
+namespace mlir {
+namespace lsp {
+/// This class contains a collection of compilation information for files
+/// provided to the language server, such as the available include directories.
+/// This database acts as an aggregate in-memory form of compilation databases
+/// used by the current language client. The textual form of a compilation
+/// database is a YAML file containing documents of the following form:
+///
+/// --- !FileInfo:
+///   filepath: <string> - Absolute file path of the file.
+///   includes: <string> - Semi-colon delimited list of include directories.
+///
+class CompilationDatabase {
+public:
+  /// Compilation information for a specific file within the database.
+  struct FileInfo {
+    /// The absolute path to the file.
+    std::string filename;
+    /// The include directories available for the file.
+    std::vector<std::string> includeDirs;
+  };
+
+  /// Construct a compilation database from the provided files containing YAML
+  /// descriptions of the database.
+  CompilationDatabase(ArrayRef<std::string> databases);
+
+  /// Get the compilation information for the provided file, or nullptr if the
+  /// database doesn't include information for `filename`.
+  const FileInfo *getFileInfo(StringRef filename) const;
+
+private:
+  /// Load the given database file into this database.
+  void loadDatabase(StringRef filename);
+
+  /// A map of filename to file information for each known file within the
+  /// databases.
+  llvm::StringMap<FileInfo> files;
+};
+} // namespace lsp
+} // namespace mlir
+
+#endif // LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_COMPILATIONDATABASE_H_

mlir/lib/Tools/mlir-pdll-lsp-server/CompilationDatabase.cpp

+//===- CompilationDatabase.cpp - PDLL Compilation Database ----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "CompilationDatabase.h"
+#include "../lsp-server-support/Logging.h"
+#include "mlir/Support/FileUtilities.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace mlir;
+using namespace mlir::lsp;
+
+//===----------------------------------------------------------------------===//
+// CompilationDatabase
+//===----------------------------------------------------------------------===//
+
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(CompilationDatabase::FileInfo)
+
+namespace llvm {
+namespace yaml {
+template <>
+struct MappingTraits<CompilationDatabase::FileInfo> {
+  static void mapping(IO &io, CompilationDatabase::FileInfo &info) {
+    io.mapRequired("filepath", info.filename);
+
+    // Parse the includes from the yaml stream. These are in the form of a
+    // semi-colon delimited list.
+    std::string combinedIncludes;
+    io.mapRequired("includes", combinedIncludes);
+    for (StringRef include : llvm::split(combinedIncludes, ";")) {
+      if (!include.empty())
+        info.includeDirs.push_back(include.str());
+    }
+  }
+};
+} // end namespace yaml
+} // end namespace llvm
+
+CompilationDatabase::CompilationDatabase(ArrayRef<std::string> databases) {
+  for (StringRef filename : databases)
+    loadDatabase(filename);
+}
+
+const CompilationDatabase::FileInfo *
+CompilationDatabase::getFileInfo(StringRef filename) const {
+  auto it = files.find(filename);
+  return it == files.end() ? nullptr : &it->second;
+}
+
+void CompilationDatabase::loadDatabase(StringRef filename) {
+  if (filename.empty())
+    return;
+
+  // Set up the input file.
+  std::string errorMessage;
+  std::unique_ptr<llvm::MemoryBuffer> inputFile =
+      openInputFile(filename, &errorMessage);
+  if (!inputFile) {
+    Logger::error("Failed to open compilation database: {0}", errorMessage);
+    return;
+  }
+  llvm::yaml::Input yaml(inputFile->getBuffer());
+
+  // Parse the yaml description and add any new files to the database.
+  std::vector<FileInfo> parsedFiles;
+  yaml >> parsedFiles;
+  for (auto &file : parsedFiles) {
+    auto it = files.try_emplace(file.filename, std::move(file));
+
+    // If we encounter a duplicate file, log a warning and ignore it.
+    if (!it.second) {
+      Logger::info("Duplicate .pdll file in compilation database: {0}",
+                   file.filename);
+    }
+  }
+}

mlir/lib/Tools/mlir-pdll-lsp-server/MlirPdllLspServerMain.cpp

LogicalResult mlir::MlirPdllLspServerMain(int argc, char **argv) {
   llvm::cl::opt<bool> prettyPrint{
       "pretty",
       llvm::cl::desc("Pretty-print JSON output"),
       llvm::cl::init(false),
   };
   llvm::cl::list<std::string> extraIncludeDirs(
       "pdll-extra-dir", llvm::cl::desc("Extra directory of include files"),
       llvm::cl::value_desc("directory"), llvm::cl::Prefix);
+  llvm::cl::list<std::string> compilationDatabases(
+      "pdll-compilation-database",
+      llvm::cl::desc("Compilation YAML databases containing additional "
+                     "compilation information for .pdll files"));
 
   llvm::cl::ParseCommandLineOptions(argc, argv, "PDLL LSP Language Server");
 
   if (litTest) {
     inputStyle = JSONStreamStyle::Delimited;
     logLevel = Logger::Level::Debug;
     prettyPrint = true;
   }
 
   // Configure the logger.
   Logger::setLogLevel(logLevel);
 
   // Configure the transport used for communication.
   llvm::sys::ChangeStdinToBinary();
   JSONTransport transport(stdin, llvm::outs(), inputStyle, prettyPrint);
 
   // Configure the servers and start the main language server.
-  PDLLServer::Options options(extraIncludeDirs);
+  PDLLServer::Options options(compilationDatabases, extraIncludeDirs);
   PDLLServer server(options);
   return runPdllLSPServer(server, transport);
 }

mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.h

 //===- PDLLServer.h - PDL General Language Server ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_SERVER_H_
 #define LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_SERVER_H_
 
 #include "mlir/Support/LLVM.h"
+#include "llvm/ADT/StringRef.h"
 #include <memory>
 #include <string>
 
 namespace mlir {
 namespace lsp {
 struct Diagnostic;
+class CompilationDatabase;
 struct CompletionList;
 struct DocumentSymbol;
 struct Hover;
 struct Location;
 struct Position;
 struct SignatureHelp;
 class URIForFile;
 
 /// This class implements all of the PDLL related functionality necessary for a
 /// language server. This class allows for keeping the PDLL specific logic
 /// separate from the logic that involves LSP server/client communication.
 class PDLLServer {
 public:
   struct Options {
-    Options(const std::vector<std::string> &extraDirs) : extraDirs(extraDirs){};
+    Options(const std::vector<std::string> &compilationDatabases,
+            const std::vector<std::string> &extraDirs)
+        : compilationDatabases(compilationDatabases), extraDirs(extraDirs) {}
+
+    /// The filenames for databases containing compilation commands for PDLL
+    /// files passed to the server.
+    const std::vector<std::string> &compilationDatabases;
 
     /// Additional list of include directories to search.
     const std::vector<std::string> &extraDirs;
   };
 
   PDLLServer(const Options &options);
   ~PDLLServer();
 

mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp

 //===- PDLLServer.cpp - PDLL Language Server ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PDLLServer.h"
 
 #include "../lsp-server-support/Logging.h"
 #include "../lsp-server-support/Protocol.h"
+#include "CompilationDatabase.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "mlir/Tools/PDLL/AST/Nodes.h"
 #include "mlir/Tools/PDLL/AST/Types.h"
 #include "mlir/Tools/PDLL/ODS/Constraint.h"
 #include "mlir/Tools/PDLL/ODS/Context.h"
 #include "mlir/Tools/PDLL/ODS/Dialect.h"
 #include "mlir/Tools/PDLL/ODS/Operation.h"
 #include "mlir/Tools/PDLL/Parser/CodeComplete.h"
PDLDocument::PDLDocument(const lsp::URIForFile &uri, StringRef contents,
                          std::vector<lsp::Diagnostic> &diagnostics)
     : astContext(odsContext) {
   auto memBuffer = llvm::MemoryBuffer::getMemBufferCopy(contents, uri.file());
   if (!memBuffer) {
     lsp::Logger::error("Failed to create memory buffer for file", uri.file());
     return;
   }
 
-  // TODO: Properly provide include directories from the client.
+  // Build the set of include directories for this file.
   llvm::SmallString<32> uriDirectory(uri.file());
   llvm::sys::path::remove_filename(uriDirectory);
   includeDirs.push_back(uriDirectory.str().str());
   includeDirs.insert(includeDirs.end(), extraDirs.begin(), extraDirs.end());
 
   sourceMgr.setIncludeDirs(includeDirs);
   sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
 
PDLTextFileChunk &PDLTextFile::getChunkFor(lsp::Position &pos) {
   return chunk;
 }
 
 //===----------------------------------------------------------------------===//
 // PDLLServer::Impl
 //===----------------------------------------------------------------------===//
 
 struct lsp::PDLLServer::Impl {
-  explicit Impl(const Options &options) : options(options) {}
+  explicit Impl(const Options &options)
+      : options(options), compilationDatabase(options.compilationDatabases) {}
 
   /// PDLL LSP options.
   const Options &options;
 
+  /// The compilation database containing additional information for files
+  /// passed to the server.
+  lsp::CompilationDatabase compilationDatabase;
+
   /// The files held by the server, mapped by their URI file name.
   llvm::StringMap<std::unique_ptr<PDLTextFile>> files;
 };
 
 //===----------------------------------------------------------------------===//
 // PDLLServer
 //===----------------------------------------------------------------------===//
 
 lsp::PDLLServer::PDLLServer(const Options &options)
     : impl(std::make_unique<Impl>(options)) {}
 lsp::PDLLServer::~PDLLServer() = default;
 
 void lsp::PDLLServer::addOrUpdateDocument(
     const URIForFile &uri, StringRef contents, int64_t version,
     std::vector<Diagnostic> &diagnostics) {
+  std::vector<std::string> additionalIncludeDirs = impl->options.extraDirs;
+  if (auto *fileInfo = impl->compilationDatabase.getFileInfo(uri.file()))
+    llvm::append_range(additionalIncludeDirs, fileInfo->includeDirs);
+
   impl->files[uri.file()] = std::make_unique<PDLTextFile>(
-      uri, contents, version, impl->options.extraDirs, diagnostics);
+      uri, contents, version, additionalIncludeDirs, diagnostics);
 }
 
 Optional<int64_t> lsp::PDLLServer::removeDocument(const URIForFile &uri) {
   auto it = impl->files.find(uri.file());
   if (it == impl->files.end())
     return llvm::None;
 
   int64_t version = it->second->getVersion();

mlir/test/mlir-pdll-lsp-server/compilation_database.test

+// RUN: echo -e '--- !FileInfo:\n  filepath: "/foo.pdll"\n  includes: "%S;%S/../../include"' > %t.yml
+// RUN: mlir-pdll-lsp-server -pdll-compilation-database=%t.yml -lit-test < %s | FileCheck %s
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"pdll","capabilities":{},"trace":"off"}}
+// -----
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{
+  "uri":"test:///foo.pdll",
+  "languageId":"pdll",
+  "version":1,
+  "text":"#include \"include/included.td\"\n#include \"include/included.pdll\""
+}}}
+// Check that we can properly process the includes without errors.
+// CHECK: "method": "textDocument/publishDiagnostics",
+// CHECK-NEXT: "params": {
+// CHECK-NEXT:     "diagnostics": [],
+// CHECK-NEXT:     "uri": "test:///foo.pdll",
+// CHECK-NEXT:     "version": 1
+// CHECK-NEXT:   }
+// -----
+{"jsonrpc":"2.0","id":7,"method":"shutdown"}
+// -----
+{"jsonrpc":"2.0","method":"exit"}

mlir/test/mlir-pdll-lsp-server/include/included.pdll

+// This file is merely to test the processing of includes, it has
+// no other purpose or contents.

mlir/test/mlir-pdll-lsp-server/include/included.td

+include "mlir/IR/OpBase.td"
+
+// This file is merely to test the processing of includes, it has
+// no other purpose or contents.

mlir/test/mlir-pdll-lsp-server/lit.local.cfg

+config.excludes = ['include']

mlir/utils/vscode/package.json

"configuration": {
           "type": "string",
           "description": "The file path of the mlir-lsp-server executable."
         },
         "mlir.pdll_server_path": {
           "scope": "resource",
           "type": "string",
           "description": "The file path of the mlir-pdll-lsp-server executable."
         },
+        "mlir.pdll_compilation_databases": {
+          "scope": "resource",
+          "type": "array",
+          "description": "A list of `pdll_compile_commands.yml` database files containing information about .pdll files processed by the server."
+        },
         "mlir.onSettingsChanged": {
           "type": "string",
           "default": "prompt",
           "description": "Action taken when a setting change requires a server restart to take effect.",
           "enum": [
             "prompt",
             "restart",
             "ignore"

mlir/utils/vscode/src/configWatcher.ts

default:
     break;
   }
 }
 
 /**
  *  Activate watchers that track configuration changes for the given workspace
  *  folder, or null if the workspace is top-level.
  */
-export async function activate(mlirContext: MLIRContext,
-                               workspaceFolder: vscode.WorkspaceFolder,
-                               serverSetting: string, serverPath: string) {
+export async function activate(
+    mlirContext: MLIRContext, workspaceFolder: vscode.WorkspaceFolder,
+    serverSettings: string[], serverPaths: string[]) {
   // When a configuration change happens, check to see if we should restart the
   // server.
   mlirContext.subscriptions.push(vscode.workspace.onDidChangeConfiguration(event => {
+    for (const serverSetting of serverSettings) {
       const expandedSetting = `mlir.${serverSetting}`;
       if (event.affectsConfiguration(expandedSetting, workspaceFolder)) {
         promptRestart(
             'onSettingsChanged',
             `setting '${
                 expandedSetting}' has changed. Do you want to reload the server?`);
       }
-  }));
-
-  // If the server path actually exists, track it in case it changes. Check that
-  // the path actually exists.
-  if (serverPath === '') {
-    return;
     }
+  }));
 
+  // Setup watchers for the provided server paths.
   const fileWatcherConfig = {
     disableGlobbing : true,
     followSymlinks : true,
     ignoreInitial : true,
     awaitWriteFinish : true,
   };
+  for (const serverPath of serverPaths) {
+    if (serverPath === '') {
+      return;
+    }
+
+    // If the server path actually exists, track it in case it changes.
     const fileWatcher = chokidar.watch(serverPath, fileWatcherConfig);
     fileWatcher.on('all', (event, _filename, _details) => {
       if (event != 'unlink') {
         promptRestart(
             'onSettingsChanged',
-          'MLIR language server binary has changed. Do you want to reload the server?');
+            'MLIR language server file has changed. Do you want to reload the server?');
       }
     });
     mlirContext.subscriptions.push(
         new vscode.Disposable(() => { fileWatcher.close(); }));
   }
+}

mlir/utils/vscode/src/mlirContext.ts

this.subscriptions.push(
               client.dispose();
               this.workspaceFolders.delete(folder.uri.toString());
             }
           }
         }));
   }
 
   /**
+   *  Prepare the server options for a PDLL server, e.g. populating any
+   *  accessible compilation databases.
+   */
+  async preparePDLLServerOptions(workspaceFolder: vscode.WorkspaceFolder,
+                                 configsToWatch: string[],
+                                 pathsToWatch: string[],
+                                 additionalServerArgs: string[]) {
+    // Process the compilation databases attached for the workspace folder.
+    let databases =
+        config.get<string[]>('pdll_compilation_databases', workspaceFolder);
+
+    // If no databases were explicitly specified, default to a database in the
+    // 'build' directory within the current workspace.
+    if (databases.length === 0) {
+      if (workspaceFolder) {
+        databases.push(workspaceFolder.uri.fsPath +
+                       '/build/pdll_compile_commands.yml');
+      }
+
+      // Otherwise, try to resolve each of the paths.
+    } else {
+      for await (let database of databases) {
+        database = await this.resolvePath(database, '', workspaceFolder);
+      }
+    }
+
+    configsToWatch.push('pdll_compilation_databases');
+    pathsToWatch.push(...databases);
+
+    // Setup the compilation databases as additional arguments to pass to the
+    // server.
+    databases.filter(database => database !== '');
+    additionalServerArgs.push(...databases.map(
+        (database) => `--pdll-compilation-database=${database}`));
+  }
+
+  /**
    *  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):
       Promise<vscodelc.LanguageClient> {
+    let configsToWatch: string[] = [];
+    let filepathsToWatch: string[] = [];
+    let additionalServerArgs: string[] = [];
+
+    // Initialize additional configurations for this server.
+    if (languageName === 'pdll') {
+      await this.preparePDLLServerOptions(workspaceFolder, configsToWatch,
+                                          filepathsToWatch,
+                                          additionalServerArgs);
+    }
+
+    // Try to activate the language client.
     const [server, serverPath] = await this.startLanguageClient(
-        workspaceFolder, outputChannel, serverSettingName, languageName);
+        workspaceFolder, outputChannel, serverSettingName, languageName,
+        additionalServerArgs);
+    configsToWatch.push(serverSettingName);
+    filepathsToWatch.push(serverPath);
 
     // Watch for configuration changes on this folder.
-    await configWatcher.activate(this, workspaceFolder, serverSettingName,
-                                 serverPath);
+    await configWatcher.activate(this, workspaceFolder, configsToWatch,
+                                 filepathsToWatch);
     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,
-                            serverSettingName: string, languageName: string):
+                            serverSettingName: string, languageName: string,
+                            additionalServerArgs: 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 (!fs.existsSync(serverPath)) {
       return [ null, serverPath ];
     }
 
     // Configure the server options.
     const serverOptions: vscodelc.ServerOptions = {
       run : {
         command : serverPath,
         transport : vscodelc.TransportKind.stdio,
-        args : []
+        args : additionalServerArgs
       },
       debug : {
         command : serverPath,
         transport : vscodelc.TransportKind.stdio,
-        args : []
+        args : additionalServerArgs
       }
     };
 
     // Configure file patterns relative to the workspace folder.
     let filePattern: vscode.GlobPattern = '**/*.' + languageName;
     let selectorPattern: string = null;
     if (workspaceFolder) {
       filePattern = new vscode.RelativePattern(workspaceFolder, filePattern);
static getDefaultServerFilename(serverSettingName: string): string {
     }
     if (serverSettingName === 'server_path') {
       return 'mlir-lsp-server';
     }
     return '';
   }
 
   /**
-   * Try to resolve the path for the given server setting, with an optional
-   * workspace folder.
+   * Try to resolve the given path, or the default path, with an optional
+   * workspace folder. If a path could not be resolved, just returns the
+   * input filePath.
    */
-  async resolveServerPath(serverSettingName: string,
-                          workspaceFolder: vscode.WorkspaceFolder):
-      Promise<string> {
-    const configServerPath =
-        config.get<string>(serverSettingName, workspaceFolder);
-    let serverPath = configServerPath;
+  async resolvePath(filePath: string, defaultPath: string,
+                    workspaceFolder: vscode.WorkspaceFolder): Promise<string> {
+    const configPath = filePath;
 
     // If the path is already fully resolved, there is nothing to do.
-    if (path.isAbsolute(serverPath)) {
-      return serverPath;
+    if (path.isAbsolute(filePath)) {
+      return filePath;
     }
 
     // If a path hasn't been set, try to use the default path.
-    if (serverPath === '') {
-      serverPath = MLIRContext.getDefaultServerFilename(serverSettingName);
-      if (serverPath === '') {
-        return serverPath;
+    if (filePath === '') {
+      if (defaultPath === '') {
+        return filePath;
       }
+      filePath = defaultPath;
+
       // Fallthrough to try resolving the default path.
     }
 
     // Try to resolve the path relative to the workspace.
-    let filePattern: vscode.GlobPattern = '**/' + serverPath;
+    let filePattern: vscode.GlobPattern = '**/' + filePath;
     if (workspaceFolder) {
       filePattern = new vscode.RelativePattern(workspaceFolder, filePattern);
     }
     let foundUris = await vscode.workspace.findFiles(filePattern, null, 1);
     if (foundUris.length === 0) {
-      // If we couldn't resolve it, just return the current configuration path
-      // anyways. The file might not exist yet.
-      return configServerPath;
+      // If we couldn't resolve it, just return the original path anyways. The
+      // file might not exist yet.
+      return configPath;
     }
     // Otherwise, return the resolved path.
     return foundUris[0].fsPath;
   }
 
+  /**
+   * Try to resolve the path for the given server setting, with an optional
+   * workspace folder.
+   */
+  async resolveServerPath(serverSettingName: string,
+                          workspaceFolder: vscode.WorkspaceFolder):
+      Promise<string> {
+    const serverPath = config.get<string>(serverSettingName, workspaceFolder);
+    const defaultPath = MLIRContext.getDefaultServerFilename(serverSettingName);
+    return this.resolvePath(serverPath, defaultPath, workspaceFolder);
+  }
+
   dispose() {
     this.subscriptions.forEach((d) => { d.dispose(); });
     this.subscriptions = [];
     this.workspaceFolders.forEach((d) => { d.dispose(); });
     this.workspaceFolders.clear();
   }
 }