[clangd] Add support for different file URI schemas.

[ioeric]

Summary

I will replace the existing URI struct in Protocol.h with the new URI and rename FileURI to URI in a followup patch.

[sammccall]

Lots of quibbles here, some things we can certainly defer. Happy to chat offline if you're not sure...

clangd/URI.cpp

18

This isn't correct, we need to escape some characters, turn \ to /, etc.

It's not quite obvious what to do here in general, because URI escaping rules are defined in terms of the full generic URI syntax.

I'd suggest:

1. instead of just splitting scheme/path, split scheme/authority/path if it starts with //, authority is the part up to the next /. Otherwise empty.

Splitting authority/scheme/path allows "file" schema to just care about the path part, not the // prefix, without mandating that all schemas have authorities.

2. when deserializing authority/scheme, decode all percent-encoding. when serializing, percent-encode characters that are neither reserved nor unreserved.

(The reserved characters basically have no business in filenames, apart from / which you don't want escaped. This allows custom URI schemes to be flexible)

36

this error needs to be handled, it shouldn't be an assert

clangd/URI.h

20

Why allow an invalid state?
I think I'd lean towards more type safety here: having a few factory functions that always produce valid URIs (like fromPath) and some that return Expected<URI> (like parse), but require URI itself to be valid.

This would probably mean making it a class and having schema/path be readonly...

20

This doesn't really describe what it's for. Consider:

/// A URI describes the location of a source file.
/// 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.

22–23

nit: scheme, not schema (they're synonyms, but URIs always talk about scheme)

25

I think calling this "path" is confusing, because there's ambiguity between the URI path component, and the file path that you're ultimately trying to transform it into.

Consider "body", without changing semantics.

32

(if you keep this: isValid(), or just valid(), or operator bool())

39

fromURI is confusing, because the input is a String and the output is a URI.
parse()?

46

Hmm, it manages file paths in exactly one schema :-)
"manages" is also very vague. What about

/ \brief URIScheme is an extension point for teaching clangd to recognize a custom URI scheme.
A scheme's job is to translate between URIs and file paths.

54

nit: move this to the registry?

65

Uri not in schema: why would the framework even call getAbsolutePath in that case?
Easier just to make that inexpressible by just having the framework pass the path/body as a stringref, I think.

We should have a way to handle errors though, e.g. file:// URIs that have relative paths. Return Expected rather than use the empty string for signaling?

66

make currentfile the last param and optional? Uri is the primary param

70

again:

• return std::string to avoid the possibility of returning a FileURI with the wrong scheme
• maybe provide a way to signal errors. In this case, optional<string> might be right, as we don't know in advance which scheme to use so failures are expected.

75

this should be defined in the cpp file

90

There are other possible failure cases.
Please propagate errors here rather than magic empty strings.

91

this is part of the "user" API, not the extension API, move up above?
in fact, should this maybe be a method on URI?

91

I think you want a public function to turn an absolute path into a file:// URI.
When communicating with the editor, we don't want to send custom URI schemes.

[ioeric]

• Addressed review comments.

[ioeric]

Thanks for the comments! I've refactored the code according to your suggestions. PTAL

[sammccall]

Few more interface nits, sorry for picking here! Will get through the impl in the morning.

clangd/URI.cpp

43

Don't you want the opposite here, convert from unix to native?

50

this error can be returned by the framework already (it's valid for all paths)

57

conversely, here you want native (which is the default)

58

hmm, file:///foo/bar is more widely used than file:/foo/bar.
You way want to emit that instead?

clangd/URI.h

24

You probably also want to describe roughly the subset of URI parsing we do.

e.g.
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).

27

e.g. "https"

29

e.g. "//reviews.llvm.org"

31

e.g. "/D41946"

43

I think "the first matching scheme" is a bit confusing - I guess here "scheme" refers to URIScheme, but in practice these should be 1:1 with schemes.
I'd just drop that, and instead add a sentence that errors may occur if the scheme isn't understood or the URI isn't valid in the scheme.

46

this is the "more public" API, so the semantics of CurrentFile should probably be defined here, and merely referred to below.
(See below comment for questions about semantics)

63

Hmm - what does "users" mean :-)
I can't think of a good way to rephrase. It might be clear enough without this sentence.

65

nit: I'm not sure this longer comment would really help someone use this API.
I'd suggest either making the example concrete and focusing around that, or dropping it entirely - it's OK to be a little sparse here, since we don't really expect unfamiliar users.

