[mlir][NFC] Move the LSP agnostic files to a new lsp-server directory

[rriddle]

Summary

This allows for sharing the implementation of key components across multiple
MLIR language servers. These will be used in a followup to help implement
a PDLL language server.

Depends on D119903

mlir/lib/Tools/CMakeLists.txt

+add_subdirectory(lsp-server-support)
 add_subdirectory(mlir-lsp-server)
 add_subdirectory(mlir-opt)
 add_subdirectory(mlir-reduce)
 add_subdirectory(mlir-translate)
 add_subdirectory(PDLL)

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

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

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

 //===- Logging.h - MLIR LSP Server Logging ----------------------*- 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_MLIRLSPSERVER_LSP_LOGGING_H
-#define LIB_MLIR_TOOLS_MLIRLSPSERVER_LSP_LOGGING_H
+#ifndef LIB_MLIR_TOOLS_LSPSERVERSUPPORT_LOGGING_H
+#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_LOGGING_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <memory>
 #include <mutex>
 
 namespace mlir {
 namespace lsp {
 
 /// This class represents the main interface for logging, and allows for
 /// filtering logging based on different levels of severity or significance.
 class Logger {
 public:
   /// The level of significance for a log message.
   enum class Level { Debug, Info, Error };
 
   /// Set the severity level of the logger.
   static void setLogLevel(Level logLevel);
 
   /// Initiate a log message at various severity levels. These should be called
   /// after a call to `initialize`.
-  template <typename... Ts> static void debug(const char *fmt, Ts &&... vals) {
+  template <typename... Ts>
+  static void debug(const char *fmt, Ts &&...vals) {
     log(Level::Debug, fmt, llvm::formatv(fmt, std::forward<Ts>(vals)...));
   }
-  template <typename... Ts> static void info(const char *fmt, Ts &&... vals) {
+  template <typename... Ts>
+  static void info(const char *fmt, Ts &&...vals) {
     log(Level::Info, fmt, llvm::formatv(fmt, std::forward<Ts>(vals)...));
   }
-  template <typename... Ts> static void error(const char *fmt, Ts &&... vals) {
+  template <typename... Ts>
+  static void error(const char *fmt, Ts &&...vals) {
     log(Level::Error, fmt, llvm::formatv(fmt, std::forward<Ts>(vals)...));
   }
 
 private:
   Logger() = default;
 
   /// Return the main logger instance.
   static Logger &get();
 
   /// Start a log message with the given severity level.
   static void log(Level logLevel, const char *fmt,
                   const llvm::formatv_object_base &message);
 
   /// The minimum logging level. Messages with lower level are ignored.
   Level logLevel = Level::Error;
 
   /// A mutex used to guard logging.
   std::mutex mutex;
 };
 } // namespace lsp
 } // namespace mlir
 
-#endif // LIB_MLIR_TOOLS_MLIRLSPSERVER_LSP_LOGGING_H
+#endif // LIB_MLIR_TOOLS_LSPSERVERSUPPORT_LOGGING_H

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

 //===- Logging.cpp --------------------------------------------------------===//
 //
 // 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 "Logging.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 void Logger::setLogLevel(Level logLevel) { get().logLevel = logLevel; }
 
 Logger &Logger::get() {
   static Logger logger;
   return logger;
 }
 
 void Logger::log(Level logLevel, const char *fmt,
                  const llvm::formatv_object_base &message) {
   Logger &logger = get();
 
   // Ignore messages with log levels below the current setting in the logger.
   if (logLevel < logger.logLevel)
     return;
 
   // An indicator character for each log level.
   const char *logLevelIndicators = "DIE";
 
   // Format the message and print to errs.
   llvm::sys::TimePoint<> timestamp = std::chrono::system_clock::now();
   std::lock_guard<std::mutex> logGuard(logger.mutex);
   llvm::errs() << llvm::formatv(
       "{0}[{1:%H:%M:%S.%L}] {2}\n",
       logLevelIndicators[static_cast<unsigned>(logLevel)], timestamp, message);
   llvm::errs().flush();
 }

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

 // Each struct has a toJSON and fromJSON function, that converts between
 // the struct and a JSON representation. (See JSON.h)
 //
 // Some structs also have operator<< serialization. This is for debugging and
 // tests, and is not generally machine-readable.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LIB_MLIR_TOOLS_MLIRLSPSERVER_LSP_PROTOCOL_H_
-#define LIB_MLIR_TOOLS_MLIRLSPSERVER_LSP_PROTOCOL_H_
+#ifndef LIB_MLIR_TOOLS_LSPSERVERSUPPORT_PROTOCOL_H_
+#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_PROTOCOL_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 #include <bitset>
 #include <memory>
 #include <string>

 
 /// Add support for JSON serialization.
 llvm::json::Value toJSON(const PublishDiagnosticsParams &params);
 
 } // namespace lsp
 } // namespace mlir
 
 namespace llvm {
-template <> struct format_provider<mlir::lsp::Position> {
+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/lsp-server-support/Protocol.cpp

 //===--- Protocol.cpp - Language Server Protocol Implementation -----------===//
 //
 // 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 the serialization code for the LSP structs.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Protocol.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 // Helper that doesn't treat `null` and absent fields as failures.
 template <typename T>
 static bool mapOptOrNull(const llvm::json::Value &params,
                          llvm::StringLiteral prop, T &out,
                          llvm::json::Path path) {
   const llvm::json::Object *o = params.getAsObject();
   assert(o);
 
   // Field is missing or null.
   auto *v = o->get(prop);
   if (!v || v->getAsNull().hasValue())
     return true;
   return fromJSON(*v, out, path.field(prop));
 }
 
 //===----------------------------------------------------------------------===//
 // LSPError
 //===----------------------------------------------------------------------===//
 
 char LSPError::ID;
 
 //===----------------------------------------------------------------------===//
 // URIForFile
 //===----------------------------------------------------------------------===//
 
 static bool isWindowsPath(StringRef path) {
   return path.size() > 1 && llvm::isAlpha(path[0]) && path[1] == ':';
 }
 
 static bool isNetworkPath(StringRef path) {
   return path.size() > 2 && path[0] == path[1] &&
          llvm::sys::path::is_separator(path[0]);
 }
 
 static bool shouldEscapeInURI(unsigned char c) {
   // Unreserved characters.
   if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
       (c >= '0' && c <= '9'))
     return false;
 
   switch (c) {
   case '-':
   case '_':
   case '.':
   case '~':
   // '/' is only reserved when parsing.
   case '/':
   // ':' is only reserved for relative URI paths, which we doesn't produce.
   case ':':
     return false;
   }
   return true;
 }
 
 /// Encodes a string according to percent-encoding.
 /// - Unreserved characters are not escaped.
 /// - Reserved characters always escaped with exceptions like '/'.
 /// - All other characters are escaped.
 static void percentEncode(StringRef content, std::string &out) {
   for (unsigned char c : content) {
     if (shouldEscapeInURI(c)) {
       out.push_back('%');
       out.push_back(llvm::hexdigit(c / 16));
       out.push_back(llvm::hexdigit(c % 16));
     } else {
       out.push_back(c);
     }
   }
 }
 
 /// Decodes a string according to percent-encoding.
 static std::string percentDecode(StringRef content) {
   std::string result;
   for (auto i = content.begin(), e = content.end(); i != e; ++i) {
     if (*i != '%') {
       result += *i;
       continue;
     }
     if (*i == '%' && i + 2 < content.end() && llvm::isHexDigit(*(i + 1)) &&
         llvm::isHexDigit(*(i + 2))) {
       result.push_back(llvm::hexFromNibbles(*(i + 1), *(i + 2)));
       i += 2;
     } else {
       result.push_back(*i);
     }
   }
   return result;
 }
 
 static bool isValidScheme(StringRef scheme) {
   if (scheme.empty())
     return false;
   if (!llvm::isAlpha(scheme[0]))
     return false;
   return std::all_of(scheme.begin() + 1, scheme.end(), [](char c) {
     return llvm::isAlnum(c) || c == '+' || c == '.' || c == '-';
   });
 }
 
 static llvm::Expected<std::string> uriFromAbsolutePath(StringRef absolutePath) {
   std::string body;
   StringRef authority;
   StringRef root = llvm::sys::path::root_name(absolutePath);
   if (isNetworkPath(root)) {
     // Windows UNC paths e.g. \\server\share => file://server/share
     authority = root.drop_front(2);
     absolutePath.consume_front(root);
   } else if (isWindowsPath(root)) {
     // Windows paths e.g. X:\path => file:///X:/path
     body = "/";
   }
   body += llvm::sys::path::convert_to_slash(absolutePath);
 
   std::string uri = "file:";
   if (authority.empty() && body.empty())
     return uri;
 
   // If authority if empty, we only print body if it starts with "/"; otherwise,
   // the URI is invalid.
   if (!authority.empty() || StringRef(body).startswith("/")) {
     uri.append("//");
     percentEncode(authority, uri);
   }
   percentEncode(body, uri);
   return uri;
 }
 
 static llvm::Expected<std::string> getAbsolutePath(StringRef authority,
                                                    StringRef body) {
   if (!body.startswith("/"))
     return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         "File scheme: expect body to be an absolute path starting "
         "with '/': " +
             body);
   SmallString<128> path;
   if (!authority.empty()) {
     // Windows UNC paths e.g. file://server/share => \\server\share
     ("//" + authority).toVector(path);
   } else if (isWindowsPath(body.substr(1))) {
     // Windows paths e.g. file:///X:/path => X:\path
     body.consume_front("/");
   }
   path.append(body);
   llvm::sys::path::native(path);
   return std::string(path);
 }
 
 static llvm::Expected<std::string> parseFilePathFromURI(StringRef origUri) {
   StringRef uri = origUri;
 
   // Decode the scheme of the URI.
   size_t pos = uri.find(':');
   if (pos == StringRef::npos)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Scheme must be provided in URI: " +
                                        origUri);
   StringRef schemeStr = uri.substr(0, pos);
   std::string uriScheme = percentDecode(schemeStr);
   if (!isValidScheme(uriScheme))
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Invalid scheme: " + schemeStr +
                                        " (decoded: " + uriScheme + ")");
   uri = uri.substr(pos + 1);
 
   // Decode the authority of the URI.
   std::string uriAuthority;
   if (uri.consume_front("//")) {
     pos = uri.find('/');
     uriAuthority = percentDecode(uri.substr(0, pos));
     uri = uri.substr(pos);
   }
 
   // Decode the body of the URI.
   std::string uriBody = percentDecode(uri);
 
   // Compute the absolute path for this uri.
   if (uriScheme != "file" && uriScheme != "test") {
     return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         "mlir-lsp-server only supports 'file' URI scheme for workspace files");
   }
   return getAbsolutePath(uriAuthority, uriBody);
 }
 
 llvm::Expected<URIForFile> URIForFile::fromURI(StringRef uri) {
   llvm::Expected<std::string> filePath = parseFilePathFromURI(uri);
   if (!filePath)
     return filePath.takeError();
   return URIForFile(std::move(*filePath), uri.str());
 }
 
 llvm::Expected<URIForFile> URIForFile::fromFile(StringRef absoluteFilepath) {
   llvm::Expected<std::string> uri = uriFromAbsolutePath(absoluteFilepath);
   if (!uri)
     return uri.takeError();
   return fromURI(*uri);
 }
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value, URIForFile &result,
                          llvm::json::Path path) {
   if (Optional<StringRef> str = value.getAsString()) {
     llvm::Expected<URIForFile> expectedURI = URIForFile::fromURI(*str);
     if (!expectedURI) {
       path.report("unresolvable URI");
       consumeError(expectedURI.takeError());
       return false;
     }
     result = std::move(*expectedURI);
     return true;
   }
   return false;
 }
 
 llvm::json::Value mlir::lsp::toJSON(const URIForFile &value) {
   return value.uri();
 }
 
 raw_ostream &mlir::lsp::operator<<(raw_ostream &os, const URIForFile &value) {
   return os << value.uri();
 }
 
 //===----------------------------------------------------------------------===//
 // ClientCapabilities
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          ClientCapabilities &result, llvm::json::Path path) {
   const llvm::json::Object *o = value.getAsObject();
   if (!o) {
     path.report("expected object");
     return false;
   }
   if (const llvm::json::Object *textDocument = o->getObject("textDocument")) {
     if (const llvm::json::Object *documentSymbol =
             textDocument->getObject("documentSymbol")) {
       if (Optional<bool> hierarchicalSupport =
               documentSymbol->getBoolean("hierarchicalDocumentSymbolSupport"))
         result.hierarchicalDocumentSymbol = *hierarchicalSupport;
     }
   }
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // InitializeParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value, TraceLevel &result,
                          llvm::json::Path path) {
   if (Optional<StringRef> str = value.getAsString()) {
     if (*str == "off") {
       result = TraceLevel::Off;
       return true;
     }
     if (*str == "messages") {
       result = TraceLevel::Messages;
       return true;
     }
     if (*str == "verbose") {
       result = TraceLevel::Verbose;
       return true;
     }
   }
   return false;
 }
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          InitializeParams &result, llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   if (!o)
     return false;
   // We deliberately don't fail if we can't parse individual fields.
   o.map("capabilities", result.capabilities);
   o.map("trace", result.trace);
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // TextDocumentItem
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          TextDocumentItem &result, llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("uri", result.uri) &&
          o.map("languageId", result.languageId) && o.map("text", result.text) &&
          o.map("version", result.version);
 }
 
 //===----------------------------------------------------------------------===//
 // TextDocumentIdentifier
 //===----------------------------------------------------------------------===//
 
 llvm::json::Value mlir::lsp::toJSON(const TextDocumentIdentifier &value) {
   return llvm::json::Object{{"uri", value.uri}};
 }
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          TextDocumentIdentifier &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("uri", result.uri);
 }
 
 //===----------------------------------------------------------------------===//
 // VersionedTextDocumentIdentifier
 //===----------------------------------------------------------------------===//
 
 llvm::json::Value
 mlir::lsp::toJSON(const VersionedTextDocumentIdentifier &value) {
   return llvm::json::Object{
       {"uri", value.uri},
       {"version", value.version},
   };
 }
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          VersionedTextDocumentIdentifier &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("uri", result.uri) && o.map("version", result.version);
 }
 
 //===----------------------------------------------------------------------===//
 // Position
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value, Position &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("line", result.line) &&
          o.map("character", result.character);
 }
 
 llvm::json::Value mlir::lsp::toJSON(const Position &value) {
   return llvm::json::Object{
       {"line", value.line},
       {"character", value.character},
   };
 }
 
 raw_ostream &mlir::lsp::operator<<(raw_ostream &os, const Position &value) {
   return os << value.line << ':' << value.character;
 }
 
 //===----------------------------------------------------------------------===//
 // Range
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value, Range &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("start", result.start) && o.map("end", result.end);
 }
 
 llvm::json::Value mlir::lsp::toJSON(const Range &value) {
   return llvm::json::Object{
       {"start", value.start},
       {"end", value.end},
   };
 }
 
 raw_ostream &mlir::lsp::operator<<(raw_ostream &os, const Range &value) {
   return os << value.start << '-' << value.end;
 }
 
 //===----------------------------------------------------------------------===//
 // Location
 //===----------------------------------------------------------------------===//
 
 llvm::json::Value mlir::lsp::toJSON(const Location &value) {
   return llvm::json::Object{
       {"uri", value.uri},
       {"range", value.range},
   };
 }
 
 raw_ostream &mlir::lsp::operator<<(raw_ostream &os, const Location &value) {
   return os << value.range << '@' << value.uri;
 }
 
 //===----------------------------------------------------------------------===//
 // TextDocumentPositionParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          TextDocumentPositionParams &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("textDocument", result.textDocument) &&
          o.map("position", result.position);
 }
 
 //===----------------------------------------------------------------------===//
 // ReferenceParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          ReferenceContext &result, llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.mapOptional("includeDeclaration", result.includeDeclaration);
 }
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          ReferenceParams &result, llvm::json::Path path) {
   TextDocumentPositionParams &base = result;
   llvm::json::ObjectMapper o(value, path);
   return fromJSON(value, base, path) && o &&
          o.mapOptional("context", result.context);
 }
 
 //===----------------------------------------------------------------------===//
 // DidOpenTextDocumentParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          DidOpenTextDocumentParams &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("textDocument", result.textDocument);
 }
 
 //===----------------------------------------------------------------------===//
 // DidCloseTextDocumentParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          DidCloseTextDocumentParams &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("textDocument", result.textDocument);
 }
 
 //===----------------------------------------------------------------------===//
 // DidChangeTextDocumentParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          TextDocumentContentChangeEvent &result,
                          llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("range", result.range) &&
          o.map("rangeLength", result.rangeLength) && o.map("text", result.text);
 }
 
 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");
 }
 
 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);
 }
 
 //===----------------------------------------------------------------------===//
 // DocumentSymbol
 //===----------------------------------------------------------------------===//
 
 llvm::json::Value mlir::lsp::toJSON(const DocumentSymbol &symbol) {
   llvm::json::Object result{{"name", symbol.name},
                             {"kind", static_cast<int>(symbol.kind)},
                             {"range", symbol.range},
                             {"selectionRange", symbol.selectionRange}};
 
   if (!symbol.detail.empty())
     result["detail"] = symbol.detail;
   if (!symbol.children.empty())
     result["children"] = symbol.children;
   return std::move(result);
 }
 
 //===----------------------------------------------------------------------===//
 // DocumentSymbolParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value,
                          DocumentSymbolParams &result, llvm::json::Path path) {
   llvm::json::ObjectMapper o(value, path);
   return o && o.map("textDocument", result.textDocument);
 }
 
 //===----------------------------------------------------------------------===//
 // DiagnosticRelatedInformation
 //===----------------------------------------------------------------------===//
 
 llvm::json::Value mlir::lsp::toJSON(const DiagnosticRelatedInformation &info) {
   return llvm::json::Object{
       {"location", info.location},
       {"message", info.message},
   };
 }
 
 //===----------------------------------------------------------------------===//
 // Diagnostic
 //===----------------------------------------------------------------------===//
 
 llvm::json::Value mlir::lsp::toJSON(const Diagnostic &diag) {
   llvm::json::Object result{
       {"range", diag.range},
       {"severity", (int)diag.severity},
       {"message", diag.message},
   };
   if (diag.category)
     result["category"] = *diag.category;
   if (!diag.source.empty())
     result["source"] = diag.source;
   if (diag.relatedInformation)
     result["relatedInformation"] = *diag.relatedInformation;
   return std::move(result);
 }
 
 //===----------------------------------------------------------------------===//
 // PublishDiagnosticsParams
 //===----------------------------------------------------------------------===//
 
 llvm::json::Value mlir::lsp::toJSON(const PublishDiagnosticsParams &params) {
   return llvm::json::Object{
       {"uri", params.uri},
       {"diagnostics", params.diagnostics},
       {"version", params.version},
   };
 }

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

 //===--- Transport.h - Sending and Receiving LSP messages -------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // The language server protocol is usually implemented by writing messages as
 // JSON-RPC over the stdin/stdout of a subprocess. This file contains a JSON
 // transport interface that handles this communication.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LIB_MLIR_TOOLS_MLIRLSPSERVER_LSP_TRANSPORT_H_
