[find-all-symbols] remove dots in SymbolInfo file paths.

[ioeric]

Summary

remove dots in SymbolInfo file paths.

[bkramer]

Adding Manuel as a second opinion. I think this is fine but paths are a messy problem, in particular removing .. can break symlinked directories.

[klimek]

I think this is ok, mainly because the clean paths are explicitly for user code, where users usually like to have, well, clean paths.

clang-tools-extra/trunk/include-fixer/find-all-symbols/FindAllMacros.cpp

 //===-- FindAllMacros.cpp - find all macros ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "FindAllMacros.h"
 #include "HeaderMapCollector.h"
 #include "SymbolInfo.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Token.h"
+#include "llvm/Support/Path.h"
 
 namespace clang {
 namespace find_all_symbols {
 
 void FindAllMacros::MacroDefined(const Token &MacroNameTok,
                                  const MacroDirective *MD) {
   SourceLocation Loc = SM->getExpansionLoc(MacroNameTok.getLocation());
   if (Loc.isInvalid() || SM->isInMainFile(Loc))
     return;
 
   llvm::StringRef FilePath = SM->getFilename(Loc);
   if (FilePath.empty())
     return;
 
   // If Collector is not nullptr, check pragma remapping header.
   FilePath = Collector ? Collector->getMappedHeader(FilePath) : FilePath;
 
+  SmallString<256> CleanedFilePath = FilePath;
+  llvm::sys::path::remove_dots(CleanedFilePath, /*remove_dot_dot=*/true);
+
   SymbolInfo Symbol(MacroNameTok.getIdentifierInfo()->getName(),
-                    SymbolInfo::SymbolKind::Macro, FilePath.str(),
+                    SymbolInfo::SymbolKind::Macro, CleanedFilePath,
                     SM->getSpellingLineNumber(Loc), {});
 
   Reporter->reportSymbol(SM->getFileEntryForID(SM->getMainFileID())->getName(),
                          Symbol);
 }
 
 } // namespace find_all_symbols
 } // namespace clang

clang-tools-extra/trunk/include-fixer/find-all-symbols/FindAllSymbols.cpp

CreateSymbolInfo(const NamedDecl *ND, const SourceManager &SM,
   }
   llvm::StringRef FilePath = SM.getFilename(Loc);
   if (FilePath.empty())
     return llvm::None;
 
   // If Collector is not nullptr, check pragma remapping header.
   FilePath = Collector ? Collector->getMappedHeader(FilePath) : FilePath;
 
-  return SymbolInfo(ND->getNameAsString(), Type, FilePath.str(),
+  SmallString<256> CleanedFilePath = FilePath;
+  llvm::sys::path::remove_dots(CleanedFilePath, /*remove_dot_dot=*/true);
+
+  return SymbolInfo(ND->getNameAsString(), Type, CleanedFilePath,
                     SM.getExpansionLineNumber(Loc), GetContexts(ND));
 }
 
 } // namespace
 
 void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // FIXME: Handle specialization.
   auto IsInSpecialization = hasAncestor(

clang-tools-extra/trunk/unittests/include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

tooling::ToolInvocation Invocation(
         {std::string("find_all_symbols"), std::string("-fsyntax-only"),
          std::string("-std=c++11"), FileName},
         Factory->create(), Files.get(),
         std::make_shared<PCHContainerOperations>());
 
     InMemoryFileSystem->addFile(HeaderName, 0,
                                 llvm::MemoryBuffer::getMemBuffer(Code));
 
+    // Test path cleaning for both decls and macros.
+    const std::string DirtyHeader = "./internal/../internal/./a/b.h";
+    const std::string CleanHeader = "internal/a/b.h";
+    const std::string DirtyHeaderContent =
+        "#define INTERNAL 1\nclass ExtraInternal {};";
+    InMemoryFileSystem->addFile(
+        DirtyHeader, 0, llvm::MemoryBuffer::getMemBuffer(DirtyHeaderContent));
+    SymbolInfo DirtyMacro("INTERNAL", SymbolInfo::SymbolKind::Macro,
+                          CleanHeader, 1, {});
+    SymbolInfo DirtySymbol("ExtraInternal", SymbolInfo::SymbolKind::Class,
+                           CleanHeader, 2, {});
+
     std::string Content = "#include\"" + std::string(HeaderName) +
                           "\"\n"
-                          "#include \"internal/internal.h\"";
+                          "#include \"internal/internal.h\"\n"
+                          "#include \"" + DirtyHeader + "\"";
     InMemoryFileSystem->addFile(FileName, 0,
                                 llvm::MemoryBuffer::getMemBuffer(Content));
     Invocation.run();
     EXPECT_TRUE(hasSymbol(InternalSymbol));
+    EXPECT_TRUE(hasSymbol(DirtySymbol));
+    EXPECT_TRUE(hasSymbol(DirtyMacro));
     return true;
   }
 
 protected:
   TestSymbolReporter Reporter;
 };
 
 TEST_F(FindAllSymbolsTest, VariableSymbols) {