[mlir][NFC] Move the headers for lsp-server-support to include/

[rriddle]

Summary

This makes it a bit easier to share the functionality for building
language servers, and makes the API public. No real functional
change, as the API was already intended for this anyways.

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

 //===- CompilationDatabase.h - LSP Compilation Database ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a definition of a generic compilation database that can be
 // used to provide information about the compilation of a given source file. It
 // contains generic components, leaving more complex interpretation to the
 // specific language servers that consume it.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LIB_MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H_
-#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H_
+#ifndef MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H
+#define MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringMap.h"
 #include <memory>
 #include <string>
 
 namespace mlir {
 namespace lsp {
private:
 
   /// A default file info that contains basic information for use by files that
   /// weren't explicitly in the database.
   FileInfo defaultFileInfo;
 };
 } // namespace lsp
 } // namespace mlir
 
-#endif // LIB_MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H_
+#endif // MLIR_TOOLS_LSPSERVERSUPPORT_COMPILATIONDATABASE_H

mlir/include/mlir/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_LSPSERVERSUPPORT_LOGGING_H
-#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_LOGGING_H
+#ifndef MLIR_TOOLS_LSPSERVERSUPPORT_LOGGING_H
+#define 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 {
private:
   Level logLevel = Level::Error;
 
   /// A mutex used to guard logging.
   std::mutex mutex;
 };
 } // namespace lsp
 } // namespace mlir
 
-#endif // LIB_MLIR_TOOLS_LSPSERVERSUPPORT_LOGGING_H
+#endif // MLIR_TOOLS_LSPSERVERSUPPORT_LOGGING_H

