[mlir][Tablegen-LSP] Add support for a compilation database

[rriddle]

Summary

This provides a format for externally specifying the include directories
for a source file. The format of the tablegen database is exactly the
same as that for PDLL, namely it includes the absolute source file name and
the set of include directories. The database format is shared to simplify
the infra, and also because the format itself is general enough to share. Even
if we desire to expand in the future to contain the actual compilation command,
nothing there is specific enough that we would need two different formats.

As with PDLL, support for generating the database is added to our mlir_tablegen
cmake command.

[jpienaar]

Nice thanks

[lanza]

mlir/cmake/modules/AddMLIR.cmake

29

Hey @rriddle, any reason this logic shouldn't be mirrored in llvm/clang/lldb's tablegen functions?

mlir/cmake/modules/AddMLIR.cmake

 include(GNUInstallDirs)
 include(LLVMDistributionSupport)
 
+# 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}/tablegen_compile_commands.yml)
+
 function(mlir_tablegen ofn)
   tablegen(MLIR ${ARGV})
   set(TABLEGEN_OUTPUT ${TABLEGEN_OUTPUT} ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
       PARENT_SCOPE)
+      
+  # Get the current set of include paths for this td 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 ${LLVM_TARGET_DEFINITIONS})
+  else()
+    set(LLVM_TARGET_DEFINITIONS_ABSOLUTE ${CMAKE_CURRENT_SOURCE_DIR}/${LLVM_TARGET_DEFINITIONS})
+  endif()
+
+  # Append the includes used for this file to the tablegen_compile_commands
+  # file.
+  file(APPEND ${CMAKE_BINARY_DIR}/tablegen_compile_commands.yml
+      "--- !FileInfo:\n"
+      "  filepath: \"${LLVM_TARGET_DEFINITIONS_ABSOLUTE}\"\n"
+      "  includes: \"${CMAKE_CURRENT_SOURCE_DIR};${tblgen_includes}\"\n"
+  )
 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)

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

 add_mlir_library(MLIRLspServerSupportLib
+  CompilationDatabase.cpp
   Logging.cpp
   Protocol.cpp
   SourceMgrUtils.cpp
   Transport.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Tools/lsp-server
 
   LINK_LIBS PUBLIC
   MLIRSupport
   )

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

-//===- CompilationDatabase.h - PDLL Compilation Database --------*- C++ -*-===//
+//===- CompilationDatabase.h - LSP 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
 //
 //===----------------------------------------------------------------------===//
+//
+// This file contains a definition of a generic compilation database that can be
+// used to provide information about the compilation of a given source file. It
+// contains generic components, leaving more complex interpretation to the
+// specific language servers that consume it.
+//
+//===----------------------------------------------------------------------===//
 
-#ifndef LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_COMPILATIONDATABASE_H_
-#define LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_COMPILATIONDATABASE_H_
+#ifndef LIB_MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H_
+#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_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;
+    FileInfo() = default;
+    FileInfo(std::vector<std::string> &&includeDirs)
+        : includeDirs(std::move(includeDirs)) {}
+
     /// 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;
+  /// Get the compilation information for the provided file.
+  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;
+
+  /// A default file info that contains basic information for use by files that
+  /// weren't explicitly in the database.
+  FileInfo defaultFileInfo;
 };
 } // namespace lsp
 } // namespace mlir
 
-#endif // LIB_MLIR_TOOLS_MLIRPDLLSPSERVER_COMPILATIONDATABASE_H_
+#endif // LIB_MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H_

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

-//===- CompilationDatabase.cpp - PDLL Compilation Database ----------------===//
+//===- CompilationDatabase.cpp - LSP 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 "../lsp-server-support/Protocol.h"
 #include "mlir/Support/FileUtilities.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 //===----------------------------------------------------------------------===//
+// YamlFileInfo
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct YamlFileInfo {
+  /// The absolute path to the file.
+  std::string filename;
+  /// The include directories available for the file.
+  std::vector<std::string> includeDirs;
+};
+} // namespace
+
+//===----------------------------------------------------------------------===//
 // CompilationDatabase
 //===----------------------------------------------------------------------===//
 
-LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(CompilationDatabase::FileInfo)
+LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(YamlFileInfo)
 
 namespace llvm {
 namespace yaml {
 template <>
-struct MappingTraits<CompilationDatabase::FileInfo> {
-  static void mapping(IO &io, CompilationDatabase::FileInfo &info) {
+struct MappingTraits<YamlFileInfo> {
+  static void mapping(IO &io, YamlFileInfo &info) {
     // Parse the filename and normalize it to the form we will expect from
     // incoming URIs.
     io.mapRequired("filepath", info.filename);
 
     // Normalize the filename to avoid incompatability with incoming URIs.
     if (Expected<lsp::URIForFile> uri =
             lsp::URIForFile::fromFile(info.filename))
       info.filename = uri->file().str();

 } // end namespace yaml
 } // end namespace llvm
 
 CompilationDatabase::CompilationDatabase(ArrayRef<std::string> databases) {
   for (StringRef filename : databases)
     loadDatabase(filename);
 }
 
-const CompilationDatabase::FileInfo *
+const CompilationDatabase::FileInfo &
 CompilationDatabase::getFileInfo(StringRef filename) const {
   auto it = files.find(filename);
-  return it == files.end() ? nullptr : &it->second;
+  return it == files.end() ? defaultFileInfo : 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;
+  std::vector<YamlFileInfo> parsedFiles;
   yaml >> parsedFiles;
+
+  SetVector<StringRef> knownIncludes;
   for (auto &file : parsedFiles) {
-    auto it = files.try_emplace(file.filename, std::move(file));
+    auto it = files.try_emplace(file.filename, std::move(file.includeDirs));
 
     // If we encounter a duplicate file, log a warning and ignore it.
     if (!it.second) {
-      Logger::info("Duplicate .pdll file in compilation database: {0}",
+      Logger::info("Duplicate file in compilation database: {0}",
                    file.filename);
+      continue;
     }
+
+    // Track the includes for the file.
+    for (StringRef include : it.first->second.includeDirs)
+      knownIncludes.insert(include);
   }
+
+  // Add all of the known includes to the default file info. We don't know any
+  // information about how to treat these files, but these may be project files
+  // that we just don't yet have information for. In these cases, providing some
+  // heuristic information provides a better user experience, and generally
+  // shouldn't lead to any negative side effects.
+  for (StringRef include : knownIncludes)
+    defaultFileInfo.includeDirs.push_back(include.str());
 }

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/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/CompilationDatabase.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"

 
 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) {
+  // Build the set of additional include directories.
   std::vector<std::string> additionalIncludeDirs = impl->options.extraDirs;
-  if (auto *fileInfo = impl->compilationDatabase.getFileInfo(uri.file()))
-    llvm::append_range(additionalIncludeDirs, fileInfo->includeDirs);
+  const auto &fileInfo = impl->compilationDatabase.getFileInfo(uri.file());
+  llvm::append_range(additionalIncludeDirs, fileInfo.includeDirs);
 
   impl->files[uri.file()] = std::make_unique<PDLTextFile>(
       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())

mlir/lib/Tools/tblgen-lsp-server/TableGenLspServerMain.cpp

llvm::cl::opt<Logger::Level> logLevel{
           clEnumValN(Logger::Level::Debug, "verbose", "Low level details")),
       llvm::cl::init(Logger::Level::Info),
   };
   llvm::cl::opt<bool> prettyPrint{
       "pretty",
       llvm::cl::desc("Pretty-print JSON output"),
       llvm::cl::init(false),
   };
+  llvm::cl::list<std::string> extraIncludeDirs(
+      "tablegen-extra-dir", llvm::cl::desc("Extra directory of include files"),
+      llvm::cl::value_desc("directory"), llvm::cl::Prefix);
+  llvm::cl::list<std::string> compilationDatabases(
+      "tablegen-compilation-database",
+      llvm::cl::desc("Compilation YAML databases containing additional "
+                     "compilation information for .td files"));
 
   llvm::cl::ParseCommandLineOptions(argc, argv, "TableGen 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.
-  TableGenServer server;
+  TableGenServer::Options options(compilationDatabases, extraIncludeDirs);
+  TableGenServer server(options);
   return runTableGenLSPServer(server, transport);
 }

mlir/lib/Tools/tblgen-lsp-server/TableGenServer.h

 struct Diagnostic;
 class URIForFile;
 
 /// This class implements all of the TableGen related functionality necessary
 /// for a language server. This class allows for keeping the TableGen specific
 /// logic separate from the logic that involves LSP server/client communication.
 class TableGenServer {
 public:
-  TableGenServer();
+  struct Options {
+    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 TableGen
+    /// files passed to the server.
+    const std::vector<std::string> &compilationDatabases;
+
+    /// Additional list of include directories to search.
+    const std::vector<std::string> &extraDirs;
+  };
+
+  TableGenServer(const Options &options);
   ~TableGenServer();
 
   /// Add or update the document, with the provided `version`, at the given URI.
   /// Any diagnostics emitted for this document should be added to
   /// `diagnostics`.
   void addOrUpdateDocument(const URIForFile &uri, StringRef contents,
                            int64_t version,
                            std::vector<Diagnostic> &diagnostics);

mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp

 //===- TableGenServer.cpp - TableGen 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 "TableGenServer.h"
 
+#include "../lsp-server-support/CompilationDatabase.h"
 #include "../lsp-server-support/Logging.h"
 #include "../lsp-server-support/Protocol.h"
 #include "../lsp-server-support/SourceMgrUtils.h"
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/FileSystem.h"

 // TableGenTextFile
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class represents a text file containing one or more TableGen documents.
 class TableGenTextFile {
 public:
   TableGenTextFile(const lsp::URIForFile &uri, StringRef fileContents,
-                   int64_t version, std::vector<lsp::Diagnostic> &diagnostics);
+                   int64_t version,
+                   const std::vector<std::string> &extraIncludeDirs,
+                   std::vector<lsp::Diagnostic> &diagnostics);
 
   /// Return the current version of this text file.
   int64_t getVersion() const { return version; }
 
 private:
   /// The full string contents of the file.
   std::string contents;
 
   /// The version of this file.
   int64_t version;
 
   /// The include directories for this file.
   std::vector<std::string> includeDirs;
 
   /// The source manager containing the contents of the input file.
   llvm::SourceMgr sourceMgr;
 
   /// The record keeper containing the parsed tablegen constructs.
   llvm::RecordKeeper recordKeeper;
 };
 } // namespace
 
-TableGenTextFile::TableGenTextFile(const lsp::URIForFile &uri,
-                                   StringRef fileContents, int64_t version,
-                                   std::vector<lsp::Diagnostic> &diagnostics)
+TableGenTextFile::TableGenTextFile(
+    const lsp::URIForFile &uri, StringRef fileContents, int64_t version,
+    const std::vector<std::string> &extraIncludeDirs,
     : contents(fileContents.str()), version(version) {
   auto memBuffer = llvm::MemoryBuffer::getMemBufferCopy(contents, uri.file());
   if (!memBuffer) {
     lsp::Logger::error("Failed to create memory buffer for file", uri.file());
     return;
   }
 
   // Build the set of include directories for this file.
-  // TODO: Setup external include directories.
   llvm::SmallString<32> uriDirectory(uri.file());
   llvm::sys::path::remove_filename(uriDirectory);
   includeDirs.push_back(uriDirectory.str().str());
+  includeDirs.insert(includeDirs.end(), extraIncludeDirs.begin(),
+                     extraIncludeDirs.end());
 
   sourceMgr.setIncludeDirs(includeDirs);
   sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
 
   // This class provides a context argument for the llvm::SourceMgr diagnostic
   // handler.
   struct DiagHandlerContext {
     std::vector<lsp::Diagnostic> &diagnostics;
if (llvm::TableGenParseFile(sourceMgr, recordKeeper))
     return;
 }
 
 //===----------------------------------------------------------------------===//
 // TableGenServer::Impl
 //===----------------------------------------------------------------------===//
 
 struct lsp::TableGenServer::Impl {
+  explicit Impl(const Options &options)
+      : options(options), compilationDatabase(options.compilationDatabases) {}
+
+  /// TableGen 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<TableGenTextFile>> files;
 };
 
 //===----------------------------------------------------------------------===//
 // TableGenServer
 //===----------------------------------------------------------------------===//
 
-lsp::TableGenServer::TableGenServer() : impl(std::make_unique<Impl>()) {}
+lsp::TableGenServer::TableGenServer(const Options &options)
+    : impl(std::make_unique<Impl>(options)) {}
 lsp::TableGenServer::~TableGenServer() = default;
 
 void lsp::TableGenServer::addOrUpdateDocument(
     const URIForFile &uri, StringRef contents, int64_t version,
     std::vector<Diagnostic> &diagnostics) {
-  impl->files[uri.file()] =
-      std::make_unique<TableGenTextFile>(uri, contents, version, diagnostics);
+  // Build the set of additional include directories.
+  std::vector<std::string> additionalIncludeDirs = impl->options.extraDirs;
+  const auto &fileInfo = impl->compilationDatabase.getFileInfo(uri.file());
+  llvm::append_range(additionalIncludeDirs, fileInfo.includeDirs);
+
+  impl->files[uri.file()] = std::make_unique<TableGenTextFile>(
+      uri, contents, version, additionalIncludeDirs, diagnostics);
 }
 
 Optional<int64_t> lsp::TableGenServer::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();
   impl->files.erase(it);
   return version;
 }

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

+// RUN: echo -e '--- !FileInfo:\n  filepath: "/foo.td"\n  includes: "%/S;%/S/../../include"' > %t.yml
+// RUN: tblgen-lsp-server -tablegen-compilation-database=%t.yml -lit-test < %s | FileCheck %s
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"tablegen","capabilities":{},"trace":"off"}}
+// -----
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{
+  "uri":"test:///foo.td",
+  "languageId":"tablegen",
+  "version":1,
+  "text":"include \"include/included.td\""
+}}}
+// 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.td",
+// CHECK-NEXT:     "version": 1
+// CHECK-NEXT:   }
+// -----
+{"jsonrpc":"2.0","id":7,"method":"shutdown"}
+// -----
+{"jsonrpc":"2.0","method":"exit"}

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

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

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

