[clangd] Use new URI with scheme support in place of the existing LSP URI

[ioeric]

Summary

o Replace the existing clangd::URI with a wrapper of FileURI which also
carries a resolved file path.
o s/FileURI/URI/

[ioeric]

clangd/ClangdLSPServer.cpp

377

not sure if this is the right thing to do. idea?

clangd/URI.h

32

same here. There are many default constructions of structures that contain URIs in ClangdLSPServer.cpp...

[sammccall]

clangd/ClangdLSPServer.cpp

283

hmm, I think you want to replyerror for unexpected cases.
maybe:

if (ResultUri) {
  if (auto U = URI::create(*Result))
     reply(C, U->toString());
  else
    replyError(C, ErrorCode::InternalError, llvm::toString(U.takeError()));
} else
  reply(C, "");

284

But basically I think this shows that the API is awkward. We should have a way to create a file URI from an absolute path that asserts rather than returning expected.
I'd suggest removing the default "file" scheme from create(), and adding createFile(abspath) that returns URI

clangd/Protocol.h

51

URIForFile? "withfile" doesn't really capture that they're related

51

Hmm actually, what about just struct URIForFile { std:string AbsPath; }
fromJSON and toJSON would do the marshalling to URI, but internally we just want the path, right?

This also gives us the usual easy null state.

clangd/URI.h

32

Does the struct-with-just-an-abspath idea address this?

43

oh, sorry I missed this in the first code review...
It's really confusing to have create(str, str, str) do simple initialization that can't really fail, and create(str,str) do complicated plugin logic that can fail in lots of ways.

Can you change the first to be a constructor and just assert on the needed invariants?
(Or failing that createFromComponents, but I can't imagine a use case where you have components but don't know they're correct)

[ioeric]

• Address review comments

[ioeric]

Thanks for the comments!

clangd/ClangdLSPServer.cpp

284

That makes a lot of sense. Thanks for the suggestion!

clangd/Protocol.h

51

Good idea!

clangd/URI.h

32

Yes!

[ioeric]

• Merge remote-tracking branch 'origin/master' into uri

[sammccall]

Can you also remove the URI-encoding hack from the VSCode client?

clangd/Protocol.cpp

35

I think you can just check that the scheme is file and pull out the path?
we don't want to expose custom URI schemes in LSP, I think

[ioeric]

• addressed review comments; removed URI hack in vscode extenstion.

clangd/ClangdLSPServer.cpp

 //===--- ClangdLSPServer.cpp - LSP server ------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "JSONRPCDispatcher.h"
 #include "SourceCode.h"
+#include "URI.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace clang::clangd;
 using namespace clang;
 
 namespace {
 
 TextEdit replacementToEdit(StringRef Code, const tooling::Replacement &R) {
void ClangdLSPServer::onRename(Ctx C, RenameParams &Params) {
   if (!Replacements) {
     replyError(C, ErrorCode::InternalError,
                llvm::toString(Replacements.takeError()));
     return;
   }
 
   std::vector<TextEdit> Edits = replacementsToEdits(*Code, *Replacements);
   WorkspaceEdit WE;
-  WE.changes = {{Params.textDocument.uri.uri, Edits}};
+  WE.changes = {{Params.textDocument.uri.uri(), Edits}};
   reply(C, WE);
 }
 
 void ClangdLSPServer::onDocumentDidClose(Ctx C,
                                          DidCloseTextDocumentParams &Params) {
   Server.removeDocument(std::move(C), Params.textDocument.uri.file);
 }
 
if (!Code)
     return replyError(C, ErrorCode::InvalidParams,
                       "onCodeAction called for non-added file");
 
   json::ary Commands;
   for (Diagnostic &D : Params.context.diagnostics) {
     auto Edits = getFixIts(Params.textDocument.uri.file, D);
     if (!Edits.empty()) {
       WorkspaceEdit WE;
-      WE.changes = {{Params.textDocument.uri.uri, std::move(Edits)}};
+      WE.changes = {{Params.textDocument.uri.uri(), std::move(Edits)}};
       Commands.push_back(json::obj{
           {"title", llvm::formatv("Apply FixIt {0}", D.message)},
           {"command", ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND},
           {"arguments", {WE}},
       });
     }
   }
   reply(C, std::move(Commands));
if (!Items)
     return replyError(C, ErrorCode::InvalidParams,
                       llvm::toString(Items.takeError()));
   reply(C, json::ary(Items->Value));
 }
 
 void ClangdLSPServer::onSwitchSourceHeader(Ctx C,
                                            TextDocumentIdentifier &Params) {
   llvm::Optional<Path> Result = Server.switchSourceHeader(Params.uri.file);
-  std::string ResultUri;
-  reply(C, Result ? URI::fromFile(*Result).uri : "");
+  reply(C, Result ? URI::createFile(*Result).toString() : "");
 }
 
 void ClangdLSPServer::onDocumentHighlight(Ctx C,
                                           TextDocumentPositionParams &Params) {
 
   auto Highlights = Server.findDocumentHighlights(
       C, Params.textDocument.uri.file,
       Position{Params.position.line, Params.position.character});
 
// Cache FixIts
     // FIXME(ibiryukov): should be deleted when documents are removed
     std::lock_guard<std::mutex> Lock(FixItsMutex);
     FixItsMap[File] = LocalFixIts;
   }
 
   // Publish diagnostics.
   Out.writeMessage(json::obj{
       {"jsonrpc", "2.0"},
       {"method", "textDocument/publishDiagnostics"},
       {"params",
        json::obj{
-           {"uri", URI::fromFile(File)},
+           {"uri", URIForFile{File}},
            {"diagnostics", std::move(DiagnosticsJSON)},
        }},
   });
 }

clangd/Protocol.h

 // tests, and is not generally machine-readable.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PROTOCOL_H
 
 #include "JSONExpr.h"
+#include "URI.h"
 #include "llvm/ADT/Optional.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 enum class ErrorCode {
   // Defined by JSON RPC.
   ParseError = -32700,
   InvalidRequest = -32600,
   MethodNotFound = -32601,
   InvalidParams = -32602,
   InternalError = -32603,
 
   ServerNotInitialized = -32002,
   UnknownErrorCode = -32001,
 
   // Defined by the protocol.
   RequestCancelled = -32800,
 };
 
