[clangd] Allow using customized include path in URI.

[hokein]

Summary

Calculating the include path from absolute file path does not always
work for all build system, e.g. bazel uses symlink as the build working
directory. The absolute file path from editor and clang is diverged from
each other. We need to address it properly in build sysmtem integration.

This patch worksarounds the issue by providing a hook in URI which allows
clients to provide their customized include path.

[sammccall]

clangd/URI.h

63

Avoid "tries to" which is vague about what cases are failures.
e.g.
Get the preferred spelling of this file for #include, if there is one, e.g. <GL.h>.
Returns the empty string if normal include-shortening based on the path should be used.
Fails if the URI is not valid in the schema.

64

what are "clients"? maybe "URI schemas"?

66

does this include <quotes>? it probably should, if we're allowing schemes to customize how includes are spelled.

69

i'd avoid the name "include path" because it can be confused with a) the set of directories passed to -I and b) the filesystem path to the file to be included.
Suggest includeString or so

109

#included

unittests/clangd/ClangdTests.cpp

986

this relies on ClangdTests and URITests being linked together, which we chose to avoid last time this came up. Just define a scheme here?
(This is one place where putting a field on URI would have been simpler)

[hokein]

Address review comments.

[hokein]

clangd/URI.h

66

Yes, the returned string is a literal string quoted with either <> or "".

69

Renamed it to spellingInclude.

unittests/clangd/ClangdTests.cpp

986

I think we probably want a scheme for unittest purpose (we also have one for lit test), but this case only needs a trivial one, added here.

[sammccall]

clangd/URI.h

69

nit: I think includeSpelling would be clearer, since include is the adjective. Up to you

[hokein]

includeSpelling

clangd/ClangdServer.cpp

 /// include.
 static llvm::Expected<HeaderFile> toHeaderFile(StringRef Header,
                                                llvm::StringRef HintPath) {
   if (isLiteralInclude(Header))
     return HeaderFile{Header.str(), /*Verbatim=*/true};
   auto U = URI::parse(Header);
   if (!U)
     return U.takeError();
+
+  auto IncludePath = URI::includeSpelling(*U);
+  if (!IncludePath)
+    return IncludePath.takeError();
+  if (!IncludePath->empty())
+    return HeaderFile{std::move(*IncludePath), /*Verbatim=*/true};
+
   auto Resolved = URI::resolve(*U, HintPath);
   if (!Resolved)
     return Resolved.takeError();
   return HeaderFile{std::move(*Resolved), /*Verbatim=*/false};
 }
 
 Expected<tooling::Replacements>
 ClangdServer::insertInclude(PathRef File, StringRef Code,

clangd/URI.h

public:
   /// 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 URI &U,
                                              llvm::StringRef HintPath = "");
 
+  /// Gets the preferred spelling of this file for #include, if there is one,
+  /// e.g. <system_header.h>, "path/to/x.h".
+  ///
+  /// This allows URI schemas to provide their customized include paths.
+  ///
+  /// Returns an empty string if normal include-shortening based on the absolute
+  /// path should be used.
+  /// Fails if the URI is not valid in the schema.
+  static llvm::Expected<std::string> includeSpelling(const URI &U);
+
   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);
public:
   /// 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<URI>
   uriFromAbsolutePath(llvm::StringRef AbsolutePath) const = 0;
+
+  /// Returns the include path of the file (e.g. <path>, "path"), which can be
+  /// #included directly. See URI::includeSpelling for details.
+  virtual llvm::Expected<std::string>
+  getIncludeSpelling(const URI& U) const {
+    return "";  // no customized include path for this scheme.
+  }
 };
 
 /// 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

 llvm::Expected<std::string> URI::resolve(const URI &Uri,
                                          llvm::StringRef HintPath) {
   auto S = findSchemeByName(Uri.Scheme);
   if (!S)
     return S.takeError();
   return S->get()->getAbsolutePath(Uri.Authority, Uri.Body, HintPath);
 }
 
+llvm::Expected<std::string> URI::includeSpelling(const URI &Uri) {
+  auto S = findSchemeByName(Uri.Scheme);
+  if (!S)
+    return S.takeError();
+  return S->get()->getIncludeSpelling(Uri);
+}
+
 } // namespace clangd
 } // namespace clang

unittests/clangd/ClangdTests.cpp

std::string parseSourceAndDumpAST(
     Server.addDocument(SourceFilename, SourceContents);
     auto Result = dumpASTWithoutMemoryLocs(Server, SourceFilename);
     EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
     EXPECT_EQ(ExpectErrors, DiagConsumer.hadErrorInLastDiags());
     return Result;
   }
 };
 
+constexpr const char* ClangdTestScheme = "ClangdTests";
+class TestURIScheme : public URIScheme {
+public:
+  llvm::Expected<std::string>
+  getAbsolutePath(llvm::StringRef /*Authority*/, llvm::StringRef Body,
+                  llvm::StringRef /*HintPath*/) const override {
+    llvm_unreachable("ClangdTests never makes absolute path.");
+  }
+
+  llvm::Expected<URI>
+  uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override {
+    llvm_unreachable("ClangdTest never creates a test URI.");
+  }
+
+  llvm::Expected<std::string> getIncludeSpelling(const URI &U) const override {
+    return ("\"" + U.body().trim("/") + "\"").str();
+  }
+};
+
+static URISchemeRegistry::Add<TestURIScheme>
+    X(ClangdTestScheme, "Test scheme for ClangdTests.");
+
 TEST_F(ClangdVFSTest, Parse) {
   // FIXME: figure out a stable format for AST dumps, so that we can check the
   // output of the dump itself is equal to the expected one, not just that it's
   // different.
   auto Empty = parseSourceAndDumpAST("foo.cpp", "", {});
   auto OneDecl = parseSourceAndDumpAST("foo.cpp", "int a;", {});
   auto SomeDecls = parseSourceAndDumpAST("foo.cpp", "int a; int b; int c;", {});
   EXPECT_NE(Empty, OneDecl);
)cpp";
   std::string OriginalHeader = URI::createFile(testPath("y.h")).toString();
   std::string PreferredHeader = URI::createFile(testPath("Y.h")).toString();
   EXPECT_TRUE(Inserted(OriginalHeader,
                        /*Preferred=*/"", "\"y.h\""));
   EXPECT_TRUE(Inserted(OriginalHeader,
                        /*Preferred=*/"<Y.h>", "<Y.h>"));
   EXPECT_TRUE(Inserted(OriginalHeader, PreferredHeader, "\"Y.h\""));
   EXPECT_TRUE(Inserted("<y.h>", PreferredHeader, "\"Y.h\""));
+  auto TestURIHeader =
+      URI::parse(llvm::formatv("{0}:///x/y/z.h", ClangdTestScheme).str());
+  EXPECT_TRUE(static_cast<bool>(TestURIHeader));
+  EXPECT_TRUE(Inserted(TestURIHeader->toString(), "", "\"x/y/z.h\""));
 
   // Check that includes are sorted.
   const auto Expected = R"cpp(
 #include "x.h"
 #include "y.h"
 #include "z.h"
 
 void f() {}