[include-cleaner] Record whether includes are spelled with <angle> quotes

[sammccall]

Summary

This is needed to accurately remove headers with tooling::IncludeHeaders in the
rare cases where <foo> and "foo" resolve to something different.

This is also nice to have in HTML report and command-line -print=changes output.

[sammccall]

add test

[kadircet]

thanks, lgtm!

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

 
 /// A single #include directive written in the main file.
 struct Include {
   llvm::StringRef Spelled;             // e.g. vector
   const FileEntry *Resolved = nullptr; // e.g. /path/to/c++/v1/vector
                                        // nullptr if the header was not found
   SourceLocation HashLocation;         // of hash in #include <vector>
   unsigned Line = 0;                   // 1-based line number for #include
+  bool Angled = false;                 // True if spelled with <angle> quotes.
+  std::string quote() const;           // e.g. <vector>
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Include &);
 
 } // namespace include_cleaner
 } // namespace clang
 
 namespace llvm {
 

clang-tools-extra/include-cleaner/lib/HTMLReport.cpp

for (const auto &H : R.Headers) {
         escapeString(H.verbatim());
         break;
       }
       OS << "</td></tr>\n";
     }
 
     for (const auto *I : R.Includes) {
       OS << "<tr><th>Included</th><td>";
-      escapeString(I->Spelled);
+      escapeString(I->quote());
       OS << ", <a href='#line" << I->Line << "'>line " << I->Line << "</a>";
       OS << "</td></tr>";
     }
 
     if (!R.Insert.empty()) {
       OS << "<tr><th>Insert</th><td class='insert'>";
       escapeString(R.Insert);
       OS << "</td></tr>";

clang-tools-extra/include-cleaner/lib/Record.cpp

void InclusionDirective(SourceLocation Hash, const Token &IncludeTok,
     if (!Active)
       return;
 
     Include I;
     I.HashLocation = Hash;
     I.Resolved = File ? &File->getFileEntry() : nullptr;
     I.Line = SM.getSpellingLineNumber(Hash);
     I.Spelled = SpelledFilename;
+    I.Angled = IsAngled;
     Recorded.Includes.add(I);
   }
 
   void MacroExpands(const Token &MacroName, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {
     if (!Active)
       return;
     recordMacroRef(MacroName, *MD.getMacroInfo());

clang-tools-extra/include-cleaner/lib/Types.cpp

case Header::Standard:
     return OS << H.standard().name();
   case Header::Verbatim:
     return OS << H.verbatim();
   }
   llvm_unreachable("Unhandled Header kind");
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Include &I) {
-  return OS << I.Line << ": " << I.Spelled << " => "
+  return OS << I.Line << ": " << I.quote() << " => "
             << (I.Resolved ? I.Resolved->getName() : "<missing>");
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolReference &R) {
   // We can't decode the Location without SourceManager. Its raw representation
   // isn't completely useless (and distinguishes SymbolReference from Symbol).
   return OS << R.Target << "@0x"
             << llvm::utohexstr(
                    R.RefLocation.getRawEncoding(), /*LowerCase=*/false,
                    /*Width=*/CHAR_BIT * sizeof(SourceLocation::UIntTy));
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, RefType T) {
   switch (T) {
   case RefType::Explicit:
     return OS << "explicit";
   case RefType::Implicit:
     return OS << "implicit";
   case RefType::Ambiguous:
     return OS << "ambiguous";
   }
   llvm_unreachable("Unexpected RefType");
 }
 
+std::string Include::quote() const {
+  return (llvm::StringRef(Angled ? "<" : "\"") + Spelled +
+          (Angled ? ">" : "\""))
+      .str();
+}
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/unittests/RecordTest.cpp

 };
 
 // Matches an Include with a particular spelling.
 MATCHER_P(spelled, S, "") { return arg.Spelled == S; }
 
 TEST_F(RecordPPTest, CapturesIncludes) {
   llvm::Annotations MainFile(R"cpp(
     $H^#include "./header.h"
-    $M^#include "missing.h"
+    $M^#include <missing.h>
   )cpp");
   Inputs.Code = MainFile.code();
   Inputs.ExtraFiles["header.h"] = "";
   Inputs.ErrorOK = true; // missing header
   auto AST = build();
 
   ASSERT_THAT(
       Recorded.Includes.all(),
       testing::ElementsAre(spelled("./header.h"), spelled("missing.h")));
 
   auto &H = Recorded.Includes.all().front();
   EXPECT_EQ(H.Line, 2u);
   EXPECT_EQ(H.HashLocation,
             AST.sourceManager().getComposedLoc(
                 AST.sourceManager().getMainFileID(), MainFile.point("H")));
   EXPECT_EQ(H.Resolved, AST.fileManager().getFile("header.h").get());
+  EXPECT_FALSE(H.Angled);
 
   auto &M = Recorded.Includes.all().back();
   EXPECT_EQ(M.Line, 3u);
   EXPECT_EQ(M.HashLocation,
             AST.sourceManager().getComposedLoc(
                 AST.sourceManager().getMainFileID(), MainFile.point("M")));
   EXPECT_EQ(M.Resolved, nullptr);
+  EXPECT_TRUE(M.Angled);
 }
 
 TEST_F(RecordPPTest, CapturesMacroRefs) {
   llvm::Annotations Header(R"cpp(
     #define $def^X 1
 
     // Refs, but not in main file.
     #define Y X