[mlir][Tablegen-LSP] Add support for a tracking definitions and references

[rriddle]

Summary

This essentially builds an index for the parsed records and record values (fields).
This covers quite a few cases, but is limited by the currently lackluster location
tracking in tablegen. A followup will work on plumbing more locations through
tablegen, which should greatly improve what we can do here.

[jpienaar]

A followup will work on plumbing more locations through

tablegen, which should greatly improve what we can do here.

Ooooooh, will be nice for refactoring tools too :)

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

178

Could you add comments here? (the previous one was where the location was empty or not tracked, this overlap I'm not sure where it is used and also seems to be discarding every instance except first seen and not sure why that's good)

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

struct LSPServer {
 
   //===--------------------------------------------------------------------===//
   // Document Change
 
   void onDocumentDidOpen(const DidOpenTextDocumentParams &params);
   void onDocumentDidClose(const DidCloseTextDocumentParams &params);
   void onDocumentDidChange(const DidChangeTextDocumentParams &params);
 
+  //===--------------------------------------------------------------------===//
+  // Definitions and References
+
+  void onGoToDefinition(const TextDocumentPositionParams &params,
+                        Callback<std::vector<Location>> reply);
+  void onReference(const ReferenceParams &params,
+                   Callback<std::vector<Location>> reply);
+
   //===----------------------------------------------------------------------===//
   // DocumentLink
 
   void onDocumentLink(const DocumentLinkParams &params,
                       Callback<std::vector<DocumentLink>> reply);
 
