[clangd] Extract FsPath from file:// uri

[stanionascu]

Summary

rfc8089#appendix-E.2 specifies that paths can begin with a drive letter e.g. as file:///c:/.
In this case just consuming front file:// is not enough and the 3rd slash must be consumed to produce a valid path on windows.

The patch introduce a generic way of converting an uri to a filesystem path and back.

[krasimir]

clangd/ASTManager.cpp

166 ↗

(On Diff #93154)

I think we should rename the Uri parameter here to File.

178 ↗

(On Diff #93154)

I think we should rename the Uri parameter here to File.

clangd/Protocol.cpp

61 ↗

(On Diff #93154)

Hm, seems to me that here the uri should be kept as-is and the clients of Result.uri should convert it to file when appropriate. Otherwise it's confusing.

167 ↗

(On Diff #93154)

Same thing: I think that the clients should be responsible of converting Result.uri to a filename.

clangd/Protocol.h

32 ↗

(On Diff #93154)

It's a little confusing: the parse method turns an uri to a file and the unparse method does the opposite. Maybe we should use more descriptive names, like uriToFile and fileToUri. This does not seem to be inconsistent with the rest of the protocol since the protocol only cares about uri-s, and file-s are an implementation detail of clangd I guess.

clangd/clients/clangd-vscode/src/extension.ts

28 ↗

(On Diff #93154)

By the way, what does this do? I'm not a typescript vs code guru.

[stanionascu]

Refactored URI handling to make it more explicit, also updated the parts which expect a File parameter and not an URI.

[stanionascu]

clangd/Protocol.cpp

61 ↗

(On Diff #93154)

Implemented the "URI::parse" to store both representations.

clangd/Protocol.h

32 ↗

(On Diff #93154)

2nd try now, instead of actually storing a string based URI, store the object which both representations (uri and file).

clangd/clients/clangd-vscode/src/extension.ts

28 ↗

(On Diff #93154)

Extended the FIXME, with the description, e.g. when vscode (on windows) sends the uri to clangd, it's represented as "file:///c%3A/path/tofile" which leads to:

• incorrect detection of the compilation database location.
• cannot find the actual unit in the database.

uri.toString(true) - skips the percent encoding and sends the uri parameter to clangd as "file:///c:/path/tofile"

[krasimir]

Looks good!

[stanionascu]

Thank you for the review!

If there are no other comments/suggestions, would be great if someone would merge it as I'm lacking the permission to do so.

clang-tools-extra/trunk/clangd/ASTManager.h

 
 namespace clangd {
 
 class ASTManager : public DocumentStoreListener {
 public:
   ASTManager(JSONOutput &Output, DocumentStore &Store, bool RunSynchronously);
   ~ASTManager() override;
 
-  void onDocumentAdd(StringRef Uri) override;
+  void onDocumentAdd(StringRef File) override;
   // FIXME: Implement onDocumentRemove
 
   /// Get code completions at a specified \p Line and \p Column in \p File.
   ///
   /// This function is thread-safe and returns completion items that own the
   /// data they contain.
   std::vector<CompletionItem> codeComplete(StringRef File, unsigned Line,
                                            unsigned Column);

 private:
   JSONOutput &Output;
   DocumentStore &Store;
 
   // Set to true if requests should block instead of being processed
   // asynchronously.
   bool RunSynchronously;
 
-  /// Loads a compilation database for URI. May return nullptr if it fails. The
+  /// Loads a compilation database for File. May return nullptr if it fails. The
   /// database is cached for subsequent accesses.
   clang::tooling::CompilationDatabase *
-  getOrCreateCompilationDatabaseForFile(StringRef Uri);
-  // Creates a new ASTUnit for the document at Uri.
+  getOrCreateCompilationDatabaseForFile(StringRef File);
+  // Creates a new ASTUnit for the document at File.
   // FIXME: This calls chdir internally, which is thread unsafe.
   std::unique_ptr<clang::ASTUnit>
-  createASTUnitForFile(StringRef Uri, const DocumentStore &Docs);
+  createASTUnitForFile(StringRef File, const DocumentStore &Docs);
 
   void runWorker();
   void parseFileAndPublishDiagnostics(StringRef File);
 
   /// Clang objects.
 
-  /// A map from Uri-s to ASTUnit-s. Guarded by \c ASTLock. ASTUnit-s are used
+  /// A map from File-s to ASTUnit-s. Guarded by \c ASTLock. ASTUnit-s are used
   /// for generating diagnostics and fix-it-s asynchronously by the worker
   /// thread and synchronously for code completion.
   ///
   /// TODO(krasimir): code completion should always have priority over parsing
   /// for diagnostics.
   llvm::StringMap<std::unique_ptr<clang::ASTUnit>> ASTs;
   /// A lock for access to the map \c ASTs.
   std::mutex ASTLock;

clang-tools-extra/trunk/clangd/ASTManager.cpp

 /// Retrieve a copy of the contents of every file in the store, for feeding into
 /// ASTUnit.
 static std::vector<ASTUnit::RemappedFile>
 getRemappedFiles(const DocumentStore &Docs) {
   // FIXME: Use VFS instead. This would allow us to get rid of the chdir below.
   std::vector<ASTUnit::RemappedFile> RemappedFiles;
   for (const auto &P : Docs.getAllDocuments()) {
     StringRef FileName = P.first;
-    FileName.consume_front("file://");
     RemappedFiles.push_back(ASTUnit::RemappedFile(
         FileName,
         llvm::MemoryBuffer::getMemBufferCopy(P.second, FileName).release()));
   }
   return RemappedFiles;
 }
 
 /// Convert from clang diagnostic level to LSP severity.
// Put FixIts into place.
     std::lock_guard<std::mutex> Guard(FixItLock);
     FixIts = std::move(LocalFixIts);
   }
 
   if (!Diagnostics.empty())
     Diagnostics.pop_back(); // Drop trailing comma.
   Output.writeMessage(
       R"({"jsonrpc":"2.0","method":"textDocument/publishDiagnostics","params":{"uri":")" +
-      File + R"(","diagnostics":[)" + Diagnostics + R"(]}})");
+      URI::fromFile(File).uri + R"(","diagnostics":[)" + Diagnostics + R"(]}})");
 }
 
 ASTManager::~ASTManager() {
   {
     std::lock_guard<std::mutex> Guard(RequestLock);
     // Wake up the clang worker thread, then exit.
     Done = true;
     ClangRequestCV.notify_one();
   }
   ClangWorker.join();
 }
 
-void ASTManager::onDocumentAdd(StringRef Uri) {
+void ASTManager::onDocumentAdd(StringRef File) {
   if (RunSynchronously) {
-    parseFileAndPublishDiagnostics(Uri);
+    parseFileAndPublishDiagnostics(File);
     return;
   }
   std::lock_guard<std::mutex> Guard(RequestLock);
   // Currently we discard all pending requests and just enqueue the latest one.
   RequestQueue.clear();
-  RequestQueue.push_back(Uri);
+  RequestQueue.push_back(File);
   ClangRequestCV.notify_one();
 }
 
 tooling::CompilationDatabase *
-ASTManager::getOrCreateCompilationDatabaseForFile(StringRef Uri) {
-  auto &I = CompilationDatabases[Uri];
+ASTManager::getOrCreateCompilationDatabaseForFile(StringRef File) {
+  auto &I = CompilationDatabases[File];
   if (I)
     return I.get();
 
-  Uri.consume_front("file://");
-
   std::string Error;
-  I = tooling::CompilationDatabase::autoDetectFromSource(Uri, Error);
+  I = tooling::CompilationDatabase::autoDetectFromSource(File, Error);
   Output.log("Failed to load compilation database: " + Twine(Error) + "\n");
   return I.get();
 }
 
 std::unique_ptr<clang::ASTUnit>
-ASTManager::createASTUnitForFile(StringRef Uri, const DocumentStore &Docs) {
+ASTManager::createASTUnitForFile(StringRef File, const DocumentStore &Docs) {
   tooling::CompilationDatabase *CDB =
-      getOrCreateCompilationDatabaseForFile(Uri);
+      getOrCreateCompilationDatabaseForFile(File);
 
-  Uri.consume_front("file://");
   std::vector<tooling::CompileCommand> Commands;
 
   if (CDB) {
-    Commands = CDB->getCompileCommands(Uri);
+    Commands = CDB->getCompileCommands(File);
     // chdir. This is thread hostile.
     if (!Commands.empty())
       llvm::sys::fs::set_current_path(Commands.front().Directory);
   }
   if (Commands.empty()) {
     // Add a fake command line if we know nothing.
     Commands.push_back(tooling::CompileCommand(
-        llvm::sys::path::parent_path(Uri), llvm::sys::path::filename(Uri),
-        {"clang", "-fsyntax-only", Uri.str()}, ""));
+        llvm::sys::path::parent_path(File), llvm::sys::path::filename(File),
+        {"clang", "-fsyntax-only", File.str()}, ""));
   }
 
   // Inject the resource dir.
   // FIXME: Don't overwrite it if it's already there.
   static int Dummy; // Just an address in this process.
   std::string ResourceDir =
       CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
   Commands.front().CommandLine.push_back("-resource-dir=" + ResourceDir);
public:
   GlobalCodeCompletionAllocator &getAllocator() override { return *Allocator; }
 
   CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
 };
 
 } // namespace
 
 std::vector<CompletionItem>
-ASTManager::codeComplete(StringRef Uri, unsigned Line, unsigned Column) {
+ASTManager::codeComplete(StringRef File, unsigned Line, unsigned Column) {
   CodeCompleteOptions CCO;
   CCO.IncludeBriefComments = 1;
   // This is where code completion stores dirty buffers. Need to free after
   // completion.
   SmallVector<const llvm::MemoryBuffer *, 4> OwnedBuffers;
   SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
   IntrusiveRefCntPtr<DiagnosticsEngine> DiagEngine(
       new DiagnosticsEngine(new DiagnosticIDs, new DiagnosticOptions));
   std::vector<CompletionItem> Items;
   CompletionItemsCollector Collector(&Items, CCO);
   std::lock_guard<std::mutex> Guard(ASTLock);
-  auto &Unit = ASTs[Uri];
+  auto &Unit = ASTs[File];
   if (!Unit)
-    Unit = createASTUnitForFile(Uri, this->Store);
+    Unit = createASTUnitForFile(File, this->Store);
   if (!Unit)
     return {};
   IntrusiveRefCntPtr<SourceManager> SourceMgr(
       new SourceManager(*DiagEngine, Unit->getFileManager()));
-  StringRef File(Uri);
-  File.consume_front("file://");
   // CodeComplete seems to require fresh LangOptions.
   LangOptions LangOpts = Unit->getLangOpts();
   // The language server protocol uses zero-based line and column numbers.
   // The clang code completion uses one-based numbers.
   Unit->CodeComplete(File, Line + 1, Column + 1, getRemappedFiles(this->Store),
                      CCO.IncludeMacros, CCO.IncludeCodePatterns,
                      CCO.IncludeBriefComments, Collector, PCHs, *DiagEngine,
                      LangOpts, *SourceMgr, Unit->getFileManager(),
                      StoredDiagnostics, OwnedBuffers);
   for (const llvm::MemoryBuffer *Buffer : OwnedBuffers)
     delete Buffer;
   return Items;
 }

clang-tools-extra/trunk/clangd/DocumentStore.h

 #include <vector>
 
 namespace clang {
 namespace clangd {
 class DocumentStore;
 
 struct DocumentStoreListener {
   virtual ~DocumentStoreListener() = default;
-  virtual void onDocumentAdd(StringRef Uri) {}
-  virtual void onDocumentRemove(StringRef Uri) {}
+  virtual void onDocumentAdd(StringRef File) {}
+  virtual void onDocumentRemove(StringRef File) {}
 };
 
-/// A container for files opened in a workspace, addressed by URI. The contents
+/// A container for files opened in a workspace, addressed by File. The contents
 /// are owned by the DocumentStore.
 class DocumentStore {
 public:
   /// Add a document to the store. Overwrites existing contents.
-  void addDocument(StringRef Uri, StringRef Text) {
+  void addDocument(StringRef File, StringRef Text) {
     {
       std::lock_guard<std::mutex> Guard(DocsMutex);
-      Docs[Uri] = Text;
+      Docs[File] = Text;
     }
     for (const auto &Listener : Listeners)
-      Listener->onDocumentAdd(Uri);
+      Listener->onDocumentAdd(File);
   }
   /// Delete a document from the store.
-  void removeDocument(StringRef Uri) {
+  void removeDocument(StringRef File) {
     {
       std::lock_guard<std::mutex> Guard(DocsMutex);
-      Docs.erase(Uri);
+      Docs.erase(File);
     }
     for (const auto &Listener : Listeners)
-      Listener->onDocumentRemove(Uri);
+      Listener->onDocumentRemove(File);
   }
   /// Retrieve a document from the store. Empty string if it's unknown.
   ///
   /// This function is thread-safe. It returns a copy to avoid handing out
   /// references to unguarded data.
-  std::string getDocument(StringRef Uri) const {
+  std::string getDocument(StringRef File) const {
     // FIXME: This could be a reader lock.
     std::lock_guard<std::mutex> Guard(DocsMutex);
-    return Docs.lookup(Uri);
+    return Docs.lookup(File);
   }
 
   /// Add a listener. Does not take ownership.
   void addListener(DocumentStoreListener *DSL) { Listeners.push_back(DSL); }
 
   /// Get name and constents of all documents in this store.
   ///
   /// This function is thread-safe. It returns a copies to avoid handing out

clang-tools-extra/trunk/clangd/Protocol.h

 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/YAMLParser.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
+struct URI {
+  std::string uri;
+  std::string file;
+
+  static URI fromUri(llvm::StringRef uri);
+  static URI fromFile(llvm::StringRef file);
+
+  static URI parse(llvm::yaml::ScalarNode *Param);
+  static std::string unparse(const URI &U);
+};
+
 struct TextDocumentIdentifier {
   /// The text document's URI.
-  std::string uri;
+  URI uri;
 
   static llvm::Optional<TextDocumentIdentifier>
   parse(llvm::yaml::MappingNode *Params);
 };
 
 struct Position {
   /// Line position in a document (zero-based).
   int line;
struct TextEdit {
   std::string newText;
 
   static llvm::Optional<TextEdit> parse(llvm::yaml::MappingNode *Params);
   static std::string unparse(const TextEdit &P);
 };
 
 struct TextDocumentItem {
   /// The text document's URI.
-  std::string uri;
+  URI uri;
 
   /// The text document's language identifier.
   std::string languageId;
 
   /// The version number of this document (it will strictly increase after each
   int version;
 
   /// The content of the opened text document.
struct CompletionItem {
   /// Note: The range of the edit must be a single line range and it must
   /// contain the position at which completion has been requested.
   llvm::Optional<TextEdit> textEdit;
 
   /// An optional array of additional text edits that are applied when selecting
   /// this completion. Edits must not overlap with the main edit nor with
   /// themselves.
   std::vector<TextEdit> additionalTextEdits;
-  
   // TODO(krasimir): The following optional fields defined by the language
   // server protocol are unsupported:
   //
   // command?: Command - An optional command that is executed *after* inserting
   //                     this completion.
   //
   // data?: any - A data entry field that is preserved on a completion item
   //              between a completion and a completion resolve request.
   static std::string unparse(const CompletionItem &P);
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/trunk/clangd/Protocol.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "Protocol.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Path.h"
 using namespace clang::clangd;
 
+
+URI URI::fromUri(llvm::StringRef uri) {
+  URI Result;
+  Result.uri = uri;
+  uri.consume_front("file://");
+  // For Windows paths e.g. /X:
+  if (uri.size() > 2 && uri[0] == '/' && uri[2] == ':')
+    uri.consume_front("/");
+  // Make sure that file paths are in native separators
+  Result.file = llvm::sys::path::convert_to_slash(uri);
+  return Result;
+}
+
+URI URI::fromFile(llvm::StringRef file) {
+  using namespace llvm::sys;
+  URI Result;
+  Result.file = file;
+  Result.uri = "file://";
+  // For Windows paths e.g. X:
+  if (file.size() > 1 && file[1] == ':')
+    Result.uri += "/";
+  // Make sure that uri paths are with posix separators
+  Result.uri += path::convert_to_slash(file, path::Style::posix);
+  return Result;
+}
+
+URI URI::parse(llvm::yaml::ScalarNode *Param) {
+  llvm::SmallString<10> Storage;
+  return URI::fromUri(Param->getValue(Storage));
+}
+
+std::string URI::unparse(const URI &U) {
+  return U.uri;
+}
+
 llvm::Optional<TextDocumentIdentifier>
 TextDocumentIdentifier::parse(llvm::yaml::MappingNode *Params) {
   TextDocumentIdentifier Result;
   for (auto &NextKeyValue : *Params) {
     auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(NextKeyValue.getKey());
     if (!KeyString)
       return llvm::None;
 
     llvm::SmallString<10> KeyStorage;
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
-    llvm::SmallString<10> Storage;
     if (KeyValue == "uri") {
-      Result.uri = Value->getValue(Storage);
+      Result.uri = URI::parse(Value);
     } else if (KeyValue == "version") {
       // FIXME: parse version, but only for VersionedTextDocumentIdentifiers.
     } else {
       return llvm::None;
     }
   }
   return Result;
 }
for (auto &NextKeyValue : *Params) {
     StringRef KeyValue = KeyString->getValue(KeyStorage);
     auto *Value =
         dyn_cast_or_null<llvm::yaml::ScalarNode>(NextKeyValue.getValue());
     if (!Value)
       return llvm::None;
 
     llvm::SmallString<10> Storage;
     if (KeyValue == "uri") {
-      Result.uri = Value->getValue(Storage);
+      Result.uri = URI::parse(Value);
     } else if (KeyValue == "languageId") {
       Result.languageId = Value->getValue(Storage);
     } else if (KeyValue == "version") {
       long long Val;
       if (llvm::getAsSignedInteger(Value->getValue(Storage), 0, Val))
         return llvm::None;
       Result.version = Val;
     } else if (KeyValue == "text") {

clang-tools-extra/trunk/clangd/ProtocolHandlers.cpp

 
 void TextDocumentDidOpenHandler::handleNotification(
     llvm::yaml::MappingNode *Params) {
   auto DOTDP = DidOpenTextDocumentParams::parse(Params);
   if (!DOTDP) {
     Output.log("Failed to decode DidOpenTextDocumentParams!\n");
     return;
   }
-  Store.addDocument(DOTDP->textDocument.uri, DOTDP->textDocument.text);
+  Store.addDocument(DOTDP->textDocument.uri.file, DOTDP->textDocument.text);
 }
 
 void TextDocumentDidChangeHandler::handleNotification(
     llvm::yaml::MappingNode *Params) {
   auto DCTDP = DidChangeTextDocumentParams::parse(Params);
   if (!DCTDP || DCTDP->contentChanges.size() != 1) {
     Output.log("Failed to decode DidChangeTextDocumentParams!\n");
     return;
   }
   // We only support full syncing right now.
-  Store.addDocument(DCTDP->textDocument.uri, DCTDP->contentChanges[0].text);
+  Store.addDocument(DCTDP->textDocument.uri.file, DCTDP->contentChanges[0].text);
 }
 
 /// Turn a [line, column] pair into an offset in Code.
 static size_t positionToOffset(StringRef Code, Position P) {
   size_t Offset = 0;
   for (int I = 0; I != P.line; ++I) {
     // FIXME: \r\n
     // FIXME: UTF-8
static std::string replacementsToEdits(StringRef Code, const T &Replacements) {
   return Edits;
 }
 
 static std::string formatCode(StringRef Code, StringRef Filename,
                               ArrayRef<tooling::Range> Ranges, StringRef ID) {
   // Call clang-format.
   // FIXME: Don't ignore style.
   format::FormatStyle Style = format::getLLVMStyle();
-  // On windows FileManager doesn't like file://. Just strip it, clang-format
-  // doesn't need it.
-  Filename.consume_front("file://");
   tooling::Replacements Replacements =
       format::reformat(Style, Code, Ranges, Filename);
 
   std::string Edits = replacementsToEdits(Code, Replacements);
   return R"({"jsonrpc":"2.0","id":)" + ID.str() +
          R"(,"result":[)" + Edits + R"(]})";
 }
 
 void TextDocumentRangeFormattingHandler::handleMethod(
     llvm::yaml::MappingNode *Params, StringRef ID) {
   auto DRFP = DocumentRangeFormattingParams::parse(Params);
   if (!DRFP) {
     Output.log("Failed to decode DocumentRangeFormattingParams!\n");
     return;
   }
 
-  std::string Code = Store.getDocument(DRFP->textDocument.uri);
+  std::string Code = Store.getDocument(DRFP->textDocument.uri.file);
 
   size_t Begin = positionToOffset(Code, DRFP->range.start);
   size_t Len = positionToOffset(Code, DRFP->range.end) - Begin;
 
-  writeMessage(formatCode(Code, DRFP->textDocument.uri,
+  writeMessage(formatCode(Code, DRFP->textDocument.uri.file,
                           {clang::tooling::Range(Begin, Len)}, ID));
 }
 
 void TextDocumentOnTypeFormattingHandler::handleMethod(
     llvm::yaml::MappingNode *Params, StringRef ID) {
   auto DOTFP = DocumentOnTypeFormattingParams::parse(Params);
   if (!DOTFP) {
     Output.log("Failed to decode DocumentOnTypeFormattingParams!\n");
     return;
   }
 
   // Look for the previous opening brace from the character position and format
   // starting from there.
-  std::string Code = Store.getDocument(DOTFP->textDocument.uri);
+  std::string Code = Store.getDocument(DOTFP->textDocument.uri.file);
   size_t CursorPos = positionToOffset(Code, DOTFP->position);
   size_t PreviousLBracePos = StringRef(Code).find_last_of('{', CursorPos);
   if (PreviousLBracePos == StringRef::npos)
     PreviousLBracePos = CursorPos;
   size_t Len = 1 + CursorPos - PreviousLBracePos;
 
-  writeMessage(formatCode(Code, DOTFP->textDocument.uri,
+  writeMessage(formatCode(Code, DOTFP->textDocument.uri.file,
                           {clang::tooling::Range(PreviousLBracePos, Len)}, ID));
 }
 
 void TextDocumentFormattingHandler::handleMethod(
     llvm::yaml::MappingNode *Params, StringRef ID) {
   auto DFP = DocumentFormattingParams::parse(Params);
   if (!DFP) {
     Output.log("Failed to decode DocumentFormattingParams!\n");
     return;
   }
 
   // Format everything.
-  std::string Code = Store.getDocument(DFP->textDocument.uri);
-  writeMessage(formatCode(Code, DFP->textDocument.uri,
+  std::string Code = Store.getDocument(DFP->textDocument.uri.file);
+  writeMessage(formatCode(Code, DFP->textDocument.uri.file,
                           {clang::tooling::Range(0, Code.size())}, ID));
 }
 
 void CodeActionHandler::handleMethod(llvm::yaml::MappingNode *Params,
                                      StringRef ID) {
   auto CAP = CodeActionParams::parse(Params);
   if (!CAP) {
     Output.log("Failed to decode CodeActionParams!\n");
     return;
   }
 
   // We provide a code action for each diagnostic at the requested location
   // which has FixIts available.
-  std::string Code = AST.getStore().getDocument(CAP->textDocument.uri);
+  std::string Code = AST.getStore().getDocument(CAP->textDocument.uri.file);
   std::string Commands;
   for (Diagnostic &D : CAP->context.diagnostics) {
     std::vector<clang::tooling::Replacement> Fixes = AST.getFixIts(D);
     std::string Edits = replacementsToEdits(Code, Fixes);
 
     if (!Edits.empty())
       Commands +=
           R"({"title":"Apply FixIt ')" + llvm::yaml::escape(D.message) +
           R"('", "command": "clangd.applyFix", "arguments": [")" +
-          llvm::yaml::escape(CAP->textDocument.uri) +
+          llvm::yaml::escape(CAP->textDocument.uri.uri) +
           R"(", [)" + Edits +
           R"(]]},)";
   }
   if (!Commands.empty())
     Commands.pop_back();
 
   writeMessage(
       R"({"jsonrpc":"2.0","id":)" + ID.str() +
       R"(, "result": [)" + Commands +
       R"(]})");
 }
 
 void CompletionHandler::handleMethod(llvm::yaml::MappingNode *Params,
                                      StringRef ID) {
   auto TDPP = TextDocumentPositionParams::parse(Params);
   if (!TDPP) {
     Output.log("Failed to decode TextDocumentPositionParams!\n");
     return;
   }
 
-  auto Items = AST.codeComplete(TDPP->textDocument.uri, TDPP->position.line,
+  auto Items = AST.codeComplete(TDPP->textDocument.uri.file, TDPP->position.line,
                                 TDPP->position.character);
   std::string Completions;
   for (const auto &Item : Items) {
     Completions += CompletionItem::unparse(Item);
     Completions += ",";
   }
   if (!Completions.empty())
     Completions.pop_back();
   writeMessage(
       R"({"jsonrpc":"2.0","id":)" + ID.str() +
       R"(,"result":[)" + Completions + R"(]})");
 }

clang-tools-extra/trunk/clangd/clients/clangd-vscode/src/extension.ts

 export function activate(context: vscode.ExtensionContext) {
     const clangdPath = getConfig<string>('path');
     const clangdArgs = getConfig<string[]>('arguments');
 
     const serverOptions: vscodelc.ServerOptions = { command: clangdPath, args: clangdArgs };
 
     const clientOptions: vscodelc.LanguageClientOptions = {
         // Register the server for C/C++ files
-        documentSelector: ['c', 'cc', 'cpp', 'h', 'hh', 'hpp']
+        documentSelector: ['c', 'cc', 'cpp', 'h', 'hh', 'hpp'],
+        uriConverters: {
+            // FIXME: by default the URI sent over the protocol will be percent encoded (see rfc3986#section-2.1)
+            //        the "workaround" below disables temporarily the encoding until decoding
+            //        is implemented properly in clangd
+            code2Protocol: (uri: vscode.Uri) : string => uri.toString(true),
+            protocol2Code: (uri: string) : vscode.Uri => undefined
+        }
     };
 
     const clangdClient = new vscodelc.LanguageClient('Clang Language Server', serverOptions, clientOptions);
 
     function applyTextEdits(uri: string, edits: vscodelc.TextEdit[]) {
         let textEditor = vscode.window.activeTextEditor;
 
-        if (textEditor && textEditor.document.uri.toString() === uri) {
+        // FIXME: vscode expects that uri will be percent encoded
+        if (textEditor && textEditor.document.uri.toString(true) === uri) {
             textEditor.edit(mutator => {
                 for (const edit of edits) {
                     mutator.replace(vscodelc.Protocol2Code.asRange(edit.range), edit.newText);
                 }
             }).then((success) => {
                 if (!success) {
                     vscode.window.showErrorMessage('Failed to apply fixes to the document.');
                 }