+config.excludes = ['include']

mlir/utils/vscode/package.json

"configuration": {
           "type": "array",
           "description": "A list of `pdll_compile_commands.yml` database files containing information about .pdll files processed by the server."
         },
         "mlir.tablegen_server_path": {
           "scope": "resource",
           "type": "string",
           "description": "The file path of the tblgen-lsp-server executable."
         },
+        "mlir.tablegen_compilation_databases": {
+          "scope": "resource",
+          "type": "array",
+          "description": "A list of `tablegen_compile_commands.yml` database files containing information about .td 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/config.ts

 import * as vscode from 'vscode';
 
 /**
  *  Gets the config value `mlir.<key>`, with an optional workspace folder.
  */
 export function get<T>(key: string,
-                       workspaceFolder: vscode.WorkspaceFolder = null): T {
-  return vscode.workspace.getConfiguration('mlir', workspaceFolder).get<T>(key);
+                       workspaceFolder: vscode.WorkspaceFolder = null,
+                       defaultValue: T = undefined): T {
+  return vscode.workspace.getConfiguration('mlir', workspaceFolder)
+      .get<T>(key, defaultValue);
 }
 
 /**
  *  Sets the config value `mlir.<key>`.
  */
 export function update<T>(key: string, value: T,
                           target?: vscode.ConfigurationTarget) {
   return vscode.workspace.getConfiguration('mlir').update(key, value, target);
 }

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.
+   *  Prepare a compilation database option for a server.
    */
-  async preparePDLLServerOptions(workspaceFolder: vscode.WorkspaceFolder,
-                                 configsToWatch: string[],
-                                 pathsToWatch: string[],
-                                 additionalServerArgs: string[]) {
+  async prepareCompilationDatabaseServerOptions(
+      languageName: string, workspaceFolder: vscode.WorkspaceFolder,
+      configsToWatch: string[], pathsToWatch: string[],
     // Process the compilation databases attached for the workspace folder.
-    let databases =
-        config.get<string[]>('pdll_compilation_databases', workspaceFolder);
+    let databases = config.get<string[]>(
+        `${languageName}_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');
+                       `/build/${languageName}_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');
+    configsToWatch.push(`${languageName}_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}`));
+        (database) => `--${languageName}-compilation-database=${database}`));
+  }
+
+  /**
+   *  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[]) {
+    await this.prepareCompilationDatabaseServerOptions(
+        'pdll', workspaceFolder, configsToWatch, pathsToWatch,
+        additionalServerArgs);
+  }
+
+  /**
+   *  Prepare the server options for a TableGen server, e.g. populating any
+   *  accessible compilation databases.
+   */
+  async prepareTableGenServerOptions(workspaceFolder: vscode.WorkspaceFolder,
+                                     configsToWatch: string[],
+                                     pathsToWatch: string[],
+                                     additionalServerArgs: string[]) {
+    await this.prepareCompilationDatabaseServerOptions(
+        'tablegen', workspaceFolder, configsToWatch, pathsToWatch,
+        additionalServerArgs);
   }
 
   /**
    *  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);
+    } else if (languageName == 'tablegen') {
+      await this.prepareTableGenServerOptions(workspaceFolder, configsToWatch,
+                                              filepathsToWatch,
+                                              additionalServerArgs);
     }
 
     // Try to activate the language client.
     const [server, serverPath] = await this.startLanguageClient(
         workspaceFolder, outputChannel, serverSettingName, languageName,
         additionalServerArgs);
     configsToWatch.push(serverSettingName);
     filepathsToWatch.push(serverPath);