   //===--------------------------------------------------------------------===//
   // Hover
void LSPServer::onInitialize(const InitializeParams &params,
   // Send a response with the capabilities of this server.
   llvm::json::Object serverCaps{
       {"textDocumentSync",
        llvm::json::Object{
            {"openClose", true},
            {"change", (int)TextDocumentSyncKind::Full},
            {"save", true},
        }},
+      {"definitionProvider", true},
+      {"referencesProvider", true},
       {"documentLinkProvider",
        llvm::json::Object{
            {"resolveProvider", false},
        }},
       {"hoverProvider", true},
   };
 
   llvm::json::Object result{
server.addOrUpdateDocument(
       params.textDocument.uri, params.contentChanges.front().text,
       params.textDocument.version, diagParams.diagnostics);
 
   // Publish any recorded diagnostics.
   publishDiagnostics(diagParams);
 }
 
 //===----------------------------------------------------------------------===//
+// Definitions and References
+
+void LSPServer::onGoToDefinition(const TextDocumentPositionParams &params,
+                                 Callback<std::vector<Location>> reply) {
+  std::vector<Location> locations;
+  server.getLocationsOf(params.textDocument.uri, params.position, locations);
+  reply(std::move(locations));
+}
+
+void LSPServer::onReference(const ReferenceParams &params,
+                            Callback<std::vector<Location>> reply) {
+  std::vector<Location> locations;
+  server.findReferencesOf(params.textDocument.uri, params.position, locations);
+  reply(std::move(locations));
+}
+
+//===----------------------------------------------------------------------===//
 // DocumentLink
 
 void LSPServer::onDocumentLink(const DocumentLinkParams &params,
                                Callback<std::vector<DocumentLink>> reply) {
   std::vector<DocumentLink> links;
   server.getDocumentLinks(params.textDocument.uri, links);
   reply(std::move(links));
 }
LogicalResult mlir::lsp::runTableGenLSPServer(TableGenServer &server,
   // Document Changes
   messageHandler.notification("textDocument/didOpen", &lspServer,
                               &LSPServer::onDocumentDidOpen);
   messageHandler.notification("textDocument/didClose", &lspServer,
                               &LSPServer::onDocumentDidClose);
   messageHandler.notification("textDocument/didChange", &lspServer,
                               &LSPServer::onDocumentDidChange);
 
+  // Definitions and References
+  messageHandler.method("textDocument/definition", &lspServer,
+                        &LSPServer::onGoToDefinition);
+  messageHandler.method("textDocument/references", &lspServer,
+                        &LSPServer::onReference);
+
   // Document Link
   messageHandler.method("textDocument/documentLink", &lspServer,
                         &LSPServer::onDocumentLink);
 
   // Hover
   messageHandler.method("textDocument/hover", &lspServer, &LSPServer::onHover);
 
   // Diagnostics

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

 #include <memory>
 #include <string>
 
 namespace mlir {
 namespace lsp {
 struct Diagnostic;
 struct DocumentLink;
 struct Hover;
+struct Location;
 struct Position;
 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:
void addOrUpdateDocument(const URIForFile &uri, StringRef contents,
                            int64_t version,
                            std::vector<Diagnostic> &diagnostics);
 
   /// Remove the document with the given uri. Returns the version of the removed
   /// document, or None if the uri did not have a corresponding document within
   /// the server.
   Optional<int64_t> removeDocument(const URIForFile &uri);
 
+  /// Return the locations of the object pointed at by the given position.
+  void getLocationsOf(const URIForFile &uri, const Position &defPos,
+                      std::vector<Location> &locations);
+
+  /// Find all references of the object pointed at by the given position.
+  void findReferencesOf(const URIForFile &uri, const Position &pos,
+                        std::vector<Location> &references);
+
   /// Return the document links referenced by the given file.
   void getDocumentLinks(const URIForFile &uri,
                         std::vector<DocumentLink> &documentLinks);
 
   /// Find a hover description for the given hover position, or None if one
   /// couldn't be found.
   Optional<Hover> findHover(const URIForFile &uri, const Position &hoverPos);
 

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/PointerUnion.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/TableGen/Parser.h"
 #include "llvm/TableGen/Record.h"
 
static lsp::URIForFile getURIFromLoc(const llvm::SourceMgr &mgr, SMLoc loc,
   if (fileForLoc)
     return *fileForLoc;
   lsp::Logger::error("Failed to create URI for include file: {0}",
                      llvm::toString(fileForLoc.takeError()));
   return mainFileURI;
 }
 
 /// Returns a language server location from the given source range.
+static lsp::Location getLocationFromLoc(llvm::SourceMgr &mgr, SMRange loc,
+                                        const lsp::URIForFile &uri) {
+  return lsp::Location(getURIFromLoc(mgr, loc.Start, uri),
+                       lsp::Range(mgr, loc));
+}
 static lsp::Location getLocationFromLoc(llvm::SourceMgr &mgr, SMLoc loc,
                                         const lsp::URIForFile &uri) {
-  return lsp::Location(getURIFromLoc(mgr, loc, uri),
-                       lsp::Range(mgr, lsp::convertTokenLocToRange(loc)));
+  return getLocationFromLoc(mgr, lsp::convertTokenLocToRange(loc), uri);
 }
 
 /// Convert the given TableGen diagnostic to the LSP form.
 static Optional<lsp::Diagnostic>
 getLspDiagnoticFromDiag(const llvm::SMDiagnostic &diag,
                         const lsp::URIForFile &uri) {
   auto *sourceMgr = const_cast<llvm::SourceMgr *>(diag.getSourceMgr());
   if (!sourceMgr || !diag.getLoc().isValid())
case llvm::SourceMgr::DK_Remark:
     break;
   }
   lspDiag.message = diag.getMessage().str();
 
   return lspDiag;
 }
 
 //===----------------------------------------------------------------------===//
+// TableGenIndex
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// This class represents a single symbol definition within a TableGen index. It
+/// contains the definition of the symbol, the location of the symbol, and any
+/// recorded references.
+struct TableGenIndexSymbol {
+  TableGenIndexSymbol(const llvm::Record *record)
+      : definition(record),
+        defLoc(lsp::convertTokenLocToRange(record->getLoc().front())) {}
+  TableGenIndexSymbol(const llvm::RecordVal *value)
+      : definition(value),
+        defLoc(lsp::convertTokenLocToRange(value->getLoc())) {}
+
+  /// The main definition of the symbol.
+  PointerUnion<const llvm::Record *, const llvm::RecordVal *> definition;
+
+  /// The source location of the definition.
+  SMRange defLoc;
+
+  /// The source location of the references of the definition.
+  SmallVector<SMRange> references;
+};
+
+/// This class provides an index for definitions/uses within a TableGen
+/// document. It provides efficient lookup of a definition given an input source
+/// range.
+class TableGenIndex {
+public:
+  TableGenIndex() : intervalMap(allocator) {}
+
+  /// Initialize the index with the given RecordKeeper.
+  void initialize(const llvm::RecordKeeper &records);
+
+  /// Lookup a symbol for the given location. Returns nullptr if no symbol could
+  /// be found. If provided, `overlappedRange` is set to the range that the
+  /// provided `loc` overlapped with.
+  const TableGenIndexSymbol *lookup(SMLoc loc,
+                                    SMRange *overlappedRange = nullptr) const;
+
+private:
+  /// The type of interval map used to store source references. SMRange is
+  /// half-open, so we also need to use a half-open interval map.
+  using MapT = llvm::IntervalMap<
+      const char *, const TableGenIndexSymbol *,
+      llvm::IntervalMapImpl::NodeSizer<const char *,
+                                       const TableGenIndexSymbol *>::LeafSize,
+      llvm::IntervalMapHalfOpenInfo<const char *>>;
+
+  /// An allocator for the interval map.
+  MapT::Allocator allocator;
+
+  /// An interval map containing a corresponding definition mapped to a source
+  /// interval.
+  MapT intervalMap;
+
+  /// A mapping between definitions and their corresponding symbol.
+  DenseMap<const void *, std::unique_ptr<TableGenIndexSymbol>> defToSymbol;
+};
+} // namespace
+
+void TableGenIndex::initialize(const llvm::RecordKeeper &records) {
+  auto getOrInsertDef = [&](const auto *def) -> TableGenIndexSymbol * {
+    auto it = defToSymbol.try_emplace(def, nullptr);
+    if (it.second)
+      it.first->second = std::make_unique<TableGenIndexSymbol>(def);
+    return &*it.first->second;
+  };
+  auto insertRef = [&](TableGenIndexSymbol *sym, SMRange refLoc,
+                       bool isDef = false) {
+    const char *startLoc = refLoc.Start.getPointer();
+    const char *endLoc = refLoc.End.getPointer();
+
+    // If the location we got was empty, try to lex a token from the start
+    // location.
+    if (startLoc == endLoc) {
+      refLoc = lsp::convertTokenLocToRange(SMLoc::getFromPointer(startLoc));
+      startLoc = refLoc.Start.getPointer();
+      endLoc = refLoc.End.getPointer();
+
+      // If the location is still empty, bail on trying to use this reference
+      // location.
+      if (startLoc == endLoc)
+        return;
+    }
+
+    // Check to see if a symbol is already attached to this location.
+    // IntervalMap doesn't allow overlapping inserts, and we don't really
+    // want multiple symbols attached to a source location anyways. This
+    // shouldn't really happen in practice, but we should handle it gracefully.
+    if (!intervalMap.overlaps(startLoc, endLoc))
+      intervalMap.insert(startLoc, endLoc, sym);
+
+    if (!isDef)
+      sym->references.push_back(refLoc);
+  };
+  auto classes =
+      llvm::make_pointee_range(llvm::make_second_range(records.getClasses()));
+  auto defs =
+      llvm::make_pointee_range(llvm::make_second_range(records.getDefs()));
+  for (const llvm::Record &def : llvm::concat<llvm::Record>(classes, defs)) {
+    auto *sym = getOrInsertDef(&def);
+    insertRef(sym, sym->defLoc, /*isDef=*/true);
+
+    // Add references to the definition.
+    for (SMLoc loc : def.getLoc().drop_front())
+      insertRef(sym, lsp::convertTokenLocToRange(loc));
+
+    // Add references to any super classes.
+    for (auto &it : def.getSuperClasses())
+      insertRef(getOrInsertDef(it.first),
+                lsp::convertTokenLocToRange(it.second.Start));
+
+    // Add definitions for any values.
+    for (const llvm::RecordVal &value : def.getValues()) {
+      auto *sym = getOrInsertDef(&value);
+      insertRef(sym, sym->defLoc, /*isDef=*/true);
+    }
+  }
+}
+
+const TableGenIndexSymbol *
+TableGenIndex::lookup(SMLoc loc, SMRange *overlappedRange) const {
+  auto it = intervalMap.find(loc.getPointer());
+  if (!it.valid() || loc.getPointer() < it.start())
+    return nullptr;
+
+  if (overlappedRange) {
+    *overlappedRange = SMRange(SMLoc::getFromPointer(it.start()),
+                               SMLoc::getFromPointer(it.stop()));
+  }
+  return it.value();
+}
+
+//===----------------------------------------------------------------------===//
 // 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,
                    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; }
 
   //===--------------------------------------------------------------------===//
+  // Definitions and References
+  //===--------------------------------------------------------------------===//
+
+  void getLocationsOf(const lsp::URIForFile &uri, const lsp::Position &defPos,
+                      std::vector<lsp::Location> &locations);
+  void findReferencesOf(const lsp::URIForFile &uri, const lsp::Position &pos,
+                        std::vector<lsp::Location> &references);
+
+  //===--------------------------------------------------------------------===//
   // Document Links
   //===--------------------------------------------------------------------===//
 
   void getDocumentLinks(const lsp::URIForFile &uri,
                         std::vector<lsp::DocumentLink> &links);
 
   //===--------------------------------------------------------------------===//
   // Hover
private:
   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;
 
+  /// The index of the parsed file.
+  TableGenIndex index;
+
   /// The set of includes of the parsed file.
   SmallVector<lsp::SourceMgrInclude> parsedIncludes;
 };
 } // namespace
 
 TableGenTextFile::TableGenTextFile(
     const lsp::URIForFile &uri, StringRef fileContents, int64_t version,
     const std::vector<std::string> &extraIncludeDirs,
sourceMgr.setDiagHandler(
       },
       &handlerContext);
   bool failedToParse = llvm::TableGenParseFile(sourceMgr, recordKeeper);
 
   // Process all of the include files.
   lsp::gatherIncludeFiles(sourceMgr, parsedIncludes);
   if (failedToParse)
     return;
