[mlir] Add hover support to mlir-lsp-server

[rriddle]

Summary

This provides information when the user hovers over a part of the source .mlir file. This revision adds the following hover behavior:

• Operation:
  • Shows the generic form.
• Operation Result:
  • Shows the parent operation name, result number(s), and type(s).
• Block:
  • Shows the parent operation name, block number, predecessors, and successors.
• Block Argument:
  • Shows the parent operation name, parent block, argument number, and type.

[rriddle]

rebase

[jpienaar]

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

127

Comment?

382

What happens in the case where we have ops with huge attributes? Should we do something similar to in the graphviz emitter and truncate?

[rriddle]

update

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

382

Added elision for element attributes, but we should probably look into adding an option that combines all of the desired printing flags into one. That way we can make it easier to log operations without needing to remember which flags you have to set to not destroy your terminal.

mlir/include/mlir/Parser/AsmParserState.h

public:
   using BlockDefIterator = llvm::pointee_iterator<
       ArrayRef<std::unique_ptr<BlockDefinition>>::iterator>;
   using OperationDefIterator = llvm::pointee_iterator<
       ArrayRef<std::unique_ptr<OperationDefinition>>::iterator>;
 
   /// Return a range of the BlockDefinitions held by the current parser state.
   iterator_range<BlockDefIterator> getBlockDefs() const;
 
+  /// Return the definition for the given block, or nullptr if the given
+  /// block does not have a definition.
+  const BlockDefinition *getBlockDef(Block *block) const;
+
   /// Return a range of the OperationDefinitions held by the current parser
   /// state.
   iterator_range<OperationDefIterator> getOpDefs() const;
 
   //===--------------------------------------------------------------------===//
   // Populate State
   //===--------------------------------------------------------------------===//
 

mlir/lib/Parser/AsmParserState.cpp

 
 //===----------------------------------------------------------------------===//
 // Access State
 
 auto AsmParserState::getBlockDefs() const -> iterator_range<BlockDefIterator> {
   return llvm::make_pointee_range(llvm::makeArrayRef(impl->blocks));
 }
 
+auto AsmParserState::getBlockDef(Block *block) const
+    -> const BlockDefinition * {
+  auto it = impl->blocksToIdx.find(block);
+  return it == impl->blocksToIdx.end() ? nullptr : &*impl->blocks[it->second];
+}
+
 auto AsmParserState::getOpDefs() const -> iterator_range<OperationDefIterator> {
   return llvm::make_pointee_range(llvm::makeArrayRef(impl->operations));
 }
 
 //===----------------------------------------------------------------------===//
 // Populate State
 
 void AsmParserState::addDefinition(

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

struct LSPServer::Impl {
   //===--------------------------------------------------------------------===//
   // Definitions and References
 
   void onGoToDefinition(const TextDocumentPositionParams &params,
                         Callback<std::vector<Location>> reply);
   void onReference(const ReferenceParams &params,
                    Callback<std::vector<Location>> reply);
 
+  //===--------------------------------------------------------------------===//
+  // Hover
+
+  void onHover(const TextDocumentPositionParams &params,
+               Callback<Optional<Hover>> reply);
+
   MLIRServer &server;
   JSONTransport &transport;
 
   /// Used to indicate that the 'shutdown' request was received from the
   /// Language Server client.
   bool shutdownRequestReceived = false;
 };
 
 //===----------------------------------------------------------------------===//
 // Initialization
 
 void LSPServer::Impl::onInitialize(const InitializeParams &params,
                                    Callback<llvm::json::Value> reply) {
   llvm::json::Object serverCaps{
       {"textDocumentSync",
        llvm::json::Object{
            {"openClose", true},
            {"change", (int)TextDocumentSyncKind::Full},
            {"save", true},
        }},
       {"definitionProvider", true},
       {"referencesProvider", true},
+      {"hoverProvider", true},
   };
 
   llvm::json::Object result{
       {{"serverInfo",
         llvm::json::Object{{"name", "mlir-lsp-server"}, {"version", "0.0.0"}}},
        {"capabilities", std::move(serverCaps)}}};
   reply(std::move(result));
 }

 void LSPServer::Impl::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));
 }
 
 //===----------------------------------------------------------------------===//
