| 1 |
//===--- Marshalling.cpp -----------------------------------------*- C++-*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#include "Marshalling.h" |
| 10 |
#include "Headers.h" |
| 11 |
#include "Index.pb.h" |
| 12 |
#include "Protocol.h" |
| 13 |
#include "index/Index.h" |
| 14 |
#include "index/Ref.h" |
| 15 |
#include "index/Serialization.h" |
| 16 |
#include "index/Symbol.h" |
| 17 |
#include "index/SymbolID.h" |
| 18 |
#include "index/SymbolLocation.h" |
| 19 |
#include "index/SymbolOrigin.h" |
| 20 |
#include "support/Logger.h" |
| 21 |
#include "clang/Index/IndexSymbol.h" |
| 22 |
#include "llvm/ADT/DenseSet.h" |
| 23 |
#include "llvm/ADT/SmallString.h" |
| 24 |
#include "llvm/ADT/SmallVector.h" |
| 25 |
#include "llvm/ADT/StringRef.h" |
| 26 |
#include "llvm/Support/Error.h" |
| 27 |
#include "llvm/Support/FormatVariadic.h" |
| 28 |
#include "llvm/Support/Path.h" |
| 29 |
#include "llvm/Support/StringSaver.h" |
| 30 |
|
| 31 |
namespace clang { |
| 32 |
namespace clangd { |
| 33 |
namespace remote { |
| 34 |
|
| 35 |
using llvm::sys::path::append; |
| 36 |
using llvm::sys::path::convert_to_slash; |
| 37 |
using llvm::sys::path::is_absolute; |
| 38 |
using llvm::sys::path::replace_path_prefix; |
| 39 |
using llvm::sys::path::Style; |
| 40 |
|
| 41 |
namespace { |
| 42 |
|
| 43 |
template <typename IDRange> |
| 44 |
llvm::Expected<llvm::DenseSet<SymbolID>> getIDs(IDRange IDs) { |
| 45 |
llvm::DenseSet<SymbolID> Result; |
| 46 |
for (const auto &ID : IDs) { |
| 47 |
auto SID = SymbolID::fromStr(StringRef(ID)); |
| 48 |
if (!SID) |
| 49 |
return SID.takeError(); |
| 50 |
Result.insert(*SID); |
| 51 |
} |
| 52 |
return Result; |
| 53 |
} |
| 54 |
|
| 55 |
} // namespace |
| 56 |
|
| 57 |
Marshaller::Marshaller(llvm::StringRef RemoteIndexRoot, |
| 58 |
llvm::StringRef LocalIndexRoot) |
| 59 |
: Strings(Arena) { |
| 60 |
llvm::StringRef PosixSeparator = get_separator(Style::posix); |
| 61 |
if (!RemoteIndexRoot.empty()) { |
| 62 |
assert(is_absolute(RemoteIndexRoot)); |
| 63 |
this->RemoteIndexRoot = convert_to_slash(RemoteIndexRoot, Style::windows); |
| 64 |
llvm::StringRef Path(this->RemoteIndexRoot); |
| 65 |
if (!is_separator(this->RemoteIndexRoot.back(), Style::posix)) |
| 66 |
this->RemoteIndexRoot += PosixSeparator; |
| 67 |
} |
| 68 |
if (!LocalIndexRoot.empty()) { |
| 69 |
assert(is_absolute(LocalIndexRoot)); |
| 70 |
this->LocalIndexRoot = convert_to_slash(LocalIndexRoot, Style::windows); |
| 71 |
llvm::StringRef Path(this->LocalIndexRoot); |
| 72 |
if (!is_separator(this->LocalIndexRoot.back(), Style::posix)) |
| 73 |
this->LocalIndexRoot += PosixSeparator; |
| 74 |
} |
| 75 |
assert(!RemoteIndexRoot.empty() || !LocalIndexRoot.empty()); |
| 76 |
} |
| 77 |
|
| 78 |
llvm::Expected<clangd::LookupRequest> |
| 79 |
Marshaller::fromProtobuf(const LookupRequest *Message) { |
| 80 |
clangd::LookupRequest Req; |
| 81 |
auto IDs = getIDs(Message->ids()); |
| 82 |
if (!IDs) |
| 83 |
return IDs.takeError(); |
| 84 |
Req.IDs = std::move(*IDs); |
| 85 |
return Req; |
| 86 |
} |
| 87 |
|
| 88 |
llvm::Expected<clangd::FuzzyFindRequest> |
| 89 |
Marshaller::fromProtobuf(const FuzzyFindRequest *Message) { |
| 90 |
assert(!RemoteIndexRoot.empty()); |
| 91 |
clangd::FuzzyFindRequest Result; |
| 92 |
Result.Query = Message->query(); |
| 93 |
for (const auto &Scope : Message->scopes()) |
| 94 |
Result.Scopes.push_back(Scope); |
| 95 |
Result.AnyScope = Message->any_scope(); |
| 96 |
if (Message->limit()) |
| 97 |
Result.Limit = Message->limit(); |
| 98 |
Result.RestrictForCodeCompletion = Message->restricted_for_code_completion(); |
| 99 |
for (const auto &Path : Message->proximity_paths()) { |
| 100 |
llvm::SmallString<256> LocalPath = llvm::StringRef(RemoteIndexRoot); |
| 101 |
append(LocalPath, Path); |
| 102 |
// FuzzyFindRequest requires proximity paths to have platform-native format |
| 103 |
// in order for SymbolIndex to process the query correctly. |
| 104 |
llvm::sys::path::native(LocalPath); |
| 105 |
Result.ProximityPaths.push_back(std::string(LocalPath)); |
| 106 |
} |
| 107 |
for (const auto &Type : Message->preferred_types()) |
| 108 |
Result.ProximityPaths.push_back(Type); |
| 109 |
return Result; |
| 110 |
} |
| 111 |
|
| 112 |
llvm::Expected<clangd::RefsRequest> |
| 113 |
Marshaller::fromProtobuf(const RefsRequest *Message) { |
| 114 |
clangd::RefsRequest Req; |
| 115 |
auto IDs = getIDs(Message->ids()); |
| 116 |
if (!IDs) |
| 117 |
return IDs.takeError(); |
| 118 |
Req.IDs = std::move(*IDs); |
| 119 |
if (Message->has_filter()) |
| 120 |
Req.Filter = static_cast<clangd::RefKind>(Message->filter()); |
| 121 |
else |
| 122 |
Req.Filter = clangd::RefKind::All; |
| 123 |
if (Message->limit()) |
| 124 |
Req.Limit = Message->limit(); |
| 125 |
Req.WantContainer = Message->want_container(); |
| 126 |
return Req; |
| 127 |
} |
| 128 |
|
| 129 |
llvm::Expected<clangd::RelationsRequest> |
| 130 |
Marshaller::fromProtobuf(const RelationsRequest *Message) { |
| 131 |
clangd::RelationsRequest Req; |
| 132 |
auto IDs = getIDs(Message->subjects()); |
| 133 |
if (!IDs) |
| 134 |
return IDs.takeError(); |
| 135 |
Req.Subjects = std::move(*IDs); |
| 136 |
if (!Message->has_predicate()) |
| 137 |
return error("RelationsRequest requires RelationKind predicate."); |
| 138 |
Req.Predicate = static_cast<RelationKind>(Message->predicate()); |
| 139 |
if (Message->limit()) |
| 140 |
Req.Limit = Message->limit(); |
| 141 |
return Req; |
| 142 |
} |
| 143 |
|
| 144 |
llvm::Expected<clangd::Symbol> Marshaller::fromProtobuf(const Symbol &Message) { |
| 145 |
if (!Message.has_info() || !Message.has_canonical_declaration()) |
| 146 |
return error("Missing info or declaration."); |
| 147 |
clangd::Symbol Result; |
| 148 |
auto ID = SymbolID::fromStr(Message.id()); |
| 149 |
if (!ID) |
| 150 |
return ID.takeError(); |
| 151 |
Result.ID = *ID; |
| 152 |
Result.SymInfo = fromProtobuf(Message.info()); |
| 153 |
Result.Name = Message.name(); |
| 154 |
Result.Scope = Message.scope(); |
| 155 |
if (Message.has_definition()) { |
| 156 |
auto Definition = fromProtobuf(Message.definition()); |
| 157 |
if (Definition) |
| 158 |
Result.Definition = *Definition; |
| 159 |
} |
| 160 |
auto Declaration = fromProtobuf(Message.canonical_declaration()); |
| 161 |
if (!Declaration) |
| 162 |
return Declaration.takeError(); |
| 163 |
Result.CanonicalDeclaration = *Declaration; |
| 164 |
Result.References = Message.references(); |
| 165 |
// Overwrite symbol origin: it's coming from remote index. |
| 166 |
Result.Origin = clangd::SymbolOrigin::Remote; |
| 167 |
Result.Signature = Message.signature(); |
| 168 |
Result.TemplateSpecializationArgs = Message.template_specialization_args(); |
| 169 |
Result.CompletionSnippetSuffix = Message.completion_snippet_suffix(); |
| 170 |
Result.Documentation = Message.documentation(); |
| 171 |
Result.ReturnType = Message.return_type(); |
| 172 |
Result.Type = Message.type(); |
| 173 |
for (const auto &Header : Message.headers()) { |
| 174 |
auto SerializedHeader = fromProtobuf(Header); |
| 175 |
if (!SerializedHeader) |
| 176 |
return SerializedHeader.takeError(); |
| 177 |
Result.IncludeHeaders.push_back(*SerializedHeader); |
| 178 |
} |
| 179 |
Result.Flags = static_cast<clangd::Symbol::SymbolFlag>(Message.flags()); |
| 180 |
return Result; |
| 181 |
} |
| 182 |
|
| 183 |
llvm::Expected<clangd::Ref> Marshaller::fromProtobuf(const Ref &Message) { |
| 184 |
if (!Message.has_location()) |
| 185 |
return error("Missing location."); |
| 186 |
clangd::Ref Result; |
| 187 |
auto Location = fromProtobuf(Message.location()); |
| 188 |
if (!Location) |
| 189 |
return Location.takeError(); |
| 190 |
Result.Location = *Location; |
| 191 |
Result.Kind = static_cast<RefKind>(Message.kind()); |
| 192 |
return Result; |
| 193 |
} |
| 194 |
|
| 195 |
llvm::Expected<std::pair<clangd::SymbolID, clangd::Symbol>> |
| 196 |
Marshaller::fromProtobuf(const Relation &Message) { |
| 197 |
auto SubjectID = SymbolID::fromStr(Message.subject_id()); |
| 198 |
if (!SubjectID) |
| 199 |
return SubjectID.takeError(); |
| 200 |
if (!Message.has_object()) |
| 201 |
return error("Missing Object."); |
| 202 |
auto Object = fromProtobuf(Message.object()); |
| 203 |
if (!Object) |
| 204 |
return Object.takeError(); |
| 205 |
return std::make_pair(*SubjectID, *Object); |
| 206 |
} |
| 207 |
|
| 208 |
LookupRequest Marshaller::toProtobuf(const clangd::LookupRequest &From) { |
| 209 |
LookupRequest RPCRequest; |
| 210 |
for (const auto &SymbolID : From.IDs) |
| 211 |
RPCRequest.add_ids(SymbolID.str()); |
| 212 |
return RPCRequest; |
| 213 |
} |
| 214 |
|
| 215 |
FuzzyFindRequest Marshaller::toProtobuf(const clangd::FuzzyFindRequest &From) { |
| 216 |
assert(!LocalIndexRoot.empty()); |
| 217 |
FuzzyFindRequest RPCRequest; |
| 218 |
RPCRequest.set_query(From.Query); |
| 219 |
for (const auto &Scope : From.Scopes) |
| 220 |
RPCRequest.add_scopes(Scope); |
| 221 |
RPCRequest.set_any_scope(From.AnyScope); |
| 222 |
if (From.Limit) |
| 223 |
RPCRequest.set_limit(*From.Limit); |
| 224 |
RPCRequest.set_restricted_for_code_completion(From.RestrictForCodeCompletion); |
| 225 |
for (const auto &Path : From.ProximityPaths) { |
| 226 |
llvm::SmallString<256> RelativePath = llvm::StringRef(Path); |
| 227 |
if (replace_path_prefix(RelativePath, LocalIndexRoot, "")) |
| 228 |
RPCRequest.add_proximity_paths( |
| 229 |
convert_to_slash(RelativePath, Style::windows)); |
| 230 |
} |
| 231 |
for (const auto &Type : From.PreferredTypes) |
| 232 |
RPCRequest.add_preferred_types(Type); |
| 233 |
return RPCRequest; |
| 234 |
} |
| 235 |
|
| 236 |
RefsRequest Marshaller::toProtobuf(const clangd::RefsRequest &From) { |
| 237 |
RefsRequest RPCRequest; |
| 238 |
for (const auto &ID : From.IDs) |
| 239 |
RPCRequest.add_ids(ID.str()); |
| 240 |
RPCRequest.set_filter(static_cast<uint32_t>(From.Filter)); |
| 241 |
if (From.Limit) |
| 242 |
RPCRequest.set_limit(*From.Limit); |
| 243 |
RPCRequest.set_want_container(From.WantContainer); |
| 244 |
return RPCRequest; |
| 245 |
} |
| 246 |
|
| 247 |
RelationsRequest Marshaller::toProtobuf(const clangd::RelationsRequest &From) { |
| 248 |
RelationsRequest RPCRequest; |
| 249 |
for (const auto &ID : From.Subjects) |
| 250 |
RPCRequest.add_subjects(ID.str()); |
| 251 |
RPCRequest.set_predicate(static_cast<uint32_t>(From.Predicate)); |
| 252 |
if (From.Limit) |
| 253 |
RPCRequest.set_limit(*From.Limit); |
| 254 |
return RPCRequest; |
| 255 |
} |
| 256 |
|
| 257 |
llvm::Expected<Symbol> Marshaller::toProtobuf(const clangd::Symbol &From) { |
| 258 |
Symbol Result; |
| 259 |
Result.set_id(From.ID.str()); |
| 260 |
*Result.mutable_info() = toProtobuf(From.SymInfo); |
| 261 |
Result.set_name(From.Name.str()); |
| 262 |
if (*From.Definition.FileURI) { |
| 263 |
auto Definition = toProtobuf(From.Definition); |
| 264 |
if (!Definition) |
| 265 |
return Definition.takeError(); |
| 266 |
*Result.mutable_definition() = *Definition; |
| 267 |
} |
| 268 |
Result.set_scope(From.Scope.str()); |
| 269 |
auto Declaration = toProtobuf(From.CanonicalDeclaration); |
| 270 |
if (!Declaration) |
| 271 |
return Declaration.takeError(); |
| 272 |
*Result.mutable_canonical_declaration() = *Declaration; |
| 273 |
Result.set_references(From.References); |
| 274 |
Result.set_signature(From.Signature.str()); |
| 275 |
Result.set_template_specialization_args( |
| 276 |
From.TemplateSpecializationArgs.str()); |
| 277 |
Result.set_completion_snippet_suffix(From.CompletionSnippetSuffix.str()); |
| 278 |
Result.set_documentation(From.Documentation.str()); |
| 279 |
Result.set_return_type(From.ReturnType.str()); |
| 280 |
Result.set_type(From.Type.str()); |
| 281 |
for (const auto &Header : From.IncludeHeaders) { |
| 282 |
auto Serialized = toProtobuf(Header); |
| 283 |
if (!Serialized) |
| 284 |
return Serialized.takeError(); |
| 285 |
auto *NextHeader = Result.add_headers(); |
| 286 |
*NextHeader = *Serialized; |
| 287 |
} |
| 288 |
Result.set_flags(static_cast<uint32_t>(From.Flags)); |
| 289 |
return Result; |
| 290 |
} |
| 291 |
|
| 292 |
llvm::Expected<Ref> Marshaller::toProtobuf(const clangd::Ref &From) { |
| 293 |
Ref Result; |
| 294 |
Result.set_kind(static_cast<uint32_t>(From.Kind)); |
| 295 |
auto Location = toProtobuf(From.Location); |
| 296 |
if (!Location) |
| 297 |
return Location.takeError(); |
| 298 |
*Result.mutable_location() = *Location; |
| 299 |
return Result; |
| 300 |
} |
| 301 |
|
| 302 |
llvm::Expected<Relation> Marshaller::toProtobuf(const clangd::SymbolID &Subject, |
| 303 |
const clangd::Symbol &Object) { |
| 304 |
Relation Result; |
| 305 |
*Result.mutable_subject_id() = Subject.str(); |
| 306 |
auto SerializedObject = toProtobuf(Object); |
| 307 |
if (!SerializedObject) |
| 308 |
return SerializedObject.takeError(); |
| 309 |
*Result.mutable_object() = *SerializedObject; |
| 310 |
return Result; |
| 311 |
} |
| 312 |
|
| 313 |
llvm::Expected<std::string> |
| 314 |
Marshaller::relativePathToURI(llvm::StringRef RelativePath) { |
| 315 |
assert(!LocalIndexRoot.empty()); |
| 316 |
assert(RelativePath == convert_to_slash(RelativePath)); |
| 317 |
if (RelativePath.empty()) |
| 318 |
return error("Empty relative path."); |
| 319 |
if (is_absolute(RelativePath, Style::posix)) |
| 320 |
return error("RelativePath '{0}' is absolute.", RelativePath); |
| 321 |
llvm::SmallString<256> FullPath = llvm::StringRef(LocalIndexRoot); |
| 322 |
append(FullPath, RelativePath); |
| 323 |
auto Result = URI::createFile(FullPath); |
| 324 |
return Result.toString(); |
| 325 |
} |
| 326 |
|
| 327 |
llvm::Expected<std::string> Marshaller::uriToRelativePath(llvm::StringRef URI) { |
| 328 |
assert(!RemoteIndexRoot.empty()); |
| 329 |
auto ParsedURI = URI::parse(URI); |
| 330 |
if (!ParsedURI) |
| 331 |
return ParsedURI.takeError(); |
| 332 |
if (ParsedURI->scheme() != "file") |
| 333 |
return error("Can not use URI schemes other than file, given: '{0}'.", URI); |
| 334 |
llvm::SmallString<256> Result = ParsedURI->body(); |
| 335 |
llvm::StringRef Path(Result); |
| 336 |
// Check for Windows paths (URI=file:///X:/path => Body=/X:/path) |
| 337 |
if (is_absolute(Path.substr(1), Style::windows)) |
| 338 |
Result = Path.drop_front(); |
| 339 |
if (!replace_path_prefix(Result, RemoteIndexRoot, "")) |
| 340 |
return error("File path '{0}' doesn't start with '{1}'.", Result.str(), |
| 341 |
RemoteIndexRoot); |
| 342 |
assert(Result == convert_to_slash(Result, Style::windows)); |
| 343 |
return std::string(Result); |
| 344 |
} |
| 345 |
|
| 346 |
clangd::SymbolLocation::Position |
| 347 |
Marshaller::fromProtobuf(const Position &Message) { |
| 348 |
clangd::SymbolLocation::Position Result; |
| 349 |
Result.setColumn(static_cast<uint32_t>(Message.column())); |
| 350 |
Result.setLine(static_cast<uint32_t>(Message.line())); |
| 351 |
return Result; |
| 352 |
} |
| 353 |
|
| 354 |
Position |
| 355 |
Marshaller::toProtobuf(const clangd::SymbolLocation::Position &Position) { |
| 356 |
remote::Position Result; |
| 357 |
Result.set_column(Position.column()); |
| 358 |
Result.set_line(Position.line()); |
| 359 |
return Result; |
| 360 |
} |
| 361 |
|
| 362 |
clang::index::SymbolInfo Marshaller::fromProtobuf(const SymbolInfo &Message) { |
| 363 |
clang::index::SymbolInfo Result; |
| 364 |
Result.Kind = static_cast<clang::index::SymbolKind>(Message.kind()); |
| 365 |
Result.SubKind = static_cast<clang::index::SymbolSubKind>(Message.subkind()); |
| 366 |
Result.Lang = static_cast<clang::index::SymbolLanguage>(Message.language()); |
| 367 |
Result.Properties = |
| 368 |
static_cast<clang::index::SymbolPropertySet>(Message.properties()); |
| 369 |
return Result; |
| 370 |
} |
| 371 |
|
| 372 |
SymbolInfo Marshaller::toProtobuf(const clang::index::SymbolInfo &Info) { |
| 373 |
SymbolInfo Result; |
| 374 |
Result.set_kind(static_cast<uint32_t>(Info.Kind)); |
| 375 |
Result.set_subkind(static_cast<uint32_t>(Info.SubKind)); |
| 376 |
Result.set_language(static_cast<uint32_t>(Info.Lang)); |
| 377 |
Result.set_properties(static_cast<uint32_t>(Info.Properties)); |
| 378 |
return Result; |
| 379 |
} |
| 380 |
|
| 381 |
llvm::Expected<clangd::SymbolLocation> |
| 382 |
Marshaller::fromProtobuf(const SymbolLocation &Message) { |
| 383 |
clangd::SymbolLocation Location; |
| 384 |
auto URIString = relativePathToURI(Message.file_path()); |
| 385 |
if (!URIString) |
| 386 |
return URIString.takeError(); |
| 387 |
Location.FileURI = Strings.save(*URIString).begin(); |
| 388 |
Location.Start = fromProtobuf(Message.start()); |
| 389 |
Location.End = fromProtobuf(Message.end()); |
| 390 |
return Location; |
| 391 |
} |
| 392 |
|
| 393 |
llvm::Expected<SymbolLocation> |
| 394 |
Marshaller::toProtobuf(const clangd::SymbolLocation &Location) { |
| 395 |
remote::SymbolLocation Result; |
| 396 |
auto RelativePath = uriToRelativePath(Location.FileURI); |
| 397 |
if (!RelativePath) |
| 398 |
return RelativePath.takeError(); |
| 399 |
*Result.mutable_file_path() = *RelativePath; |
| 400 |
*Result.mutable_start() = toProtobuf(Location.Start); |
| 401 |
*Result.mutable_end() = toProtobuf(Location.End); |
| 402 |
return Result; |
| 403 |
} |
| 404 |
|
| 405 |
llvm::Expected<HeaderWithReferences> Marshaller::toProtobuf( |
| 406 |
const clangd::Symbol::IncludeHeaderWithReferences &IncludeHeader) { |
| 407 |
HeaderWithReferences Result; |
| 408 |
Result.set_references(IncludeHeader.References); |
| 409 |
Result.set_supported_directives(IncludeHeader.SupportedDirectives); |
| 410 |
const std::string Header = IncludeHeader.IncludeHeader.str(); |
| 411 |
if (isLiteralInclude(Header)) { |
| 412 |
Result.set_header(Header); |
| 413 |
return Result; |
| 414 |
} |
| 415 |
auto RelativePath = uriToRelativePath(Header); |
| 416 |
if (!RelativePath) |
| 417 |
return RelativePath.takeError(); |
| 418 |
Result.set_header(*RelativePath); |
| 419 |
return Result; |
| 420 |
} |
| 421 |
|
| 422 |
llvm::Expected<clangd::Symbol::IncludeHeaderWithReferences> |
| 423 |
Marshaller::fromProtobuf(const HeaderWithReferences &Message) { |
| 424 |
std::string Header = Message.header(); |
| 425 |
if (!isLiteralInclude(Header)) { |
| 426 |
auto URIString = relativePathToURI(Header); |
| 427 |
if (!URIString) |
| 428 |
return URIString.takeError(); |
| 429 |
Header = *URIString; |
| 430 |
} |
| 431 |
auto Directives = clangd::Symbol::IncludeDirective::Include; |
| 432 |
if (Message.has_supported_directives()) |
| 433 |
Directives = static_cast<clangd::Symbol::IncludeDirective>( |
| 434 |
Message.supported_directives()); |
| 435 |
return clangd::Symbol::IncludeHeaderWithReferences{ |
| 436 |
Strings.save(Header), Message.references(), Directives}; |
| 437 |
} |
| 438 |
|
| 439 |
} // namespace remote |
| 440 |
} // namespace clangd |
| 441 |
} // namespace clang |