12 #include "llvm/ADT/None.h"
13 #include "llvm/Support/Error.h"
14 #include "llvm/Support/Path.h"
24 if (!S.startswith(
"file://"))
28 llvm::consumeError(Uri.takeError());
31 for (
const auto &Mapping : Mappings) {
38 llvm::StringRef Body = Uri->body();
39 if (Body.consume_front(From) && (Body.empty() || Body.front() ==
'/')) {
40 std::string MappedBody = (To + Body).str();
41 return URI(Uri->scheme(), Uri->authority(), MappedBody)
52 if (
K == Kind::Object) {
53 llvm::json::Object *
Obj = V.getAsObject();
54 llvm::json::Object MappedObj;
56 for (
auto &KV : *
Obj) {
57 if (llvm::Optional<std::string> MappedKey =
59 MappedObj.try_emplace(std::move(*MappedKey), std::move(KV.second));
61 MappedObj.try_emplace(std::move(KV.first), std::move(KV.second));
64 *
Obj = std::move(MappedObj);
68 }
else if (
K == Kind::Array) {
71 }
else if (
K == Kind::String) {
72 if (llvm::Optional<std::string> Mapped =
74 V = std::move(*Mapped);
80 class PathMappingMessageHandler :
public Transport::MessageHandler {
82 PathMappingMessageHandler(MessageHandler &Handler,
84 : WrappedHandler(Handler), Mappings(Mappings) {}
88 return WrappedHandler.onNotify(Method, std::move(Params));
94 return WrappedHandler.onCall(Method, std::move(Params), std::move(
ID));
98 llvm::Expected<llvm::json::Value> Result)
override {
102 return WrappedHandler.onReply(std::move(
ID), std::move(Result));
106 Transport::MessageHandler &WrappedHandler;
112 class PathMappingTransport :
public Transport {
114 PathMappingTransport(std::unique_ptr<Transport> Transp,
PathMappings Mappings)
115 : WrappedTransport(std::move(Transp)), Mappings(std::move(Mappings)) {}
119 WrappedTransport->notify(Method, std::move(Params));
125 WrappedTransport->call(Method, std::move(Params), std::move(
ID));
129 llvm::Expected<llvm::json::Value> Result)
override {
133 WrappedTransport->reply(std::move(
ID), std::move(Result));
136 llvm::Error loop(MessageHandler &Handler)
override {
137 PathMappingMessageHandler WrappedHandler(Handler, Mappings);
138 return WrappedTransport->loop(WrappedHandler);
142 std::unique_ptr<Transport> WrappedTransport;
148 llvm::Expected<std::string> parsePath(llvm::StringRef
Path) {
149 namespace path = llvm::sys::path;
150 if (path::is_absolute(
Path, path::Style::posix)) {
151 return std::string(
Path);
153 if (path::is_absolute(
Path, path::Style::windows)) {
154 std::string Converted = path::convert_to_slash(
Path, path::Style::windows);
155 if (Converted.front() !=
'/')
156 Converted =
"/" + Converted;
159 return error(
"Path not absolute: {0}",
Path);
165 return OS <<
M.ClientPath <<
"=" <<
M.ServerPath;
168 llvm::Expected<PathMappings>
170 llvm::StringRef ClientPath, ServerPath, PathPair, Rest = RawPathMappings;
172 while (!Rest.empty()) {
173 std::tie(PathPair, Rest) = Rest.split(
",");
174 std::tie(ClientPath, ServerPath) = PathPair.split(
"=");
175 if (ClientPath.empty() || ServerPath.empty())
176 return error(
"Not a valid path mapping pair: {0}", PathPair);
177 llvm::Expected<std::string> ParsedClientPath = parsePath(ClientPath);
178 if (!ParsedClientPath)
179 return ParsedClientPath.takeError();
180 llvm::Expected<std::string> ParsedServerPath = parsePath(ServerPath);
181 if (!ParsedServerPath)
182 return ParsedServerPath.takeError();
183 ParsedMappings.push_back(
184 {std::move(*ParsedClientPath), std::move(*ParsedServerPath)});
186 return ParsedMappings;
189 std::unique_ptr<Transport>
192 return std::make_unique<PathMappingTransport>(std::move(Transp), Mappings);