-#define LIB_MLIR_TOOLS_MLIRLSPSERVER_LSP_TRANSPORT_H_
+#ifndef LIB_MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H_
+#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H_
 
 #include "Logging.h"
 #include "Protocol.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"

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

 //===--- JSONTransport.cpp - sending and receiving LSP messages over JSON -===//
 //
 // 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 "Transport.h"
 #include "Logging.h"
 #include "Protocol.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/Error.h"
 #include <system_error>
 #include <utility>
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 //===----------------------------------------------------------------------===//
 // Reply
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// Function object to reply to an LSP call.
 /// Each instance must be called exactly once, otherwise:
 ///  - if there was no reply, an error reply is sent
 ///  - if there were multiple replies, only the first is sent
 class Reply {
 public:
   Reply(const llvm::json::Value &id, StringRef method,
         JSONTransport &transport);
   Reply(Reply &&other);
   Reply &operator=(Reply &&) = delete;
   Reply(const Reply &) = delete;
   Reply &operator=(const Reply &) = delete;
 
   void operator()(llvm::Expected<llvm::json::Value> reply);
 
 private:
   StringRef method;
   std::atomic<bool> replied = {false};
   llvm::json::Value id;
   JSONTransport *transport;
 };
 } // namespace
 
 Reply::Reply(const llvm::json::Value &id, llvm::StringRef method,
              JSONTransport &transport)
     : id(id), transport(&transport) {}
 
 Reply::Reply(Reply &&other)
     : replied(other.replied.load()), id(std::move(other.id)),
       transport(other.transport) {
   other.transport = nullptr;
 }
 
 void Reply::operator()(llvm::Expected<llvm::json::Value> reply) {
   if (replied.exchange(true)) {
     Logger::error("Replied twice to message {0}({1})", method, id);
     assert(false && "must reply to each call only once!");
     return;
   }
   assert(transport && "expected valid transport to reply to");
 
   if (reply) {
     Logger::info("--> reply:{0}({1})", method, id);
     transport->reply(std::move(id), std::move(reply));
   } else {
     llvm::Error error = reply.takeError();
     Logger::info("--> reply:{0}({1})", method, id, error);
     transport->reply(std::move(id), std::move(error));
   }
 }
 
 //===----------------------------------------------------------------------===//
 // MessageHandler
 //===----------------------------------------------------------------------===//
 
 bool MessageHandler::onNotify(llvm::StringRef method, llvm::json::Value value) {
   Logger::info("--> {0}", method);
 
   if (method == "exit")
     return false;
   if (method == "$cancel") {
     // TODO: Add support for cancelling requests.
   } else {
     auto it = notificationHandlers.find(method);
     if (it != notificationHandlers.end())
       it->second(std::move(value));
   }
   return true;
 }
 
 bool MessageHandler::onCall(llvm::StringRef method, llvm::json::Value params,
                             llvm::json::Value id) {
   Logger::info("--> {0}({1})", method, id);
 
   Reply reply(id, method, transport);
 
   auto it = methodHandlers.find(method);
   if (it != methodHandlers.end()) {
     it->second(std::move(params), std::move(reply));
   } else {
     reply(llvm::make_error<LSPError>("method not found: " + method.str(),
                                      ErrorCode::MethodNotFound));
   }
   return true;
 }
 
 bool MessageHandler::onReply(llvm::json::Value id,
                              llvm::Expected<llvm::json::Value> result) {
   // TODO: Add support for reply callbacks when support for outgoing messages is
   // added. For now, we just log an error on any replies received.
   Callback<llvm::json::Value> replyHandler =
       [&id](llvm::Expected<llvm::json::Value> result) {
         Logger::error(
             "received a reply with ID {0}, but there was no such call", id);
         if (!result)
           llvm::consumeError(result.takeError());
       };
 
   // Log and run the reply handler.
   if (result)
     replyHandler(std::move(result));
   else
     replyHandler(result.takeError());
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // JSONTransport
 //===----------------------------------------------------------------------===//
 
 /// Encode the given error as a JSON object.
 static llvm::json::Object encodeError(llvm::Error error) {
   std::string message;
   ErrorCode code = ErrorCode::UnknownErrorCode;
   auto handlerFn = [&](const LSPError &lspError) -> llvm::Error {
     message = lspError.message;
     code = lspError.code;
     return llvm::Error::success();
   };
   if (llvm::Error unhandled = llvm::handleErrors(std::move(error), handlerFn))
     message = llvm::toString(std::move(unhandled));
 
   return llvm::json::Object{
       {"message", std::move(message)},
       {"code", int64_t(code)},
   };
 }
 
 /// Decode the given JSON object into an error.
 llvm::Error decodeError(const llvm::json::Object &o) {
   StringRef msg = o.getString("message").getValueOr("Unspecified error");
   if (Optional<int64_t> code = o.getInteger("code"))
     return llvm::make_error<LSPError>(msg.str(), ErrorCode(*code));
   return llvm::make_error<llvm::StringError>(llvm::inconvertibleErrorCode(),
                                              msg.str());
 }
 
 void JSONTransport::notify(StringRef method, llvm::json::Value params) {
   sendMessage(llvm::json::Object{
       {"jsonrpc", "2.0"},
       {"method", method},
       {"params", std::move(params)},
   });
 }
 void JSONTransport::call(StringRef method, llvm::json::Value params,
                          llvm::json::Value id) {
   sendMessage(llvm::json::Object{
       {"jsonrpc", "2.0"},
       {"id", std::move(id)},
       {"method", method},
       {"params", std::move(params)},
   });
 }
 void JSONTransport::reply(llvm::json::Value id,
                           llvm::Expected<llvm::json::Value> result) {
   if (result) {
     return sendMessage(llvm::json::Object{
         {"jsonrpc", "2.0"},
         {"id", std::move(id)},
         {"result", std::move(*result)},
     });
   }
 
   sendMessage(llvm::json::Object{
       {"jsonrpc", "2.0"},
       {"id", std::move(id)},
       {"error", encodeError(result.takeError())},
   });
 }
 
 llvm::Error JSONTransport::run(MessageHandler &handler) {
   std::string json;
   while (!feof(in)) {
     if (ferror(in)) {
       return llvm::errorCodeToError(
           std::error_code(errno, std::system_category()));
     }
 
     if (succeeded(readMessage(json))) {
       if (llvm::Expected<llvm::json::Value> doc = llvm::json::parse(json)) {
         if (!handleMessage(std::move(*doc), handler))
           return llvm::Error::success();
       } else {
         Logger::error("JSON parse error: {0}", llvm::toString(doc.takeError()));
       }
     }
   }
   return llvm::errorCodeToError(std::make_error_code(std::errc::io_error));
 }
 
 void JSONTransport::sendMessage(llvm::json::Value msg) {
   outputBuffer.clear();
   llvm::raw_svector_ostream os(outputBuffer);
   os << llvm::formatv(prettyOutput ? "{0:2}\n" : "{0}", msg);
   out << "Content-Length: " << outputBuffer.size() << "\r\n\r\n"
       << outputBuffer;
   out.flush();
   Logger::debug(">>> {0}\n", outputBuffer);
 }
 
 bool JSONTransport::handleMessage(llvm::json::Value msg,
                                   MessageHandler &handler) {
   // Message must be an object with "jsonrpc":"2.0".
   llvm::json::Object *object = msg.getAsObject();
   if (!object ||
       object->getString("jsonrpc") != llvm::Optional<StringRef>("2.0"))
     return false;
 
   // `id` may be any JSON value. If absent, this is a notification.
   llvm::Optional<llvm::json::Value> id;
   if (llvm::json::Value *i = object->get("id"))
     id = std::move(*i);
   Optional<StringRef> method = object->getString("method");
 
   // This is a response.
   if (!method) {
     if (!id)
       return false;
     if (auto *err = object->getObject("error"))
       return handler.onReply(std::move(*id), decodeError(*err));
     // result should be given, use null if not.
     llvm::json::Value result = nullptr;
     if (llvm::json::Value *r = object->get("result"))
       result = std::move(*r);
     return handler.onReply(std::move(*id), std::move(result));
   }
 
   // Params should be given, use null if not.
   llvm::json::Value params = nullptr;
   if (llvm::json::Value *p = object->get("params"))
     params = std::move(*p);
 
   if (id)
     return handler.onCall(*method, std::move(params), std::move(*id));
   return handler.onNotify(*method, std::move(params));
 }
 
 /// Tries to read a line up to and including \n.
 /// If failing, feof(), ferror(), or shutdownRequested() will be set.
 LogicalResult readLine(std::FILE *in, SmallVectorImpl<char> &out) {
   // Big enough to hold any reasonable header line. May not fit content lines
   // in delimited mode, but performance doesn't matter for that mode.
   static constexpr int bufSize = 128;
   size_t size = 0;
   out.clear();
   for (;;) {
     out.resize_for_overwrite(size + bufSize);
     if (!std::fgets(&out[size], bufSize, in))
       return failure();
 
     clearerr(in);
 
     // If the line contained null bytes, anything after it (including \n) will
     // be ignored. Fortunately this is not a legal header or JSON.
     size_t read = std::strlen(&out[size]);
     if (read > 0 && out[size + read - 1] == '\n') {
       out.resize(size + read);
       return success();
     }
     size += read;
   }
 }
 
 // Returns None when:
 //  - ferror(), feof(), or shutdownRequested() are set.
 //  - Content-Length is missing or empty (protocol error)
 LogicalResult JSONTransport::readStandardMessage(std::string &json) {
   // A Language Server Protocol message starts with a set of HTTP headers,
   // delimited  by \r\n, and terminated by an empty line (\r\n).
   unsigned long long contentLength = 0;
   llvm::SmallString<128> line;
   while (true) {
     if (feof(in) || ferror(in) || failed(readLine(in, line)))
       return failure();
 
     // Content-Length is a mandatory header, and the only one we handle.
     StringRef lineRef = line;
     if (lineRef.consume_front("Content-Length: ")) {
       llvm::getAsUnsignedInteger(lineRef.trim(), 0, contentLength);
     } else if (!lineRef.trim().empty()) {
       // It's another header, ignore it.
       continue;
     } else {
       // An empty line indicates the end of headers. Go ahead and read the JSON.
       break;
     }
   }
 
   // The fuzzer likes crashing us by sending "Content-Length: 9999999999999999"
   if (contentLength == 0 || contentLength > 1 << 30)
     return failure();
 
   json.resize(contentLength);
   for (size_t pos = 0, read; pos < contentLength; pos += read) {
     read = std::fread(&json[pos], 1, contentLength - pos, in);
     if (read == 0)
       return failure();
 
     // If we're done, the error was transient. If we're not done, either it was
     // transient or we'll see it again on retry.
     clearerr(in);
     pos += read;
   }
   return success();
 }
 
 /// For lit tests we support a simplified syntax:
 /// - messages are delimited by '// -----' on a line by itself
 /// - lines starting with // are ignored.
 /// This is a testing path, so favor simplicity over performance here.
 /// When returning failure: feof(), ferror(), or shutdownRequested() will be
 /// set.
 LogicalResult JSONTransport::readDelimitedMessage(std::string &json) {
   json.clear();
   llvm::SmallString<128> line;
   while (succeeded(readLine(in, line))) {
     StringRef lineRef = line.str().trim();
     if (lineRef.startswith("//")) {
       // Found a delimiter for the message.
       if (lineRef == "// -----")
         break;
       continue;
     }
 
     json += line;
   }
 
   return failure(ferror(in));
 }

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

 add_mlir_library(MLIRLspServerLib
-  lsp/Logging.cpp
-  lsp/Protocol.cpp
-  lsp/Transport.cpp
   LSPServer.cpp
   MLIRServer.cpp
   MlirLspServerMain.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Tools/mlir-lsp-server
 
   LINK_LIBS PUBLIC
   MLIRIR
+  MLIRLspServerSupportLib
   MLIRParser
   )

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

 //===- LSPServer.cpp - MLIR 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 "LSPServer.h"
+#include "../lsp-server-support/Logging.h"
+#include "../lsp-server-support/Protocol.h"
+#include "../lsp-server-support/Transport.h"
 #include "MLIRServer.h"
-#include "lsp/Logging.h"
-#include "lsp/Protocol.h"
-#include "lsp/Transport.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringMap.h"
 
 #define DEBUG_TYPE "mlir-lsp-server"
 
 using namespace mlir;
 using namespace mlir::lsp;
 

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

 //===- MLIRServer.cpp - MLIR Generic 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 "MLIRServer.h"
-#include "lsp/Logging.h"
-#include "lsp/Protocol.h"
+#include "../lsp-server-support/Logging.h"
+#include "../lsp-server-support/Protocol.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Parser/AsmParserState.h"
 #include "mlir/Parser/Parser.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 

 }
 
 /// Returns a language server range for the given source range.
 static lsp::Range getRangeFromLoc(llvm::SourceMgr &mgr, SMRange range) {
   return {getPosFromLoc(mgr, range.Start), getPosFromLoc(mgr, range.End)};
 }
 
 /// Returns a language server location from the given source range.
