[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

107

#included

unittests/clangd/ClangdTests.cpp

964

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

964

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::includePath(*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 = "");
 
+  /// Tries to get the include path of the file corresponding to the URI.
+  /// This allows clients to provide their customized include paths.
+  ///
+  /// If the returned string is non-empty, clangd will use it directly when
+  /// doing include insertion; otherwise we will fall back to the clang to
+  /// calculate the include path from the resolved absolute path.
+  static llvm::Expected<std::string> includePath(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 corresponding to the URI, which can
+  /// be #include directly. See URI::resolveIncludePath for details.
+  virtual llvm::Expected<std::string>
+  getIncludePath(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::includePath(const URI &Uri) {
+  auto S = findSchemeByName(Uri.Scheme);
+  if (!S)
+    return S.takeError();
+  return S->get()->getIncludePath(Uri);
+}
+
 } // namespace clangd
 } // namespace clang

unittests/clangd/ClangdTests.cpp

)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::create("/abc/test-root/x/y/z.h", "unittest");
+  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() {}

unittests/clangd/URITests.cpp

public:
 
   llvm::Expected<URI>
   uriFromAbsolutePath(llvm::StringRef AbsolutePath) const override {
     auto Pos = AbsolutePath.find(TestRoot);
     assert(Pos != llvm::StringRef::npos);
     return URI(Scheme, /*Authority=*/"",
                AbsolutePath.substr(Pos + llvm::StringRef(TestRoot).size()));
   }
+
+  llvm::Expected<std::string> getIncludePath(const URI &U) const override {
+    return ("\"" + U.body() + "\"").str();
+  }
 };
 
 const char *TestScheme::Scheme = "unittest";
 const char *TestScheme::TestRoot = "/test-root/";
 
 static URISchemeRegistry::Add<TestScheme> X(TestScheme::Scheme, "Test schema");
 
 std::string createOrDie(llvm::StringRef AbsolutePath,