+// Hover
+
+void LSPServer::Impl::onHover(const TextDocumentPositionParams &params,
+                              Callback<Optional<Hover>> reply) {
+  reply(server.findHover(params.textDocument.uri, params.position));
+}
+
+//===----------------------------------------------------------------------===//
 // LSPServer
 //===----------------------------------------------------------------------===//
 
 LSPServer::LSPServer(MLIRServer &server, JSONTransport &transport)
     : impl(std::make_unique<Impl>(server, transport)) {}
 LSPServer::~LSPServer() {}
 
 LogicalResult LSPServer::run() {
messageHandler.notification("textDocument/didChange", impl.get(),
                               &Impl::onDocumentDidChange);
 
   // Definitions and References
   messageHandler.method("textDocument/definition", impl.get(),
                         &Impl::onGoToDefinition);
   messageHandler.method("textDocument/references", impl.get(),
                         &Impl::onReference);
 
+  // Hover
+  messageHandler.method("textDocument/hover", impl.get(), &Impl::onHover);
+
+  // Run the main loop of the transport.
   LogicalResult result = success();
   if (llvm::Error error = impl->transport.run(messageHandler)) {
     Logger::error("Transport error: {0}", error);
     llvm::consumeError(std::move(error));
     result = failure();
   } else {
     result = success(impl->shutdownRequestReceived);
   }
   return result;
 }

mlir/lib/Tools/mlir-lsp-server/MLIRServer.h

 
 #include "mlir/Support/LLVM.h"
 #include <memory>
 
 namespace mlir {
 class DialectRegistry;
 
 namespace lsp {
+struct Hover;
 struct Location;
 struct Position;
 class URIForFile;
 
 /// This class implements all of the MLIR related functionality necessary for a
 /// language server. This class allows for keeping the MLIR specific logic
 /// separate from the logic that involves LSP server/client communication.
 class MLIRServer {
public:
   /// 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);
 
+  /// 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);
+
 private:
   struct Impl;
 
   std::unique_ptr<Impl> impl;
 };
 
 } // namespace lsp
 } // namespace mlir
 
 #endif // LIB_MLIR_TOOLS_MLIRLSPSERVER_SERVER_H_

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

 /// that this has slightly different behavior than SMRange because it is
 /// inclusive of the end location.
 static bool contains(llvm::SMRange range, llvm::SMLoc loc) {
   return range.Start.getPointer() <= loc.getPointer() &&
          loc.getPointer() <= range.End.getPointer();
 }
 
 /// Returns true if the given location is contained by the definition or one of