mlir/include/mlir/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_LSPSERVERSUPPORT_PROTOCOL_H_
-#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_PROTOCOL_H_
+#ifndef MLIR_TOOLS_LSPSERVERSUPPORT_PROTOCOL_H
+#define MLIR_TOOLS_LSPSERVERSUPPORT_PROTOCOL_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <bitset>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
-#include <optional>
 
 namespace mlir {
 struct LogicalResult;
 
 namespace lsp {
 
 enum class ErrorCode {
   // Defined by JSON RPC.

mlir/include/mlir/Tools/lsp-server-support/SourceMgrUtils.h

 //===--- SourceMgrUtils.h - SourceMgr LSP Utils -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains an array of generally useful SourceMgr utilities for
 // interacting with LSP components.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LIB_MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H_
-#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H_
+#ifndef MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H
+#define MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H
 
-#include "Protocol.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
 #include "llvm/Support/SourceMgr.h"
 #include <optional>
 
 namespace mlir {
 namespace lsp {
 //===----------------------------------------------------------------------===//
 // Utils
 //===----------------------------------------------------------------------===//
 
 /// Returns the range of a lexical token given a SMLoc corresponding to the
 /// start of an token location. The range is computed heuristically, and
 /// supports identifier-like tokens, strings, etc.
-SMRange convertTokenLocToRange(SMLoc loc);
+SMRange convertTokenLocToRange(SMLoc loc, StringRef identifierChars = "");
 
 /// Extract a documentation comment for the given location within the source
 /// manager. Returns std::nullopt if no comment could be computed.
 std::optional<std::string> extractSourceDocComment(llvm::SourceMgr &sourceMgr,
                                                    SMLoc loc);
 
 /// Returns true if the given range contains the given source location. Note
 /// that this has different behavior than SMRange because it is inclusive of the

mlir/include/mlir/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_LSPSERVERSUPPORT_TRANSPORT_H_
-#define LIB_MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H_
+#ifndef MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H
+#define MLIR_TOOLS_LSPSERVERSUPPORT_TRANSPORT_H
 
-#include "Logging.h"
-#include "Protocol.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 #include <atomic>
 

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

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

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

 //===- CompilationDatabase.cpp - LSP Compilation Database -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "CompilationDatabase.h"
-#include "../lsp-server-support/Logging.h"
-#include "Protocol.h"
+#include "mlir/Tools/lsp-server-support/CompilationDatabase.h"
 #include "mlir/Support/FileUtilities.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 //===----------------------------------------------------------------------===//

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 "mlir/Tools/lsp-server-support/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; }

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 "Logging.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
 #include "mlir/Support/LogicalResult.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"

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

 //===--- SourceMgrUtils.cpp - SourceMgr LSP Utils -------------------------===//
 //
 // 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 "SourceMgrUtils.h"
+#include "mlir/Tools/lsp-server-support/SourceMgrUtils.h"
 #include "llvm/Support/Path.h"
 #include <optional>
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 //===----------------------------------------------------------------------===//
 // Utils
while (char c = *curPtr++) {
     }
   }
 
   // If we hit this point, we've reached the end of the buffer. Update the end
   // pointer to not point past the buffer.
   return curPtr - 1;
 }
 
-SMRange lsp::convertTokenLocToRange(SMLoc loc) {
+SMRange lsp::convertTokenLocToRange(SMLoc loc, StringRef identifierChars) {
   if (!loc.isValid())
     return SMRange();
   const char *curPtr = loc.getPointer();
 
   // Check if this is a string token.
   if (*curPtr == '"') {
     curPtr = lexLocStringTok(curPtr + 1);
 
     // Otherwise, default to handling an identifier.
   } else {
     // Return if the given character is a valid identifier character.
-    auto isIdentifierChar = [](char c) {
-      return isalnum(c) || c == '$' || c == '.' || c == '_' || c == '-';
+    auto isIdentifierChar = [=](char c) {
+      return isalnum(c) || c == '_' || identifierChars.contains(c);
     };
 
     while (*curPtr && isIdentifierChar(*(++curPtr)))
       continue;
   }
 
   return SMRange(loc, SMLoc::getFromPointer(curPtr));
 }

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 "mlir/Tools/lsp-server-support/Transport.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/Error.h"
+#include <optional>
 #include <system_error>
 #include <utility>
-#include <optional>
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 //===----------------------------------------------------------------------===//
 // Reply
 //===----------------------------------------------------------------------===//
 

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/Transport.h"
 #include "MLIRServer.h"
 #include "Protocol.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Transport.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include <optional>
 
 #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-server-support/Logging.h"
-#include "../lsp-server-support/SourceMgrUtils.h"
 #include "Protocol.h"
 #include "mlir/AsmParser/AsmParser.h"
 #include "mlir/AsmParser/AsmParserState.h"
 #include "mlir/AsmParser/CodeComplete.h"
 #include "mlir/Bytecode/BytecodeWriter.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Parser/Parser.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/SourceMgrUtils.h"
 #include "llvm/Support/Base64.h"
 #include "llvm/Support/SourceMgr.h"
 #include <optional>
 
 using namespace mlir;
 
+/// Returns the range of a lexical token given a SMLoc corresponding to the
+/// start of an token location. The range is computed heuristically, and
+/// supports identifier-like tokens, strings, etc.
+static SMRange convertTokenLocToRange(SMLoc loc) {
+  return lsp::convertTokenLocToRange(loc, "$-.");
+}
+
 /// Returns a language server location from the given MLIR file location.
 /// `uriScheme` is the scheme to use when building new uris.
 static std::optional<lsp::Location> getLocationFromLoc(StringRef uriScheme,
                                                        FileLineColLoc loc) {
   llvm::Expected<lsp::URIForFile> sourceURI =
       lsp::URIForFile::fromFile(loc.getFilename(), uriScheme);
   if (!sourceURI) {
     lsp::Logger::error("Failed to create URI for file `{0}`: {1}",
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 (std::optional<SMRange> range = lsp::convertTokenLocToRange(loc)) {
+      if (std::optional<SMRange> range = convertTokenLocToRange(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();
   });

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 "mlir/IR/Dialect.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Transport.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,
                                       DialectRegistry &registry) {

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

 // Some structs also have operator<< serialization. This is for debugging and
 // tests, and is not generally machine-readable.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIB_MLIR_TOOLS_MLIRLSPSERVER_PROTOCOL_H_
 #define LIB_MLIR_TOOLS_MLIRLSPSERVER_PROTOCOL_H_
 
-#include "../lsp-server-support/Protocol.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
 
 namespace mlir {
 namespace lsp {
 //===----------------------------------------------------------------------===//
 // MLIRConvertBytecodeParams
 //===----------------------------------------------------------------------===//
 
 /// This class represents the parameters used when converting between MLIR's

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

 //===- LSPServer.cpp - PDLL Language Server -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LSPServer.h"
 
-#include "../lsp-server-support/Logging.h"
-#include "../lsp-server-support/Transport.h"
 #include "PDLLServer.h"
 #include "Protocol.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Transport.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include <optional>
 
 #define DEBUG_TYPE "pdll-lsp-server"
 
 using namespace mlir;
 using namespace mlir::lsp;

mlir/lib/Tools/mlir-pdll-lsp-server/MlirPdllLspServerMain.cpp

 //===- MlirPdllLspServerMain.cpp - MLIR PDLL 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-pdll-lsp-server/MlirPdllLspServerMain.h"
-#include "../lsp-server-support/Logging.h"
-#include "../lsp-server-support/Transport.h"
 #include "LSPServer.h"
 #include "PDLLServer.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Transport.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Program.h"
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 LogicalResult mlir::MlirPdllLspServerMain(int argc, char **argv) {
   llvm::cl::opt<JSONStreamStyle> inputStyle{

mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp

 //===- PDLLServer.cpp - PDLL Language Server ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PDLLServer.h"
 
-#include "../lsp-server-support/CompilationDatabase.h"
-#include "../lsp-server-support/Logging.h"
-#include "../lsp-server-support/SourceMgrUtils.h"
 #include "Protocol.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "mlir/Tools/PDLL/AST/Nodes.h"
 #include "mlir/Tools/PDLL/AST/Types.h"
 #include "mlir/Tools/PDLL/CodeGen/CPPGen.h"
 #include "mlir/Tools/PDLL/CodeGen/MLIRGen.h"
 #include "mlir/Tools/PDLL/ODS/Constraint.h"
 #include "mlir/Tools/PDLL/ODS/Context.h"
 #include "mlir/Tools/PDLL/ODS/Dialect.h"
 #include "mlir/Tools/PDLL/ODS/Operation.h"
 #include "mlir/Tools/PDLL/Parser/CodeComplete.h"
 #include "mlir/Tools/PDLL/Parser/Parser.h"
+#include "mlir/Tools/lsp-server-support/CompilationDatabase.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/SourceMgrUtils.h"
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include <optional>
 

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

 // Some structs also have operator<< serialization. This is for debugging and
 // tests, and is not generally machine-readable.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIB_MLIR_TOOLS_MLIRPDLLLSPSERVER_PROTOCOL_H_
 #define LIB_MLIR_TOOLS_MLIRPDLLLSPSERVER_PROTOCOL_H_
 
-#include "../lsp-server-support/Protocol.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
 
 namespace mlir {
 namespace lsp {
 //===----------------------------------------------------------------------===//
 // PDLLViewOutputParams
 //===----------------------------------------------------------------------===//
 
 /// The type of output to view from PDLL.

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

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

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

 //===- TableGenLspServerMain.cpp - TableGen 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/tblgen-lsp-server/TableGenLspServerMain.h"
-#include "../lsp-server-support/Logging.h"
-#include "../lsp-server-support/Transport.h"
 #include "LSPServer.h"
 #include "TableGenServer.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Transport.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Program.h"
 
 using namespace mlir;
 using namespace mlir::lsp;
 
 LogicalResult mlir::TableGenLspServerMain(int argc, char **argv) {
   llvm::cl::opt<JSONStreamStyle> inputStyle{

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 "mlir/Support/IndentedOstream.h"
 #include "mlir/Support/LogicalResult.h"
+#include "mlir/Tools/lsp-server-support/CompilationDatabase.h"
+#include "mlir/Tools/lsp-server-support/Logging.h"
+#include "mlir/Tools/lsp-server-support/Protocol.h"
+#include "mlir/Tools/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"
 #include <optional>
 
 using namespace mlir;
 
+/// Returns the range of a lexical token given a SMLoc corresponding to the
+/// start of an token location. The range is computed heuristically, and
+/// supports identifier-like tokens, strings, etc.
+static SMRange convertTokenLocToRange(SMLoc loc) {
+  return lsp::convertTokenLocToRange(loc, "$");
+}
+
 /// Returns a language server uri for the given source location. `mainFileURI`
 /// corresponds to the uri for the main file of the source manager.
 static lsp::URIForFile getURIFromLoc(const llvm::SourceMgr &mgr, SMLoc loc,
                                      const lsp::URIForFile &mainFileURI) {
   int bufferId = mgr.FindBufferContainingLoc(loc);
   if (bufferId == 0 || bufferId == static_cast<int>(mgr.getMainFileID()))
     return mainFileURI;
   llvm::Expected<lsp::URIForFile> fileForLoc = lsp::URIForFile::fromFile(
       mgr.getBufferInfo(bufferId).Buffer->getBufferIdentifier());
   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 getLocationFromLoc(mgr, lsp::convertTokenLocToRange(loc), uri);
+  return getLocationFromLoc(mgr, convertTokenLocToRange(loc), uri);
 }
 
 /// Convert the given TableGen diagnostic to the LSP form.
 static std::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())

 
 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())) {}
+        defLoc(convertTokenLocToRange(record->getLoc().front())) {}
   TableGenIndexSymbol(const llvm::RecordVal *value)
-      : definition(value),
-        defLoc(lsp::convertTokenLocToRange(value->getLoc())) {}
+      : definition(value), defLoc(convertTokenLocToRange(value->getLoc())) {}
   virtual ~TableGenIndexSymbol() = default;
 
   // The main definition of the symbol.
   PointerUnion<const llvm::Record *, const llvm::RecordVal *> definition;
 
   /// The source location of the definition.
   SMRange defLoc;
 
void TableGenIndex::initialize(const llvm::RecordKeeper &records) {
   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));
+      refLoc = 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;
     }
void TableGenIndex::initialize(const llvm::RecordKeeper &records) {
   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));
+      insertRef(sym, convertTokenLocToRange(loc));
     for (SMRange loc : def.getReferenceLocs())
       insertRef(sym, loc);
 
     // Add definitions for any values.
     for (const llvm::RecordVal &value : def.getValues()) {
       auto *sym = getOrInsertDef(&def, &value);
       insertRef(sym, sym->defLoc, /*isDef=*/true);
       for (SMRange refLoc : value.getReferenceLocs())