-struct URI {
-  std::string uri;
+struct URIForFile {
   std::string file;
 
-  static URI fromUri(llvm::StringRef uri);
-  static URI fromFile(llvm::StringRef file);
+  std::string uri() const { return URI::createFile(file).toString(); }
 
-  friend bool operator==(const URI &LHS, const URI &RHS) {
-    return LHS.uri == RHS.uri;
+  friend bool operator==(const URIForFile &LHS, const URIForFile &RHS) {
+    return LHS.file == RHS.file;
   }
 
-  friend bool operator!=(const URI &LHS, const URI &RHS) {
+  friend bool operator!=(const URIForFile &LHS, const URIForFile &RHS) {
     return !(LHS == RHS);
   }
 
-  friend bool operator<(const URI &LHS, const URI &RHS) {
-    return LHS.uri < RHS.uri;
+  friend bool operator<(const URIForFile &LHS, const URIForFile &RHS) {
+    return LHS.file < RHS.file;
   }
 };
-json::Expr toJSON(const URI &U);
-bool fromJSON(const json::Expr &, URI &);
-llvm::raw_ostream &operator<<(llvm::raw_ostream &, const URI &);
+
+/// Serialize/deserialize \p URIForFile to/from a string URI.
+json::Expr toJSON(const URIForFile &U);
+bool fromJSON(const json::Expr &, URIForFile &);
 
 struct TextDocumentIdentifier {
   /// The text document's URI.
-  URI uri;
+  URIForFile uri;
 };
 bool fromJSON(const json::Expr &, TextDocumentIdentifier &);
 
 struct Position {
   /// Line position in a document (zero-based).
   int line;
 
   /// Character offset on a line in a document (zero-based).
struct Range {
   }
 };
 bool fromJSON(const json::Expr &, Range &);
 json::Expr toJSON(const Range &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Range &);
 
 struct Location {
   /// The text document's URI.
-  URI uri;
+  URIForFile uri;
   Range range;
 
   friend bool operator==(const Location &LHS, const Location &RHS) {
     return LHS.uri == RHS.uri && LHS.range == RHS.range;
   }
 
   friend bool operator!=(const Location &LHS, const Location &RHS) {
     return !(LHS == RHS);
struct TextEdit {
   std::string newText;
 };
 bool fromJSON(const json::Expr &, TextEdit &);
 json::Expr toJSON(const TextEdit &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TextEdit &);
 
 struct TextDocumentItem {
   /// The text document's URI.
-  URI uri;
+  URIForFile 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 InitializeParams {
   /// if no folder is open.
   ///
   /// @deprecated in favour of rootUri.
   llvm::Optional<std::string> rootPath;
 
   /// The rootUri of the workspace. Is null if no
   /// folder is open. If both `rootPath` and `rootUri` are set
   /// `rootUri` wins.
-  llvm::Optional<URI> rootUri;
+  llvm::Optional<URIForFile> rootUri;
 
   // User provided initialization options.
   // initializationOptions?: any;
 
   /// The capabilities provided by the client (editor or tool)
   /// Note: Not currently used by clangd
   // ClientCapabilities capabilities;
 
enum class FileChangeType {
   Changed = 2,
   /// The file got deleted.
   Deleted = 3
 };
 bool fromJSON(const json::Expr &E, FileChangeType &Out);
 
 struct FileEvent {
   /// The file's URI.
-  URI uri;
+  URIForFile uri;
   /// The change type.
   FileChangeType type;
 };
 bool fromJSON(const json::Expr &, FileEvent &);
 
 struct DidChangeWatchedFilesParams {
   /// The actual file events.
   std::vector<FileEvent> changes;

clangd/Protocol.cpp

 //===--- Protocol.cpp - Language Server Protocol Implementation -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the serialization code for the LSP structs.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Protocol.h"
+#include "URI.h"
+#include "Logger.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
 
-URI URI::fromUri(llvm::StringRef uri) {
-  URI Result;
-  Result.uri = uri;
-  uri.consume_front("file://");
-  // Also trim authority-less URIs
-  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;
-}
-
-bool fromJSON(const json::Expr &E, URI &R) {
+bool fromJSON(const json::Expr &E, URIForFile &R) {
   if (auto S = E.asString()) {
-    R = URI::fromUri(*S);
+    auto U = URI::parse(*S);
+    if (!U) {
+      log(Context::empty(),
+          "Failed to parse URI " + *S + ": " + llvm::toString(U.takeError()));
+      return false;
+    }
+    if (U->scheme() != "file") {
+      log(Context::empty(),
+          "Clangd only supports 'file' URI scheme for workspace files: " + *S);
+      return false;
+    }
+    // We know that body of a file URI is absolute path.
+    R.file = U->body();
     return true;
   }
   return false;
 }
 
-json::Expr toJSON(const URI &U) { return U.uri; }
+json::Expr toJSON(const URIForFile &U) {
+  return U.uri();
+}
 
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const URI &U) {
-  return OS << U.uri;
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const URIForFile &U) {
+  return OS << U.uri();
 }
 
 bool fromJSON(const json::Expr &Params, TextDocumentIdentifier &R) {
   json::ObjectMapper O(Params);
   return O && O.map("uri", R.uri);
 }
 
 bool fromJSON(const json::Expr &Params, Position &R) {

clangd/URI.h

 /// In the simplest case, this is a "file" URI that directly encodes the
 /// absolute path to a file. More abstract cases are possible: a shared index
 /// service might expose repo:// URIs that are relative to the source control
 /// root.
 ///
 /// Clangd handles URIs of the form <scheme>:[//<authority>]<body>. It doesn't
 /// further split the authority or body into constituent parts (e.g. query
 /// strings is included in the body).
-class FileURI {
+class URI {
 public:
+  URI(llvm::StringRef Scheme, llvm::StringRef Authority, llvm::StringRef Body);
+
   /// Returns decoded scheme e.g. "https"
   llvm::StringRef scheme() const { return Scheme; }
   /// Returns decoded authority e.g. "reviews.lvm.org"
   llvm::StringRef authority() const { return Authority; }
   /// Returns decoded body e.g. "/D41946"
   llvm::StringRef body() const { return Body; }
 
   /// Returns a string URI with all components percent-encoded.
   std::string toString() const;
 
-  /// Create a FileURI from unescaped scheme+authority+body.
-  static llvm::Expected<FileURI> create(llvm::StringRef Scheme,
-                                        llvm::StringRef Authority,
-                                        llvm::StringRef Body);
-
-  /// Creates a FileURI for a file in the given scheme. \p Scheme must be
+  /// Creates a URI for a file in the given scheme. \p Scheme must be
   /// registered. The URI is percent-encoded.
-  static llvm::Expected<FileURI> create(llvm::StringRef AbsolutePath,
-                                        llvm::StringRef Scheme = "file");
+  static llvm::Expected<URI> create(llvm::StringRef AbsolutePath,
+                                    llvm::StringRef Scheme);
+
+  /// This creates a file:// URI for \p AbsolutePath. The path must be absolute.
+  static URI createFile(llvm::StringRef AbsolutePath);
 
   /// Parse a URI string "<scheme>:[//<authority>/]<path>". Percent-encoded
   /// characters in the URI will be decoded.
-  static llvm::Expected<FileURI> parse(llvm::StringRef Uri);
+  static llvm::Expected<URI> parse(llvm::StringRef Uri);
 
   /// Resolves the absolute path of \p U. If there is no matching scheme, or the
   /// URI is invalid in the scheme, this returns an error.
   ///
   /// \p HintPath A related path, such as the current file or working directory,
   /// which can help disambiguate when the same file exists in many workspaces.
-  static llvm::Expected<std::string> resolve(const FileURI &U,
+  static llvm::Expected<std::string> resolve(const URI &U,
                                              llvm::StringRef HintPath = "");
 
-  friend bool operator==(const FileURI &LHS, const FileURI &RHS) {
+  friend bool operator==(const URI &LHS, const URI &RHS) {
     return std::tie(LHS.Scheme, LHS.Authority, LHS.Body) ==
            std::tie(RHS.Scheme, RHS.Authority, RHS.Body);
   }
 
+  friend bool operator<(const URI &LHS, const URI &RHS) {
+    return std::tie(LHS.Scheme, LHS.Authority, LHS.Body) <
+           std::tie(RHS.Scheme, RHS.Authority, RHS.Body);
+  }
+
 private:
-  FileURI() = default;
+  URI() = default;
 
   std::string Scheme;
   std::string Authority;
   std::string Body;
 };
 
 /// URIScheme is an extension point for teaching clangd to recognize a custom
 /// URI scheme. This is expected to be implemented and exposed via the
 /// URISchemeRegistry.
 class URIScheme {
 public:
   virtual ~URIScheme() = default;
 
   /// Returns the absolute path of the file corresponding to the URI
-  /// authority+body in the file system. See FileURI::resolve for semantics of
+  /// authority+body in the file system. See URI::resolve for semantics of
   /// \p HintPath.
   virtual llvm::Expected<std::string>
   getAbsolutePath(llvm::StringRef Authority, llvm::StringRef Body,
                   llvm::StringRef HintPath) const = 0;
 
-  virtual llvm::Expected<FileURI>
+  virtual llvm::Expected<URI>
   uriFromAbsolutePath(llvm::StringRef AbsolutePath) const = 0;
 };
 
 /// By default, a "file" scheme is supported where URI paths are always absolute
 /// in the file system.
 typedef llvm::Registry<URIScheme> URISchemeRegistry;
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHURI_H

clangd/URI.cpp

getAbsolutePath(llvm::StringRef /*Authority*/, llvm::StringRef Body,
     // For Windows paths e.g. /X:
     if (Body.size() > 2 && Body[0] == '/' && Body[2] == ':')
       Body.consume_front("/");
     llvm::SmallVector<char, 16> Path(Body.begin(), Body.end());
     llvm::sys::path::native(Path);
     return std::string(Path.begin(), Path.end());
   }
 
-  llvm::Expected<FileURI>
+  llvm::Expected<URI>
   uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override {
     using namespace llvm::sys;
 
     std::string Body;
     // For Windows paths e.g. X:
     if (AbsolutePath.size() > 1 && AbsolutePath[1] == ':')
       Body = "/";
     Body += path::convert_to_slash(AbsolutePath);
-    return FileURI::create(Scheme, /*Authority=*/"", Body);
+    return URI(Scheme, /*Authority=*/"", Body);
   }
 };
 
 const char *FileSystemScheme::Scheme = "file";
 
 static URISchemeRegistry::Add<FileSystemScheme>
     X(FileSystemScheme::Scheme,
       "URI scheme for absolute paths in the file system.");
for (auto I = Content.begin(), E = Content.end(); I != E; ++I) {
     } else
       Result.push_back(*I);
   }
   return Result;
 }
 
 } // namespace
 
-llvm::Expected<FileURI> FileURI::create(llvm::StringRef Scheme,
-                                        llvm::StringRef Authority,
-                                        llvm::StringRef Body) {
-  if (Scheme.empty())
-    return make_string_error("Scheme must be specified in a URI.");
-  if (!Authority.empty() && !Body.startswith("/"))
-    return make_string_error(
+URI::URI(llvm::StringRef Scheme, llvm::StringRef Authority,
+         llvm::StringRef Body)
+    : Scheme(Scheme), Authority(Authority), Body(Body) {
+  assert(!Scheme.empty());
+  assert((Authority.empty() || Body.startswith("/")) &&
          "URI body must start with '/' when authority is present.");
-  FileURI U;
-  U.Scheme = Scheme;
-  U.Authority = Authority;
-  U.Body = Body;
-  return U;
 }
 
-std::string FileURI::toString() const {
+std::string URI::toString() const {
   std::string Result;
   llvm::raw_string_ostream OS(Result);
   OS << percentEncode(Scheme) << ":";
   if (Authority.empty() && Body.empty())
     return OS.str();
   // If authority if empty, we only print body if it starts with "/"; otherwise,
   // the URI is invalid.
   if (!Authority.empty() || llvm::StringRef(Body).startswith("/"))
     OS << "//" << percentEncode(Authority);
   OS << percentEncode(Body);
   OS.flush();
   return Result;
 }
 
-llvm::Expected<FileURI> FileURI::parse(llvm::StringRef OrigUri) {
-  FileURI U;
+llvm::Expected<URI> URI::parse(llvm::StringRef OrigUri) {
+  URI U;
   llvm::StringRef Uri = OrigUri;
 
   auto Pos = Uri.find(':');
   if (Pos == 0 || Pos == llvm::StringRef::npos)
     return make_string_error("Scheme must be provided in URI: " + OrigUri);
   U.Scheme = percentDecode(Uri.substr(0, Pos));
   Uri = Uri.substr(Pos + 1);
   if (Uri.consume_front("//")) {
     Pos = Uri.find('/');
     U.Authority = percentDecode(Uri.substr(0, Pos));
     Uri = Uri.substr(Pos);
   }
   U.Body = percentDecode(Uri);
   return U;
 }
 
-llvm::Expected<FileURI> FileURI::create(llvm::StringRef AbsolutePath,
-                                        llvm::StringRef Scheme) {
+llvm::Expected<URI> URI::create(llvm::StringRef AbsolutePath,
   if (!llvm::sys::path::is_absolute(AbsolutePath))
     return make_string_error("Not a valid absolute path: " + AbsolutePath);
   auto S = findSchemeByName(Scheme);
   if (!S)
     return S.takeError();
   return S->get()->uriFromAbsolutePath(AbsolutePath);
 }
 
-llvm::Expected<std::string> FileURI::resolve(const FileURI &Uri,
-                                             llvm::StringRef HintPath) {
+URI URI::createFile(llvm::StringRef AbsolutePath) {
+  auto U = create(AbsolutePath, "file");
+  if (!U)
+    llvm_unreachable(llvm::toString(U.takeError()).c_str());
+  return std::move(*U);
+}
+
+llvm::Expected<std::string> URI::resolve(const URI &Uri,
   auto S = findSchemeByName(Uri.Scheme);
   if (!S)
     return S.takeError();
   return S->get()->getAbsolutePath(Uri.Authority, Uri.Body, HintPath);
 }
 
 } // namespace clangd
 } // namespace clang

clangd/XRefs.cpp

 //===--- XRefs.cpp ----------------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 #include "XRefs.h"
+#include "Logger.h"
+#include "URI.h"
 #include "clang/Index/IndexDataConsumer.h"
 #include "clang/Index/IndexingAction.h"
 namespace clang {
 namespace clangd {
 using namespace llvm;
 namespace {
 
 // Get the definition from a given declaration `D`.
getDeclarationLocation(ParsedAST &AST, const SourceRange &ValSourceRange) {
   End.line = SourceMgr.getSpellingLineNumber(LocEnd) - 1;
   End.character = SourceMgr.getSpellingColumnNumber(LocEnd) - 1;
   Range R = {Begin, End};
   Location L;
 
   StringRef FilePath = F->tryGetRealPathName();
   if (FilePath.empty())
     FilePath = F->getName();
-  L.uri = URI::fromFile(FilePath);
+  L.uri.file = FilePath;
   L.range = R;
   return L;
 }
 
 } // namespace
 
 std::vector<Location> findDefinitions(const Context &Ctx, ParsedAST &AST,
                                       Position Pos) {

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

export function activate(context: vscode.ExtensionContext) {
 
     const serverOptions: vscodelc.ServerOptions = { command: clangdPath, args: clangdArgs };
 
     const filePattern: string = '**/*.{' +
       ['cpp', 'c', 'cc', 'cxx', 'c++', 'm', 'mm', 'h', 'hh', 'hpp', 'hxx', 'inc'].join() + '}';
     const clientOptions: vscodelc.LanguageClientOptions = {
         // Register the server for C/C++ files
         documentSelector: [{scheme: 'file', pattern: filePattern}],
-        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 => vscode.Uri.parse(uri)
-        },
         synchronize: !syncFileEvents ? undefined : {
             fileEvents: vscode.workspace.createFileSystemWatcher(filePattern)
         }
     };
 
     const clangdClient = new vscodelc.LanguageClient('Clang Language Server', serverOptions, clientOptions);
     console.log('Clang Language Server is now active!');
 
     const disposable = clangdClient.start();
 }

unittests/clangd/URITests.cpp

public:
   getAbsolutePath(llvm::StringRef /*Authority*/, llvm::StringRef Body,
                   llvm::StringRef HintPath) const override {
     auto Pos = HintPath.find(TestRoot);
     assert(Pos != llvm::StringRef::npos);
     return (HintPath.substr(0, Pos + llvm::StringRef(TestRoot).size()) + Body)
         .str();
   }
 
-  llvm::Expected<FileURI>
+  llvm::Expected<URI>
   uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override {
     auto Pos = AbsolutePath.find(TestRoot);
     assert(Pos != llvm::StringRef::npos);
-    return FileURI::create(
-        Scheme, /*Authority=*/"",
+    return URI(Scheme, /*Authority=*/"",
                AbsolutePath.substr(Pos + llvm::StringRef(TestRoot).size()));
   }
 };
 
 const char *TestScheme::Scheme = "test";
 const char *TestScheme::TestRoot = "/test-root/";
 
 static URISchemeRegistry::Add<TestScheme> X(TestScheme::Scheme, "Test schema");
 
 std::string createOrDie(llvm::StringRef AbsolutePath,
                         llvm::StringRef Scheme = "file") {
-  auto Uri = FileURI::create(AbsolutePath, Scheme);
+  auto Uri = URI::create(AbsolutePath, Scheme);
   if (!Uri)
     llvm_unreachable(llvm::toString(Uri.takeError()).c_str());
   return Uri->toString();
 }
 
-std::string createOrDie(llvm::StringRef Scheme, llvm::StringRef Authority,
-                        llvm::StringRef Body) {
-  auto Uri = FileURI::create(Scheme, Authority, Body);
-  if (!Uri)
-    llvm_unreachable(llvm::toString(Uri.takeError()).c_str());
-  return Uri->toString();
-}
-
-FileURI parseOrDie(llvm::StringRef Uri) {
-  auto U = FileURI::parse(Uri);
+URI parseOrDie(llvm::StringRef Uri) {
+  auto U = URI::parse(Uri);
   if (!U)
     llvm_unreachable(llvm::toString(U.takeError()).c_str());
   return *U;
 }
 
 TEST(PercentEncodingTest, Encode) {
-  EXPECT_EQ(createOrDie("x", /*Authority=*/"", "a/b/c"), "x:a/b/c");
-  EXPECT_EQ(createOrDie("x", /*Authority=*/"", "a!b;c~"), "x:a%21b%3bc~");
+  EXPECT_EQ(URI("x", /*Authority=*/"", "a/b/c").toString(), "x:a/b/c");
+  EXPECT_EQ(URI("x", /*Authority=*/"", "a!b;c~").toString(), "x:a%21b%3bc~");
 }
 
 TEST(PercentEncodingTest, Decode) {
   EXPECT_EQ(parseOrDie("x:a/b/c").body(), "a/b/c");
 
   EXPECT_EQ(parseOrDie("%3a://%3a/%3").scheme(), ":");
   EXPECT_EQ(parseOrDie("%3a://%3a/%3").authority(), ":");
   EXPECT_EQ(parseOrDie("%3a://%3a/%3").body(), "/%3");
 
   EXPECT_EQ(parseOrDie("x:a%21b%3ac~").body(), "a!b:c~");
 }
 
-std::string resolveOrDie(const FileURI &U, llvm::StringRef HintPath = "") {
-  auto Path = FileURI::resolve(U, HintPath);
+std::string resolveOrDie(const URI &U, llvm::StringRef HintPath = "") {
+  auto Path = URI::resolve(U, HintPath);
   if (!Path)
     llvm_unreachable(llvm::toString(Path.takeError()).c_str());
   return *Path;
 }
 
 TEST(URITest, Create) {
 #ifdef LLVM_ON_WIN32
   EXPECT_THAT(createOrDie("c:\\x\\y\\z"), "file:///c%3a/x/y/z");
 #else
   EXPECT_THAT(createOrDie("/x/y/z"), "file:///x/y/z");
   EXPECT_THAT(createOrDie("/(x)/y/\\ z"), "file:///%28x%29/y/%5c%20z");
 #endif
 }
 
 TEST(URITest, FailedCreate) {
-  auto Fail = [](llvm::Expected<FileURI> U) {
+  auto Fail = [](llvm::Expected<URI> U) {
     if (!U) {
       llvm::consumeError(U.takeError());
       return true;
     }
     return false;
   };
-  // Create from scheme+authority+body:
-  //
-  // Scheme must be provided.
-  EXPECT_TRUE(Fail(FileURI::create("", "auth", "/a")));
-  // Body must start with '/' if authority is present.
-  EXPECT_TRUE(Fail(FileURI::create("scheme", "auth", "x/y/z")));
-
-  // Create from scheme registry:
-  //
-  EXPECT_TRUE(Fail(FileURI::create("/x/y/z", "no")));
+  EXPECT_TRUE(Fail(URI::create("/x/y/z", "no")));
   // Path has to be absolute.
-  EXPECT_TRUE(Fail(FileURI::create("x/y/z")));
+  EXPECT_TRUE(Fail(URI::create("x/y/z", "file")));
 }
 
 TEST(URITest, Parse) {
   EXPECT_THAT(parseOrDie("file://auth/x/y/z"),
               AllOf(Scheme("file"), Authority("auth"), Body("/x/y/z")));
 
   EXPECT_THAT(parseOrDie("file://au%3dth/%28x%29/y/%5c%20z"),
               AllOf(Scheme("file"), Authority("au=th"), Body("/(x)/y/\\ z")));
EXPECT_THAT(parseOrDie("urn:isbn:0451450523"),
               AllOf(Scheme("urn"), Authority(""), Body("isbn:0451450523")));
   EXPECT_THAT(
       parseOrDie("file:///c:/windows/system32/"),
       AllOf(Scheme("file"), Authority(""), Body("/c:/windows/system32/")));
 }
 
 TEST(URITest, ParseFailed) {
   auto FailedParse = [](llvm::StringRef U) {
-    auto URI = FileURI::parse(U);
+    auto URI = URI::parse(U);
     if (!URI) {
       llvm::consumeError(URI.takeError());
       return true;
     }
     return false;
   };
 
   // Expect ':' in URI.
#else
   EXPECT_THAT(resolveOrDie(parseOrDie("file://au%3dth/%28x%29/y/%20z")),
               "/(x)/y/ z");
   EXPECT_THAT(resolveOrDie(parseOrDie("file:///c:/x/y/z")), "c:/x/y/z");
 #endif
 }
 
 TEST(URITest, Platform) {
   auto Path = getVirtualTestFilePath("x");
-  auto U = FileURI::create(Path, "file");
+  auto U = URI::create(Path, "file");
   EXPECT_TRUE(static_cast<bool>(U));
   EXPECT_THAT(resolveOrDie(*U), Path.str());
 }
 
 TEST(URITest, ResolveFailed) {
   auto FailedResolve = [](llvm::StringRef Uri) {
-    auto Path = FileURI::resolve(parseOrDie(Uri));
+    auto Path = URI::resolve(parseOrDie(Uri));
     if (!Path) {
       llvm::consumeError(Path.takeError());
       return true;
     }
     return false;
   };
 
   // Invalid scheme.
   EXPECT_TRUE(FailedResolve("no:/a/b/c"));
   // File path needs to be absolute.
   EXPECT_TRUE(FailedResolve("file:a/b/c"));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

unittests/clangd/XRefsTests.cpp

 //===-- XRefsTests.cpp  ---------------------------*- C++ -*--------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "Annotations.h"
 #include "ClangdUnit.h"
 #include "Matchers.h"
+#include "TestFS.h"
 #include "XRefs.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/PCHContainerOperations.h"
 #include "clang/Frontend/Utils.h"
 #include "llvm/Support/Path.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 

 namespace {
 using testing::ElementsAre;
 using testing::Field;
 using testing::Matcher;
 using testing::UnorderedElementsAreArray;
 
 // FIXME: this is duplicated with FileIndexTests. Share it.
 ParsedAST build(StringRef Code) {
-  auto CI = createInvocationFromCommandLine({"clang", "-xc++", "Foo.cpp"});
+  auto TestFile = getVirtualTestFilePath("Foo.cpp");
+  auto CI =
+      createInvocationFromCommandLine({"clang", "-xc++", TestFile.c_str()});
   auto Buf = MemoryBuffer::getMemBuffer(Code);
   auto AST = ParsedAST::Build(
       Context::empty(), std::move(CI), nullptr, std::move(Buf),
       std::make_shared<PCHContainerOperations>(), vfs::getRealFileSystem());
   assert(AST.hasValue());
   return std::move(*AST);
 }