-/// the uses of the given SMDefinition.
-static bool isDefOrUse(const AsmParserState::SMDefinition &def,
-                       llvm::SMLoc loc) {
-  auto isUseFn = [&](const llvm::SMRange &range) {
+/// the uses of the given SMDefinition. If provided, `overlappedRange` is set to
+/// the range within `def` that the provided `loc` overlapped with.
+static bool isDefOrUse(const AsmParserState::SMDefinition &def, llvm::SMLoc loc,
+                       llvm::SMRange *overlappedRange = nullptr) {
+  // Check the main definition.
+  if (contains(def.loc, loc)) {
+    if (overlappedRange)
+      *overlappedRange = def.loc;
+    return true;
+  }
+
+  // Check the uses.
+  auto useIt = llvm::find_if(def.uses, [&](const llvm::SMRange &range) {
     return contains(range, loc);
+  });
+  if (useIt != def.uses.end()) {
+    if (overlappedRange)
+      *overlappedRange = *useIt;
+    return true;
+  }
+  return false;
+}
+
+/// Given a location pointing to a result, return the result number it refers
+/// to or None if it refers to all of the results.
+static Optional<unsigned> getResultNumberFromLoc(llvm::SMLoc loc) {
+  // Skip all of the identifier characters.
+  auto isIdentifierChar = [](char c) {
+    return isalnum(c) || c == '%' || c == '$' || c == '.' || c == '_' ||
+           c == '-';
   };
-  return contains(def.loc, loc) || llvm::any_of(def.uses, isUseFn);
+  const char *curPtr = loc.getPointer();
+  while (isIdentifierChar(*curPtr))
+    ++curPtr;
+  if (*curPtr != '#')
+    return llvm::None;
+
+  // Compute the number from the string.
+  const char *numberStart = ++curPtr;
+  while (llvm::isDigit(*curPtr))
+    ++curPtr;
+  StringRef numberStr(numberStart, curPtr - numberStart);
+  unsigned resultNumber = 0;
+  return numberStr.consumeInteger(10, resultNumber) ? Optional<unsigned>()
+                                                    : resultNumber;
+}
+
+/// Given a source location range, return the text covered by the given range.
+/// If the range is invalid, returns None.
+static Optional<StringRef> getTextFromRange(llvm::SMRange range) {
+  if (!range.isValid())
+    return None;
+  const char *startPtr = range.Start.getPointer();
+  return StringRef(startPtr, range.End.getPointer() - startPtr);
+}
+
+/// Given a block, return its position in its parent region.
+static unsigned getBlockNumber(Block *block) {
+  return std::distance(block->getParent()->begin(), block->getIterator());
+}
+
+/// Given a block and source location, print the source name of the block to the
+/// given output stream.
+static void printDefBlockName(raw_ostream &os, Block *block,
+                              llvm::SMRange loc = {}) {
+  // Try to extract a name from the source location.
+  Optional<StringRef> text = getTextFromRange(loc);
+  if (text && text->startswith("^")) {
+    os << *text;
+    return;
+  }
+
+  // Otherwise, we don't have a name so print the block number.
+  os << "<Block #" << getBlockNumber(block) << ">";
+}
+static void printDefBlockName(raw_ostream &os,
+                              const AsmParserState::BlockDefinition &def) {
+  printDefBlockName(os, def.block, def.definition.loc);
 }
 
 //===----------------------------------------------------------------------===//
 // MLIRDocument
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class represents all of the information pertaining to a specific MLIR
 /// document.
 struct MLIRDocument {
   MLIRDocument(const lsp::URIForFile &uri, StringRef contents,
                DialectRegistry &registry);
 
+  //===--------------------------------------------------------------------===//
+  // 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);
 
+  //===--------------------------------------------------------------------===//
+  // Hover
+  //===--------------------------------------------------------------------===//
+
+  Optional<lsp::Hover> findHover(const lsp::URIForFile &uri,
+                                 const lsp::Position &hoverPos);
+  Optional<lsp::Hover>
+  buildHoverForOperation(const AsmParserState::OperationDefinition &op);
+  lsp::Hover buildHoverForOperationResult(llvm::SMRange hoverRange,
+                                          Operation *op, unsigned resultStart,
+                                          unsigned resultEnd,
+                                          llvm::SMLoc posLoc);
+  lsp::Hover buildHoverForBlock(llvm::SMRange hoverRange,
+                                const AsmParserState::BlockDefinition &block);
+  lsp::Hover
+  buildHoverForBlockArgument(llvm::SMRange hoverRange, BlockArgument arg,
+                             const AsmParserState::BlockDefinition &block);
+
   /// The context used to hold the state contained by the parsed document.
   MLIRContext context;
 
   /// The high level parser state used to find definitions and references within
   /// the source file.
   AsmParserState asmState;
 
   /// The container for the IR parsed from the input file.
MLIRDocument::MLIRDocument(const lsp::URIForFile &uri, StringRef contents,
   }
 
   sourceMgr.AddNewSourceBuffer(std::move(memBuffer), llvm::SMLoc());
   if (failed(
           parseSourceFile(sourceMgr, &parsedIR, &context, nullptr, &asmState)))
     return;
 }
 
+//===----------------------------------------------------------------------===//
+// MLIRDocument: Definitions and References
+//===----------------------------------------------------------------------===//
+
 void MLIRDocument::getLocationsOf(const lsp::URIForFile &uri,
                                   const lsp::Position &defPos,
                                   std::vector<lsp::Location> &locations) {
   llvm::SMLoc posLoc = getPosFromLoc(sourceMgr, defPos);
 
   // Functor used to check if an SM definition contains the position.
   auto containsPosition = [&](const AsmParserState::SMDefinition &def) {
     if (!isDefOrUse(def, posLoc))
for (const AsmParserState::BlockDefinition &block : asmState.getBlockDefs()) {
 
     for (const AsmParserState::SMDefinition &arg : block.arguments)
       if (isDefOrUse(arg, posLoc))
         return appendSMDef(arg);
   }
 }
 
 //===----------------------------------------------------------------------===//
+// MLIRDocument: Hover
+//===----------------------------------------------------------------------===//
+
+Optional<lsp::Hover> MLIRDocument::findHover(const lsp::URIForFile &uri,
+                                             const lsp::Position &hoverPos) {
+  llvm::SMLoc posLoc = getPosFromLoc(sourceMgr, hoverPos);
+  llvm::SMRange hoverRange;
+
+  // Check for Hovers on operations and results.
+  for (const AsmParserState::OperationDefinition &op : asmState.getOpDefs()) {
+    // Check if the position points at this operation.
+    if (contains(op.loc, posLoc))
+      return buildHoverForOperation(op);
+
+    // Check if the position points at a result group.
+    for (unsigned i = 0, e = op.resultGroups.size(); i < e; ++i) {
+      const auto &result = op.resultGroups[i];
+      if (!isDefOrUse(result.second, posLoc, &hoverRange))
+        continue;
+
+      // Get the range of results covered by the over position.
+      unsigned resultStart = result.first;
+      unsigned resultEnd =
+          (i == e - 1) ? op.op->getNumResults() : op.resultGroups[i + 1].first;
+      return buildHoverForOperationResult(hoverRange, op.op, resultStart,
+                                          resultEnd, posLoc);
+    }
+  }
+
+  // Check to see if the hover is over a block argument.
+  for (const AsmParserState::BlockDefinition &block : asmState.getBlockDefs()) {
+    if (isDefOrUse(block.definition, posLoc, &hoverRange))
+      return buildHoverForBlock(hoverRange, block);
+
+    for (const auto &arg : llvm::enumerate(block.arguments)) {
+      if (!isDefOrUse(arg.value(), posLoc, &hoverRange))
+        continue;
+
+      return buildHoverForBlockArgument(
+          hoverRange, block.block->getArgument(arg.index()), block);
+    }
+  }
+  return llvm::None;
+}
+
+Optional<lsp::Hover> MLIRDocument::buildHoverForOperation(
+    const AsmParserState::OperationDefinition &op) {
+  // Don't show hovers for operations with regions to avoid huge hover  blocks.
+  // TODO: Should we add support for printing an op without its regions?
+  if (llvm::any_of(op.op->getRegions(),
+                   [](Region &region) { return !region.empty(); }))
+    return llvm::None;
+
+  lsp::Hover hover(getRangeFromLoc(sourceMgr, op.loc));
+  llvm::raw_string_ostream os(hover.contents.value);
+
+  // For hovers on an operation, show the generic form.
+  os << "```mlir\n";
+  op.op->print(os, OpPrintingFlags().printGenericOpForm());
+  os << "\n```\n";
+
+  return hover;
+}
+
+lsp::Hover MLIRDocument::buildHoverForOperationResult(llvm::SMRange hoverRange,
+                                                      Operation *op,
+                                                      unsigned resultStart,
+                                                      unsigned resultEnd,
+                                                      llvm::SMLoc posLoc) {
+  lsp::Hover hover(getRangeFromLoc(sourceMgr, hoverRange));
+  llvm::raw_string_ostream os(hover.contents.value);
+
+  // Add the parent operation name to the hover.
+  os << "Operation: \"" << op->getName() << "\"\n\n";
+
+  // Check to see if the location points to a specific result within the
+  // group.
+  if (Optional<unsigned> resultNumber = getResultNumberFromLoc(posLoc)) {
+    if ((resultStart + *resultNumber) < resultEnd) {
+      resultStart += *resultNumber;
+      resultEnd = resultStart + 1;
+    }
+  }
+
+  // Add the range of results and their types to the hover info.
+  if ((resultStart + 1) == resultEnd) {
+    os << "Result #" << resultStart << "\n\n"
+       << "Type: `" << op->getResult(resultStart).getType() << "`\n\n";
+  } else {
+    os << "Result #[" << resultStart << ", " << (resultEnd - 1) << "]\n\n"
+       << "Types: ";
+    llvm::interleaveComma(
+        op->getResults().slice(resultStart, resultEnd), os,
+        [&](Value result) { os << "`" << result.getType() << "`"; });
+  }
+
+  return hover;
+}
+
+lsp::Hover
+MLIRDocument::buildHoverForBlock(llvm::SMRange hoverRange,
+                                 const AsmParserState::BlockDefinition &block) {
+  lsp::Hover hover(getRangeFromLoc(sourceMgr, hoverRange));
+  llvm::raw_string_ostream os(hover.contents.value);
+
+  // Print the given block to the hover output stream.
+  auto printBlockToHover = [&](Block *newBlock) {
+    if (const auto *def = asmState.getBlockDef(newBlock))
+      printDefBlockName(os, *def);
+    else
+      printDefBlockName(os, newBlock);
+  };
+
+  // Display the parent operation, block number, predecessors, and successors.
+  os << "Operation: \"" << block.block->getParentOp()->getName() << "\"\n\n"
+     << "Block #" << getBlockNumber(block.block) << "\n\n";
+  if (!block.block->hasNoPredecessors()) {
+    os << "Predecessors: ";
+    llvm::interleaveComma(block.block->getPredecessors(), os,
+                          printBlockToHover);
+    os << "\n\n";
+  }
+  if (!block.block->hasNoSuccessors()) {
+    os << "Successors: ";
+    llvm::interleaveComma(block.block->getSuccessors(), os, printBlockToHover);
+    os << "\n\n";
+  }
+
+  return hover;
+}
+
+lsp::Hover MLIRDocument::buildHoverForBlockArgument(
+    llvm::SMRange hoverRange, BlockArgument arg,
+    const AsmParserState::BlockDefinition &block) {
+  lsp::Hover hover(getRangeFromLoc(sourceMgr, hoverRange));
+  llvm::raw_string_ostream os(hover.contents.value);
+
+  // Display the parent operation, block, the argument number, and the type.
+  os << "Operation: \"" << block.block->getParentOp()->getName() << "\"\n\n"
+     << "Block: ";
+  printDefBlockName(os, block);
+  os << "\n\nArgument #" << arg.getArgNumber() << "\n\n"
+     << "Type: `" << arg.getType() << "`\n\n";
+
+  return hover;
+}
+
+//===----------------------------------------------------------------------===//
 // MLIRServer::Impl
 //===----------------------------------------------------------------------===//
 
 struct lsp::MLIRServer::Impl {
   Impl(DialectRegistry &registry) : registry(registry) {}
 
   /// The registry containing dialects that can be recognized in parsed .mlir
   /// files.

 
 void lsp::MLIRServer::findReferencesOf(const URIForFile &uri,
                                        const Position &pos,
                                        std::vector<Location> &references) {
   auto fileIt = impl->documents.find(uri.file());
   if (fileIt != impl->documents.end())
     fileIt->second->findReferencesOf(uri, pos, references);
 }
+
+Optional<lsp::Hover> lsp::MLIRServer::findHover(const URIForFile &uri,
+                                                const Position &hoverPos) {
+  auto fileIt = impl->documents.find(uri.file());
+  if (fileIt != impl->documents.end())
+    return fileIt->second->findHover(uri, hoverPos);
+  return llvm::None;
+}

mlir/lib/Tools/mlir-lsp-server/lsp/Protocol.h

struct DidChangeTextDocumentParams {
   TextDocumentIdentifier textDocument;
 
   /// The actual content changes.
   std::vector<TextDocumentContentChangeEvent> contentChanges;
 };
 bool fromJSON(const llvm::json::Value &value,
               DidChangeTextDocumentParams &result, llvm::json::Path path);
 
+//===----------------------------------------------------------------------===//
+// MarkupContent
+//===----------------------------------------------------------------------===//
+
+/// Describes the content type that a client supports in various result literals
+/// like `Hover`.
+enum class MarkupKind {
+  PlainText,
+  Markdown,
+};
+bool fromJSON(const llvm::json::Value &value, MarkupKind &result,
+              llvm::json::Path path);
+raw_ostream &operator<<(raw_ostream &os, MarkupKind kind);
+
+struct MarkupContent {
+  MarkupKind kind = MarkupKind::PlainText;
+  std::string value;
+};
+llvm::json::Value toJSON(const MarkupContent &mc);
+
+//===----------------------------------------------------------------------===//
+// Hover
+//===----------------------------------------------------------------------===//
+
+struct Hover {
+  /// Construct a default hover with the given range that uses Markdown content.
+  Hover(Range range) : contents{MarkupKind::Markdown, ""}, range(range) {}
+
+  /// The hover's content.
+  MarkupContent contents;
+
+  /// An optional range is a range inside a text document that is used to
+  /// visualize a hover, e.g. by changing the background color.
+  Optional<Range> range;
+};
+llvm::json::Value toJSON(const Hover &hover);
+
 } // namespace lsp
 } // namespace mlir
 
 namespace llvm {
 template <> struct format_provider<mlir::lsp::Position> {
   static void format(const mlir::lsp::Position &pos, raw_ostream &os,
                      StringRef style) {
     assert(style.empty() && "style modifiers for this type are not supported");
     os << pos;
   }
 };
 } // namespace llvm
 
 #endif

mlir/lib/Tools/mlir-lsp-server/lsp/Protocol.cpp

 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          DidChangeTextDocumentParams &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("textDocument", result.textDocument) &&
          o.map("contentChanges", result.contentChanges);
 }
+
+//===----------------------------------------------------------------------===//
+// MarkupContent
+//===----------------------------------------------------------------------===//
+
+static llvm::StringRef toTextKind(MarkupKind kind) {
+  switch (kind) {
+  case MarkupKind::PlainText:
+    return "plaintext";
+  case MarkupKind::Markdown:
+    return "markdown";
+  }
+  llvm_unreachable("Invalid MarkupKind");
+}
+
+bool fromJSON(const llvm::json::Value &value, MarkupKind &result,
+              llvm::json::Path path) {
+  Optional<StringRef> str = value.getAsString();
+  if (!str) {
+    path.report("expected string");
+    return false;
+  }
+  if (*str == "plaintext")
+    result = MarkupKind::PlainText;
+  else if (*str == "markdown")
+    result = MarkupKind::Markdown;
+  else
+    return path.report("unknown markup kind"), false;
+
+  return true;
+}
+
+raw_ostream &mlir::lsp::operator<<(raw_ostream &os, MarkupKind kind) {
+  return os << toTextKind(kind);
+}
+
+llvm::json::Value mlir::lsp::toJSON(const MarkupContent &mc) {
+  if (mc.value.empty())
+    return nullptr;
+
+  return llvm::json::Object{
+      {"kind", toTextKind(mc.kind)},
+      {"value", mc.value},
+  };
+}
+
+//===----------------------------------------------------------------------===//
+// Hover
+//===----------------------------------------------------------------------===//
+
+llvm::json::Value mlir::lsp::toJSON(const Hover &hover) {
+  llvm::json::Object result{{"contents", toJSON(hover.contents)}};
+  if (hover.range.hasValue())
+    result["range"] = toJSON(*hover.range);
+  return std::move(result);
+}

mlir/test/mlir-lsp-server/hover.test

+// RUN: mlir-lsp-server -lit-test < %s | FileCheck -strict-whitespace %s
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"mlir","capabilities":{},"trace":"off"}}
+// -----
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{
+  "uri":"test:///foo.mlir",
+  "languageId":"mlir",
+  "version":1,
+  "text":"func @foo(%arg: i1) {\n%value = constant true\nbr ^bb2\n^bb2:\nreturn\n}"
+}}}
+// -----
+// Hover on an operation.
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
+  "textDocument":{"uri":"test:///foo.mlir"},
+  "position":{"line":1,"character":12}
+}}
+//      CHECK:  "id": 1,
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": {
+// CHECK-NEXT:    "contents": {
+// CHECK-NEXT:      "kind": "markdown",
+// CHECK-NEXT:      "value": "```mlir\n%true = \"std.constant\"() {value = true} : () -> i1\n```\n"
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:      "end": {
+// CHECK-NEXT:        "character": 17,
+// CHECK-NEXT:        "line": 1
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "start": {
+// CHECK-NEXT:        "character": 10,
+// CHECK-NEXT:        "line": 1
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// -----
+// Hover on an operation result.
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
+  "textDocument":{"uri":"test:///foo.mlir"},
+  "position":{"line":1,"character":2}
+}}
+//      CHECK:  "id": 1,
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": {
+// CHECK-NEXT:    "contents": {
+// CHECK-NEXT:      "kind": "markdown",
+// CHECK-NEXT:      "value": "Operation: \"std.constant\"\n\nResult #0\n\nType: `i1`\n\n"
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:      "end": {
+// CHECK-NEXT:        "character": 6,
+// CHECK-NEXT:        "line": 1
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "start": {
+// CHECK-NEXT:        "character": 1,
+// CHECK-NEXT:        "line": 1
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// -----
+// Hover on a Block.
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
+  "textDocument":{"uri":"test:///foo.mlir"},
+  "position":{"line":3,"character":2}
+}}
+//      CHECK:  "id": 1,
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": {
+// CHECK-NEXT:    "contents": {
+// CHECK-NEXT:      "kind": "markdown",
+// CHECK-NEXT:      "value": "Operation: \"func\"\n\nBlock #1\n\nPredecessors: <Block #0>\n\n"
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:      "end": {
+// CHECK-NEXT:        "character": 4,
+// CHECK-NEXT:        "line": 3
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "start": {
+// CHECK-NEXT:        "character": 1,
+// CHECK-NEXT:        "line": 3
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// -----
+// Hover on a Block argument.
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
+  "textDocument":{"uri":"test:///foo.mlir"},
+  "position":{"line":0,"character":12}
+}}
+//      CHECK:  "id": 1,
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": {
+// CHECK-NEXT:    "contents": {
+// CHECK-NEXT:      "kind": "markdown",
+// CHECK-NEXT:      "value": "Operation: \"func\"\n\nBlock: <Block #0>\n\nArgument #0\n\nType: `i1`\n\n"
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:      "end": {
+// CHECK-NEXT:        "character": 14,
+// CHECK-NEXT:        "line": 0
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "start": {
+// CHECK-NEXT:        "character": 11,
+// CHECK-NEXT:        "line": 0
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// -----
+{"jsonrpc":"2.0","id":3,"method":"shutdown"}
+// -----
+{"jsonrpc":"2.0","method":"exit"}

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

 // RUN: mlir-lsp-server -lit-test < %s | FileCheck -strict-whitespace %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:      "hoverProvider": true,
 // 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": {