-static lsp::Location getLocationFromLoc(llvm::SourceMgr &mgr,
-                                        SMRange range,
+static lsp::Location getLocationFromLoc(llvm::SourceMgr &mgr, SMRange range,
                                         const lsp::URIForFile &uri) {
   return lsp::Location{uri, getRangeFromLoc(mgr, range)};
 }
 
 /// Returns a language server location from the given MLIR file location.
 static Optional<lsp::Location> getLocationFromLoc(FileLineColLoc loc) {
   llvm::Expected<lsp::URIForFile> sourceURI =
       lsp::URIForFile::fromFile(loc.getFilename());
loc->walk([&](Location nestedLoc) {
     if (sourceLoc && (!uri || sourceLoc->uri == *uri)) {
       location = *sourceLoc;
       SMLoc loc = sourceMgr.FindLocForLineAndColumn(
           sourceMgr.getMainFileID(), fileLoc.getLine(), fileLoc.getColumn());
 
       // Use range of potential identifier starting at location, else length 1
       // range.
       location->range.end.character += 1;
-      if (Optional<SMRange> range =
-              AsmParserState::convertIdLocToRange(loc)) {
+      if (Optional<SMRange> range = AsmParserState::convertIdLocToRange(loc)) {
         auto lineCol = sourceMgr.getLineAndColumn(range->End);
         location->range.end.character =
             std::max(fileLoc.getColumn() + 1, lineCol.second - 1);
       }
       return WalkResult::interrupt();
     }
     return WalkResult::advance();
   });
static bool isDefOrUse(const AsmParserState::SMDefinition &def, SMLoc loc,
   // Check the main definition.
   if (contains(def.loc, loc)) {
     if (overlappedRange)
       *overlappedRange = def.loc;
     return true;
   }
 
   // Check the uses.
-  const auto *useIt = llvm::find_if(def.uses, [&](const SMRange &range) {
-    return contains(range, loc);
-  });
+  const auto *useIt = llvm::find_if(
+      def.uses, [&](const SMRange &range) { return contains(range, loc); });
   if (useIt != def.uses.end()) {
     if (overlappedRange)
       *overlappedRange = *useIt;
     return true;
   }
   return false;
 }
 

 
 /// 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,
-                              SMRange loc = {}) {
+static void printDefBlockName(raw_ostream &os, Block *block, 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.
struct MLIRDocument {
   // Hover
   //===--------------------------------------------------------------------===//
 
   Optional<lsp::Hover> findHover(const lsp::URIForFile &uri,
                                  const lsp::Position &hoverPos);
   Optional<lsp::Hover>
   buildHoverForOperation(SMRange hoverRange,
                          const AsmParserState::OperationDefinition &op);
-  lsp::Hover buildHoverForOperationResult(SMRange hoverRange,
-                                          Operation *op, unsigned resultStart,
-                                          unsigned resultEnd,
-                                          SMLoc posLoc);
+  lsp::Hover buildHoverForOperationResult(SMRange hoverRange, Operation *op,
+                                          unsigned resultStart,
+                                          unsigned resultEnd, SMLoc posLoc);
   lsp::Hover buildHoverForBlock(SMRange hoverRange,
                                 const AsmParserState::BlockDefinition &block);
   lsp::Hover
   buildHoverForBlockArgument(SMRange hoverRange, BlockArgument arg,
                              const AsmParserState::BlockDefinition &block);
 
   //===--------------------------------------------------------------------===//
   // Document Symbols

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

 //===- MlirLspServerMain.cpp - MLIR Language Server main ------------------===//
 //
 // 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 "mlir/Tools/mlir-lsp-server/MlirLspServerMain.h"
+#include "../lsp-server-support/Logging.h"
+#include "../lsp-server-support/Transport.h"
 #include "LSPServer.h"
 #include "MLIRServer.h"
-#include "lsp/Logging.h"
-#include "lsp/Transport.h"
 #include "mlir/IR/Dialect.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Program.h"
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 LogicalResult mlir::MlirLspServerMain(int argc, char **argv,