+
+  // If we successfully parsed the file, we can now build the index.
+  index.initialize(recordKeeper);
+}
+
+//===----------------------------------------------------------------------===//
+// TableGenTextFile: Definitions and References
+//===----------------------------------------------------------------------===//
+
+void TableGenTextFile::getLocationsOf(const lsp::URIForFile &uri,
+                                      const lsp::Position &defPos,
+                                      std::vector<lsp::Location> &locations) {
+  SMLoc posLoc = defPos.getAsSMLoc(sourceMgr);
+  const TableGenIndexSymbol *symbol = index.lookup(posLoc);
+  if (!symbol)
+    return;
+
+  locations.push_back(getLocationFromLoc(sourceMgr, symbol->defLoc, uri));
+}
+
+void TableGenTextFile::findReferencesOf(
+    const lsp::URIForFile &uri, const lsp::Position &pos,
+    std::vector<lsp::Location> &references) {
+  SMLoc posLoc = pos.getAsSMLoc(sourceMgr);
+  const TableGenIndexSymbol *symbol = index.lookup(posLoc);
+  if (!symbol)
+    return;
+
+  references.push_back(getLocationFromLoc(sourceMgr, symbol->defLoc, uri));
+  for (SMRange refLoc : symbol->references)
+    references.push_back(getLocationFromLoc(sourceMgr, refLoc, uri));
 }
 
 //===--------------------------------------------------------------------===//
 // TableGenTextFile: Document Links
 //===--------------------------------------------------------------------===//
 
 void TableGenTextFile::getDocumentLinks(const lsp::URIForFile &uri,
                                         std::vector<lsp::DocumentLink> &links) {
Optional<int64_t> lsp::TableGenServer::removeDocument(const URIForFile &uri) {
   if (it == impl->files.end())
     return llvm::None;
 
   int64_t version = it->second->getVersion();
   impl->files.erase(it);
   return version;
 }
 
+void lsp::TableGenServer::getLocationsOf(const URIForFile &uri,
+                                         const Position &defPos,
+                                         std::vector<Location> &locations) {
+  auto fileIt = impl->files.find(uri.file());
+  if (fileIt != impl->files.end())
+    fileIt->second->getLocationsOf(uri, defPos, locations);
+}
+
+void lsp::TableGenServer::findReferencesOf(const URIForFile &uri,
+                                           const Position &pos,
+                                           std::vector<Location> &references) {
+  auto fileIt = impl->files.find(uri.file());
+  if (fileIt != impl->files.end())
+    fileIt->second->findReferencesOf(uri, pos, references);
+}
+
 void lsp::TableGenServer::getDocumentLinks(
     const URIForFile &uri, std::vector<DocumentLink> &documentLinks) {
   auto fileIt = impl->files.find(uri.file());
   if (fileIt != impl->files.end())
     return fileIt->second->getDocumentLinks(uri, documentLinks);
 }
 
 Optional<lsp::Hover> lsp::TableGenServer::findHover(const URIForFile &uri,
                                                     const Position &hoverPos) {
   auto fileIt = impl->files.find(uri.file());
   if (fileIt != impl->files.end())
     return fileIt->second->findHover(uri, hoverPos);
   return llvm::None;
 }

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

+// RUN: tblgen-lsp-server -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":"class Foo {\n  int field1 = ?;\n}\ndef FooDerived : Foo {\n  let field1 = 10;\n }\n"
+}}}
+// -----
+{"jsonrpc":"2.0","id":1,"method":"textDocument/definition","params":{
+  "textDocument":{"uri":"test:///foo.td"},
+  "position":{"line":3,"character":19}
+}}
+//      CHECK:  "id": 1
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": [
+// CHECK-NEXT:    {
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:        "end": {
+// CHECK-NEXT:          "character": 9,
+// CHECK-NEXT:          "line": 0
+// CHECK-NEXT:        },
+// CHECK-NEXT:        "start": {
+// CHECK-NEXT:          "character": 6,
+// CHECK-NEXT:          "line": 0
+// CHECK-NEXT:        }
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "uri": "{{.*}}/foo.td"
+// CHECK-NEXT:    }
+// -----
+{"jsonrpc":"2.0","id":2,"method":"textDocument/definition","params":{
+  "textDocument":{"uri":"test:///foo.td"},
+  "position":{"line":4,"character":9}
+}}
+//      CHECK:  "id": 2
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": [
+// CHECK-NEXT:    {
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:        "end": {
+// CHECK-NEXT:          "character": 12,
+// CHECK-NEXT:          "line": 4
+// CHECK-NEXT:        },
+// CHECK-NEXT:        "start": {
+// CHECK-NEXT:          "character": 6,
+// CHECK-NEXT:          "line": 4
+// CHECK-NEXT:        }
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "uri": "{{.*}}/foo.td"
+// CHECK-NEXT:    }
+// -----
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}
+// -----
+{"jsonrpc":"2.0","method":"exit"}

mlir/test/tblgen-lsp-server/initialize-params.test

 // RUN: tblgen-lsp-server -lit-test < %s | FileCheck %s
 // Test initialize request parameters with rootUri
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootUri":"test:///workspace","capabilities":{},"trace":"off"}}
 //      CHECK:  "id": 0,
 // CHECK-NEXT:  "jsonrpc": "2.0",
 // CHECK-NEXT:  "result": {
 // CHECK-NEXT:    "capabilities": {
+// CHECK-NEXT:    "definitionProvider": true,
 // CHECK-NEXT:    "documentLinkProvider": {
 // CHECK-NEXT:      "resolveProvider": false
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "hoverProvider": true,
-// CHECK-NEXT:      "textDocumentSync": {
+// CHECK-NEXT:    "referencesProvider": true,
+// CHECK-NEXT:    "textDocumentSync": {
 // CHECK-NEXT:        "change": 1,
 // CHECK-NEXT:        "openClose": true,
 // CHECK-NEXT:        "save": true
 // CHECK-NEXT:      }
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "serverInfo": {
 // CHECK-NEXT:      "name": "tblgen-lsp-server",
 // CHECK-NEXT:      "version": "{{.*}}"

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

+// RUN: tblgen-lsp-server -lit-test < %s | FileCheck -strict-whitespace %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":"class Foo;\ndef FooDerived : Foo;\n"
+}}}
+// -----
+{"jsonrpc":"2.0","id":1,"method":"textDocument/references","params":{
+  "textDocument":{"uri":"test:///foo.td"},
+  "position":{"line":0,"character":7},
+  "context":{"includeDeclaration": false}
+}}
+//      CHECK:  "id": 1
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": [
+// CHECK-NEXT:    {
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:        "end": {
+// CHECK-NEXT:          "character": 9,
+// CHECK-NEXT:          "line": 0
+// CHECK-NEXT:        },
+// CHECK-NEXT:        "start": {
+// CHECK-NEXT:          "character": 6,
+// CHECK-NEXT:          "line": 0
+// CHECK-NEXT:        }
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "uri": "{{.*}}/foo.td"
+// CHECK-NEXT:    },
+// CHECK-NEXT:    {
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:        "end": {
+// CHECK-NEXT:          "character": 20,
+// CHECK-NEXT:          "line": 1
+// CHECK-NEXT:        },
+// CHECK-NEXT:        "start": {
+// CHECK-NEXT:          "character": 17,
+// CHECK-NEXT:          "line": 1
+// CHECK-NEXT:        }
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "uri": "{{.*}}/foo.td"
+// CHECK-NEXT:    }
+// CHECK-NEXT:  ]
+// -----
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}
+// -----
+{"jsonrpc":"2.0","method":"exit"}