[clangd] Remove ./ and ../ in the file paths

[hokein]

It would be nicer to have a unittest (if it doesn't take too much effort to create one).

[kadircet]

• Add tests

clangd/index/Background.cpp

 // directory.
 llvm::SmallString<128> getAbsolutePath(const tooling::CompileCommand &Cmd) {
   llvm::SmallString<128> AbsolutePath;
   if (llvm::sys::path::is_absolute(Cmd.Filename)) {
     AbsolutePath = Cmd.Filename;
   } else {
     AbsolutePath = Cmd.Directory;
     llvm::sys::path::append(AbsolutePath, Cmd.Filename);
+    llvm::sys::path::remove_dots(AbsolutePath, true);
   }
   return AbsolutePath;
 }
 } // namespace
 
 BackgroundIndex::BackgroundIndex(
     Context BackgroundContext, const FileSystemProvider &FSProvider,
     const GlobalCompilationDatabase &CDB,

unittests/clangd/BackgroundIndexTests.cpp

class MemoryShardStorage : public BackgroundIndexStorage {
   size_t &CacheHits;
 
 public:
   MemoryShardStorage(llvm::StringMap<std::string> &Storage, size_t &CacheHits)
       : Storage(Storage), CacheHits(CacheHits) {}
   llvm::Error storeShard(llvm::StringRef ShardIdentifier,
                          IndexFileOut Shard) const override {
     std::lock_guard<std::mutex> Lock(StorageMu);
+    AccessedPaths.insert(ShardIdentifier);
     Storage[ShardIdentifier] = llvm::to_string(Shard);
     return llvm::Error::success();
   }
   std::unique_ptr<IndexFileIn>
   loadShard(llvm::StringRef ShardIdentifier) const override {
     std::lock_guard<std::mutex> Lock(StorageMu);
+    AccessedPaths.insert(ShardIdentifier);
     if (Storage.find(ShardIdentifier) == Storage.end()) {
       return nullptr;
     }
     auto IndexFile = readIndexFile(Storage[ShardIdentifier]);
     if (!IndexFile) {
       ADD_FAILURE() << "Error while reading " << ShardIdentifier << ':'
                     << IndexFile.takeError();
       return nullptr;
     }
     CacheHits++;
     return llvm::make_unique<IndexFileIn>(std::move(*IndexFile));
   }
+
+  mutable llvm::StringSet<> AccessedPaths;
 };
 
 class BackgroundIndexTest : public ::testing::Test {
 protected:
   BackgroundIndexTest() { preventThreadStarvationInTests(); }
 };
 
 TEST_F(BackgroundIndexTest, NoCrashOnErrorFile) {
TEST_F(BackgroundIndexTest, ShardStorageEmptyFile) {
   }
   EXPECT_EQ(CacheHits, 3U);
   ShardHeader = MSS.loadShard(testPath("root/B.h"));
   EXPECT_NE(ShardHeader, nullptr);
   EXPECT_THAT(*ShardHeader->Symbols,
               Contains(AllOf(Named("new_func"), Declared(), Not(Defined()))));
 }
 
+TEST_F(BackgroundIndexTest, NoDotsInAbsPath) {
+  MockFSProvider FS;
+  llvm::StringMap<std::string> Storage;
+  size_t CacheHits = 0;
+  MemoryShardStorage MSS(Storage, CacheHits);
+  OverlayCDB CDB(/*Base=*/nullptr);
+  BackgroundIndex Idx(Context::empty(), FS, CDB,
+                      [&](llvm::StringRef) { return &MSS; });
+
+  tooling::CompileCommand Cmd;
+  FS.Files[testPath("root/A.cc")] = "";
+  Cmd.Filename = "../A.cc";
+  Cmd.Directory = testPath("root/build");
+  Cmd.CommandLine = {"clang++", "../A.cc"};
+  CDB.setCompileCommand(testPath("root/build/../A.cc"), Cmd);
+
+  FS.Files[testPath("root/B.cc")] = "";
+  Cmd.Filename = "./B.cc";
+  Cmd.Directory = testPath("root");
+  Cmd.CommandLine = {"clang++", "./B.cc"};
+  CDB.setCompileCommand(testPath("root/./B.cc"), Cmd);
+
+  ASSERT_TRUE(Idx.blockUntilIdleForTest());
+  for (llvm::StringRef AbsPath : MSS.AccessedPaths.keys()) {
+    EXPECT_FALSE(AbsPath.contains("./")) << AbsPath;
+    EXPECT_FALSE(AbsPath.contains("../")) << AbsPath;
+  }
+}
+
 } // namespace clangd
 } // namespace clang