[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/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/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/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,