76

I think "the file from which the request is issued" is overly-specified (and a little unclear).

For instance, consider this workflow:
vim $projectroot
go to symbol -> "MyClass" (from global index)
Now we're trying to navigate to "monorepo://proj/myclass.h", but we don't have a "current file" to use as a hint. $projectroot would probably do nicely, and is available to clangd.

So maybe llvm::StringRef HintPath- "A related path, such as the current file or working directory, which can help disambiguate when the same file exists in many workspaces".

80

You should probably pass authority here too, or we're committing all schemes to ignore authority

82

similarly, this should return (authority, body), not just body.
a pair seems fine for such an internal API

90

this seems easy enough to test via uri::create rather than exposing it publicly, but up to you.

97

nit: you probably don't want anything between URIScheme and this - if you keep percent*, move them below?

[ioeric]

• Address review comments

clangd/URI.cpp

43

Ah, right!

57

Don't we still need to convert \ to / on windows?

clangd/URI.h

29

I think authority doesn't include leading "//"?

76

Makes sense. Thanks for the suggestion!

90

I think this would also be useful for other scheme extensions.

[sammccall]

clangd/URI.cpp

94

Performance doesn't really matter here, but it looks like this is intended to save time by precomputing, and I don't think it's any faster than the direct version of percentEncode which might be easier to read:

for (unsigned char C : Content)
  if (shouldEscape(C))
    OS << '%' << format_hex_no_prefix(C, 2);
  else
    OS << C;

where shouldEscape just does some range checks.
(the "unsigned" is important!)

95

128 should be 256, right?

123

most implementations seem to just treat treat the % as literal in this case, e.g. "%41%" -> "A%", which makes this function unable to fail, which simplifies parse() a bit

125

alternatively, using more llvm and less std:

if (*I == '%' && I + 2 < Content.end()
  && isHexDigit(*(I+1)) && isHexDigit(*(I+2)) {
  Result.push_back(hexFromNibbles(*(I+1), *(I+2)));
  I += 2;
} else
  Result.push_back(*I);

136

nit: i'd probably prefer to keep "uri" referring to the whole URI, and call the one you mutate something else

138

consider StringRef::split which avoids some index arithmetic:

pair<StringRef, StringRef> SchemeSplit = Uri.split(':');
if (SchemeSplit.second == "")
  return error
U.Scheme = percentDecode(SchemeSplit.first);
// then SchemeSplit.second contains the rest

149

this is e.g. http://llvm.org
This is valid: scheme = 'http', authority = 'llvm.org', path = ''.
(Wikipedia is wrong, but the RFC covers this)

155

this is e.g. file:///foo/bar, which is definitely valid!
scheme = 'file', authority = '', path = '/foo/bar'

(we should have a test for this one!)

168

body may be empty. (http://llvm.org again)

unittests/clangd/URITests.cpp

115

please include some typical examples:

"file:///etc/passwd"
"file:///c:/windows/system32/"
"http://llvm.org"
"urn:isbn:0451450523"

117

the body should be "//x/y/z" here - the / that terminates the authority is part of the path.
(This is a valid URI, but not a typical example)

143

this is the same as the next one

144

these are both valid

148

this is valid, authority may be empty

[sammccall]

Sorry, our comments crossed...

clangd/URI.cpp

57

yes. convert_to_slash(path, style) assumes that path is in style.

convert_to_slash("c:\\foo.txt", windows) --> "c:/foo.txt"
convert_to_slash("c:\\foo.txt", posix) --> "c:\\foo.txt" (because that's a perfectly valid filename on a posix system! well, apart from the colon)
convert_to_slash("c:\\foo.txt", native) --> "c:/foo.txt" if the host is windows, "c:\\foo.txt" if the host is windows (this is what you want)

clangd/URI.h

29

You're right! my mistake.

[ioeric]

• Addressed review comments.
• Check windows vs unit paths in tests.
• Properly check absolute paths.

[ioeric]

clangd/URI.cpp

57

I see. Thanks for the clarification!

138

split is neat. But here we want to distinguish between http: vs http while it's not trivial wth split. Similar for / following the authority if we want to keep body '/', say, in http://llvm.org/.

155

Right! Realized file:////foo/bar was weird while preparing the previous diff ;)

[sammccall]

LG with some nits addressed

clangd/URI.cpp

47

should this be native(Path, posix)?
native(Path) seems to be a no-op

90

nit: reserved
nit: you're not unescaping it, you're just not escaping it

and I don't think "for readability" is accurate.
Reserved characters are only reserved in certain contexts, escaping a slash in a path is (I think) incorrect.

138

I don't understand what you mean by distinguishing http: vs http - "http://foo" will split into {"http", "foo"}. "httpfoo" will not split at all, and "http::foo" will split into "http" and "://foo".

Agreed regarding authority/body.

clangd/URI.h

32

nit: prefer to omit \brief unless you want the brief comment to be something other than the first sentence.

(I know we have this in lots of places - it adds noise, and I finally got around to looking it up in the style guide!)

82

Still confused about this API, but let's chat offline?

90

Hmm, I think if individual schemes need to do encoding/decoding, then our API is wrong :-)

92

nit: unreserved

unittests/clangd/URITests.cpp

2

you may want a test that round-trips getVirtualTestFilePath("x") through a file URI and back again.
This should exercise the platform-specific code path - that path is under C:\ on windows, and /tmp/ on linux. The buildbots should give us platform coverage.

[ioeric]

• Addressed review comments.

[ioeric]

clangd/URI.h

32

Good to know. Thanks!

unittests/clangd/URITests.cpp

2

Good idea! Didn't know such a nice function exists.

clangd/CMakeLists.txt

add_clang_library(clangDaemon
   GlobalCompilationDatabase.cpp
   JSONExpr.cpp
   JSONRPCDispatcher.cpp
   Logger.cpp
   Protocol.cpp
   ProtocolHandlers.cpp
   SourceCode.cpp
   Trace.cpp
+  URI.cpp
   XRefs.cpp
   index/FileIndex.cpp
   index/Index.cpp
   index/MemIndex.cpp
   index/Merge.cpp
   index/SymbolCollector.cpp
   index/SymbolYAML.cpp
 

clangd/URI.h

+//===--- URI.h - File URIs with schemes --------------------------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHURI_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PATHURI_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Registry.h"
+
+namespace clang {
+namespace clangd {
+
+/// A URI describes the location of a source file.
+/// 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.
+class FileURI {
+public:
+  /// \brief Returns decoded scheme.
+  llvm::StringRef scheme() const { return Scheme; }
+  /// \brief Returns decoded authority.
+  llvm::StringRef authority() const { return Authority; }
+  /// \brief Returns decoded body.
+  llvm::StringRef body() const { return Body; }
+
+  /// \brief Creates a URI string for a file in the given scheme. \p Scheme must
+  /// must be registered.
+  static llvm::Expected<std::string> create(llvm::StringRef AbsolutePath,
+                                            llvm::StringRef Scheme = "file");
+
+  /// \brief Parse a URI string "<scheme>://<authority>/<path>" where authority
+  /// is optional when "//" is not present.
+  static llvm::Expected<FileURI> parse(llvm::StringRef Uri);
+
+  /// \brief Resolves the absolute path of \p U with the first matching scheme
+  /// registered.
+  static llvm::Expected<std::string> resolve(const FileURI &U,
+                                             llvm::StringRef CurrentFile = "");
+
+  friend bool operator==(const FileURI &LHS, const FileURI &RHS) {
+    return std::tie(LHS.Scheme, LHS.Authority, LHS.Body) ==
+           std::tie(RHS.Scheme, RHS.Authority, RHS.Body);
+  }
+
+private:
+  FileURI() = default;
+
+  std::string Scheme;
+  std::string Authority;
+  std::string Body;
+};
+
+/// \brief 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. Users are not expected to use URIScheme directly.
+///
+/// Different codebases/projects can have different file schemes, and clangd
+/// interprets a file path according to the scheme. For example, a file path
+/// provided by a remote symbol index can follow a certain scheme (e.g. relative
+/// to a project root directory), and clangd needs to combine the scheme path
+/// with execution environment (e.g. working/build directory) in order to get a
+/// file path in the file system.
+class URIScheme {
+public:
+  virtual ~URIScheme() = default;
+
+  /// \brief Returns the absolute path of the file corresponding to the URI body
+  /// in the file system. \p CurrentFile is the file from which the request is
+  /// issued. This is needed because the same URI in different workspace may
+  /// correspond to different files.
+  virtual llvm::Expected<std::string>
+  getAbsolutePath(llvm::StringRef Body, llvm::StringRef CurrentFile) const = 0;
+
+  virtual llvm::Expected<std::string>
+  uriFromAbsolutePath(llvm::StringRef AbsolutePath) const = 0;
+};
+
+/// \brief Encodes a string according to percent-encoding.
+/// - Unrerved characters are not escaped.
+/// - Reserved characters always escaped with exceptions like '/'.
+/// - All other characters are escaped.
+std::string percentEncode(llvm::StringRef Content);
+
+/// \brief Decodes a string according to percent-encoding.
+llvm::Expected<std::string> percentDecode(llvm::StringRef Content);
+
+/// 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

+//===---- URI.h - File URIs with schemes -------------------------*- C++-*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "URI.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Path.h"
+#include <iomanip>
+#include <sstream>
+
+LLVM_INSTANTIATE_REGISTRY(clang::clangd::URISchemeRegistry)
+
+namespace clang {
+namespace clangd {
+namespace {
+
+inline llvm::Error make_string_error(const llvm::Twine &Message) {
+  return llvm::make_error<llvm::StringError>(Message,
+                                             llvm::inconvertibleErrorCode());
+}
+
+/// \brief This manages file paths in the file system. All paths in the scheme
+/// are absolute (with leading '/').
+class FileSystemScheme : public URIScheme {
+public:
+  static const char *Scheme;
+
+  llvm::Expected<std::string>
+  getAbsolutePath(llvm::StringRef Body,
+                  llvm::StringRef /*CurrentFile*/) const override {
+    if (!Body.startswith("/"))
+      return make_string_error(
+          "File scheme: expect body to be an absolute path starting with '/'");
+    // For Windows paths e.g. /X:
+    if (Body.size() > 2 && Body[0] == '/' && Body[2] == ':')
+      Body.consume_front("/");
+    return llvm::sys::path::convert_to_slash(Body);
+  }
+
+  llvm::Expected<std::string>
+  uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override {
+    using namespace llvm::sys;
+
+    if (!AbsolutePath.startswith("/"))
+      return make_string_error(
+          "File scheme: An AbsolutePath must start with '/'.");
+    std::string Body;
+    // For Windows paths e.g. X:
+    if (AbsolutePath.size() > 1 && AbsolutePath[1] == ':')
+      Body = "/";
+    Body += path::convert_to_slash(AbsolutePath, path::Style::posix);
+    return (llvm::Twine(Scheme) + ":" + percentEncode(Body)).str();
+  }
+};
+
+const char *FileSystemScheme::Scheme = "file";
+
+static URISchemeRegistry::Add<FileSystemScheme>
+    X(FileSystemScheme::Scheme,
+      "URI scheme for absolute paths in the file system.");
+
+llvm::Expected<std::unique_ptr<URIScheme>>
+findSchemeByName(llvm::StringRef Scheme) {
+  for (auto I = URISchemeRegistry::begin(), E = URISchemeRegistry::end();
+       I != E; ++I) {
+    if (I->getName() != Scheme)
+      continue;
+    return I->instantiate();
+  }
+  return make_string_error("Can't find scheme: " + Scheme);
+}
+
+constexpr static char Unreserved[] = {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+    'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b',
+    'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+    'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4',
+    '5', '6', '7', '8', '9', '0', '-', '_', '.', '~',
+};
+
+inline std::string percentize(char C) {
+  std::ostringstream OS;
+  OS << "%" << std::setfill('0') << std::setw(2) << std::hex
+     << static_cast<int>(C);
+  return OS.str();
+}
+
+std::vector<std::string> createEncodeMap() {
+  std::vector<std::string> Result(128, "");
+  for (char C : Unreserved)
+    Result[C] = C;
+  for (int i = 0; i < 128; i++)
+    if (Result[i].empty())
+      Result[i] = percentize(static_cast<char>(i));
+  // Avoid escaping '/' to save URI readability.
+  Result['/'] = '/';
+  return Result;
+}
+
+} // namespace
+
+std::string percentEncode(llvm::StringRef Content) {
+  static const std::vector<std::string> EncodeMap = createEncodeMap();
+  std::string Result;
+  for (char C : Content)
+    Result += EncodeMap[C];
+  return Result;
+}
+
+llvm::Expected<std::string> percentDecode(llvm::StringRef Content) {
+  std::string Result;
+  for (auto I = Content.begin(), E = Content.end(); I != E; ++I) {
+    if (*I != '%') {
+      Result += *I;
+      continue;
+    }
+    if (I + 1 == E || I + 2 == E)
+      return make_string_error("Expect two characters after '%' sign: Content");
+    char Buf[3];
+    Buf[0] = *(++I);
+    Buf[1] = *(++I);
+    Buf[2] = '\0';
+    Result += static_cast<char>(strtoul(Buf, nullptr, 16));
+  }
+  return Result;
+}
+
+llvm::Expected<FileURI> FileURI::parse(llvm::StringRef Uri) {
+  FileURI U;
+  llvm::StringRef OrigUri = Uri;
+
+  auto Pos = Uri.find(':');
+  if (Pos == llvm::StringRef::npos)
+    return make_string_error("Expect ':' in a URI: " + OrigUri);
+  auto Decoded = percentDecode(Uri.substr(0, Pos));
+  if (!Decoded)
+    return Decoded.takeError();
+  U.Scheme = *Decoded;
+
+  Uri = Uri.substr(Pos + 1);
+  if (Uri.consume_front("//")) {
+    Pos = Uri.find('/');
+    if (Pos == llvm::StringRef::npos)
+      return make_string_error("Expect '/' after a URI authority: " + OrigUri);
+
+    Decoded = percentDecode(Uri.substr(0, Pos));
+    if (!Decoded)
+      return Decoded.takeError();
+    if (Decoded->empty())
+      return make_string_error(
+          "'//' is present after scheme while authority is not provided: " +
+          OrigUri);
+    U.Authority = *Decoded;
+    Uri = Uri.substr(Pos + 1);
+  }
+  Decoded = percentDecode(Uri);
+  if (!Decoded)
+    return Decoded.takeError();
+  U.Body = *Decoded;
+
+  if (U.Scheme.empty() || U.Body.empty())
+    return make_string_error("Scheme and body must be provided in URI: " +
+                             OrigUri);
+
+  return U;
+}
+
+llvm::Expected<std::string> FileURI::create(llvm::StringRef AbsolutePath,
+                                            llvm::StringRef Scheme) {
+  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 CurrentFile) {
+  auto S = findSchemeByName(Uri.Scheme);
+  if (!S)
+    return S.takeError();
+  return S->get()->getAbsolutePath(Uri.Body, CurrentFile);
+}
+
+} // namespace clangd
+} // namespace clang

unittests/clangd/CMakeLists.txt

add_extra_unittest(ClangdTests
   ClangdTests.cpp
   CodeCompleteTests.cpp
   CodeCompletionStringsTests.cpp
   ContextTests.cpp
   FileIndexTests.cpp
   FuzzyMatchTests.cpp
   IndexTests.cpp
   JSONExprTests.cpp
+  URITests.cpp
   TestFS.cpp
   TraceTests.cpp
   SourceCodeTests.cpp
   SymbolCollectorTests.cpp
   XRefsTests.cpp
   )
 
 target_link_libraries(ClangdTests

unittests/clangd/URITests.cpp

+//===-- URITests.cpp  ---------------------------------*- C++ -*-----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "URI.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+using ::testing::AllOf;
+
+MATCHER_P(Scheme, S, "") { return arg.scheme() == S; }
+MATCHER_P(Authority, A, "") { return arg.authority() == A; }
+MATCHER_P(Body, B, "") { return arg.body() == B; }
+
+std::string decodeOrDie(llvm::StringRef S) {
+  auto D = percentDecode(S);
+  if (!D)
+    llvm_unreachable(llvm::toString(D.takeError()).c_str());
+  return *D;
+}
+
+TEST(PercentEncodingTest, Encode) {
+  EXPECT_EQ(percentEncode("a/b/c"), "a/b/c");
+  EXPECT_EQ(percentEncode("a!b;c~"), "a%21b%3bc~");
+}
+
+TEST(PercentEncodingTest, Decode) {
+  EXPECT_EQ(decodeOrDie("a/b/c"), "a/b/c");
+  EXPECT_EQ(decodeOrDie("a%21b%3ac~"), "a!b:c~");
+}
+
+// Assume all files in the schema have a "test-root/" root directory, and the
+// schema path is the relative path to the root directory.
+// So the schema of "/some-dir/test-root/x/y/z" is "test:x/y/z".
+class TestScheme : public URIScheme {
+public:
+  static const char *Scheme;
+
+  static const char *TestRoot;
+
+  llvm::Expected<std::string>
+  getAbsolutePath(llvm::StringRef Body,
+                  llvm::StringRef CurrentFile) const override {
+    auto Pos = CurrentFile.find(TestRoot);
+    assert(Pos != llvm::StringRef::npos);
+    return (CurrentFile.substr(0, Pos + llvm::StringRef(TestRoot).size()) +
+            Body)
+        .str();
+  }
+
+  llvm::Expected<std::string>
+  uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override {
+    auto Pos = AbsolutePath.find(TestRoot);
+    assert(Pos != llvm::StringRef::npos);
+    return (llvm::Twine(Scheme) + ":" +
+            AbsolutePath.substr(Pos + Pos + llvm::StringRef(TestRoot).size()))
+        .str();
+  }
+};
+
+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);
+  if (!Uri)
+    llvm_unreachable(llvm::toString(Uri.takeError()).c_str());
+  return *Uri;
+}
+
+FileURI parseOrDie(llvm::StringRef Uri) {
+  auto U = FileURI::parse(Uri);
+  if (!U)
+    llvm_unreachable(llvm::toString(U.takeError()).c_str());
+  llvm::errs() << "URI: " << U->scheme() << ", " << U->authority() << ", "
+               << U->body() << "\n";
+  return *U;
+}
+
+std::string resolveOrDie(const FileURI &U, llvm::StringRef CurrentFile = "") {
+  auto Path = FileURI::resolve(U, CurrentFile);
+  if (!Path)
+    llvm_unreachable(llvm::toString(Path.takeError()).c_str());
+  return *Path;
+}
+
+TEST(URITest, Create) {
+  EXPECT_THAT(createOrDie("/x/y/z"), "file:/x/y/z");
+  EXPECT_THAT(createOrDie("/(x)/y/\\ z"), "file:/%28x%29/y/%5c%20z");
+}
+
+TEST(URITest, FailedCreate) {
+  auto Uri = FileURI::create("/x/y/z", "no");
+  EXPECT_FALSE(static_cast<bool>(Uri));
+  llvm::consumeError(Uri.takeError());
+
+  // Path has to be absolute.
+  Uri = FileURI::create("x/y/z");
+  EXPECT_FALSE(static_cast<bool>(Uri));
+  llvm::consumeError(Uri.takeError());
+}
+
+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("file:/%28x%29/y/%5c%20z"),
+              AllOf(Scheme("file"), Authority(""), Body("/(x)/y/\\ z")));
+}
+
+TEST(URITest, ParseFailed) {
+  auto FailedParse = [](llvm::StringRef U) {
+    auto URI = FileURI::parse("file//x/y/z");
+    if (!URI) {
+      llvm::consumeError(URI.takeError());
+      return true;
+    }
+    return false;
+  };
+
+  // Expect ':' in URI.
+  EXPECT_TRUE(FailedParse("file//x/y/z"));
+  // Expect two bytes after %.
+  EXPECT_TRUE(FailedParse("file://x/y/z%2"));
+  // Empty.
+  EXPECT_TRUE(FailedParse(""));
+  EXPECT_TRUE(FailedParse(":/a/b/c"));
+  EXPECT_TRUE(FailedParse("s:"));
+  // Incomplete.
+  EXPECT_TRUE(FailedParse("x:"));
+  EXPECT_TRUE(FailedParse("x://a"));
+  // Empty authority.
+  EXPECT_TRUE(FailedParse("file:////x/y/z"));
+}
+
+TEST(URITest, Resolve) {
+  EXPECT_EQ(resolveOrDie(parseOrDie("file:/a/b/c")), "/a/b/c");
+  EXPECT_EQ(resolveOrDie(parseOrDie("file://auth//a/b/c")), "/a/b/c");
+  EXPECT_EQ(resolveOrDie(parseOrDie("test:a/b/c"), "/dir/test-root/x/y/z"),
+            "/dir/test-root/a/b/c");
+
+  EXPECT_THAT(resolveOrDie(parseOrDie("file://au%3dth//%28x%29/y/%5c%20z")),
+              "/(x)/y/\\ z");
+}
+
+TEST(URITest, ResolveFailed) {
+  auto FailedResolve = [](llvm::StringRef Uri) {
+    auto Path = FileURI::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"));
+  // File path needs to be absolute.
+  EXPECT_TRUE(FailedResolve("file://c/x/y/z"));
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang