[include-cleaner] Fix the `fixIncludes` API not respect main-file header.

[hokein]

Summary

The fixIncludes was using the input as the main file path, this will
results in inserting header at wrong places.

We need the main file path to so that we can get the real main-file
header.

[kadircet]

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

303–304

can you also have a test in which we insert "d.h" and it gets put into the right place?

[hokein]

add a testcase.

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

303–304

added a test with a FIXME -- unfortunately, this case doesn't work yet (I believe this is a bug in the tooling::HeaderIncludes, I plan to fix it afterwards.)

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

analyze(llvm::ArrayRef<Decl *> ASTRoots,
         llvm::ArrayRef<SymbolReference> MacroRefs, const Includes &I,
         const PragmaIncludes *PI, const SourceManager &SM,
         const HeaderSearch &HS,
         llvm::function_ref<bool(llvm::StringRef)> HeaderFilter = nullptr);
 
 /// Removes unused includes and inserts missing ones in the main file.
 /// Returns the modified main-file code.
 /// The FormatStyle must be C++ or ObjC (to support include ordering).
-std::string fixIncludes(const AnalysisResults &Results, llvm::StringRef Code,
+std::string fixIncludes(const AnalysisResults &Results,
+                        llvm::StringRef FileName, llvm::StringRef Code,
                         const format::FormatStyle &IncludeStyle);
 
 /// Gets all the providers for a symbol by traversing each location.
 /// Returned headers are sorted by relevance, first element is the most
 /// likely provider for the symbol.
 llvm::SmallVector<Header> headersForSymbol(const Symbol &S,
                                            const SourceManager &SM,
                                            const PragmaIncludes *PI);
 } // namespace include_cleaner
 } // namespace clang
 
 #endif

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

for (const Include &I : Inc.all()) {
     Results.Unused.push_back(&I);
   }
   for (llvm::StringRef S : Missing.keys())
     Results.Missing.push_back(S.str());
   llvm::sort(Results.Missing);
   return Results;
 }
 
-std::string fixIncludes(const AnalysisResults &Results, llvm::StringRef Code,
+std::string fixIncludes(const AnalysisResults &Results,
+                        llvm::StringRef FileName, llvm::StringRef Code,
                         const format::FormatStyle &Style) {
   assert(Style.isCpp() && "Only C++ style supports include insertions!");
   tooling::Replacements R;
   // Encode insertions/deletions in the magic way clang-format understands.
   for (const Include *I : Results.Unused)
-    cantFail(R.add(tooling::Replacement("input", UINT_MAX, 1, I->quote())));
+    cantFail(R.add(tooling::Replacement(FileName, UINT_MAX, 1, I->quote())));
   for (llvm::StringRef Spelled : Results.Missing)
-    cantFail(R.add(tooling::Replacement("input", UINT_MAX, 0,
+    cantFail(R.add(tooling::Replacement(FileName, UINT_MAX, 0,
                                         ("#include " + Spelled).str())));
   // "cleanup" actually turns the UINT_MAX replacements into concrete edits.
   auto Positioned = cantFail(format::cleanupAroundReplacements(Code, R, Style));
   return cantFail(tooling::applyAllReplacements(Code, Positioned));
 }
 
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/tool/IncludeCleaner.cpp

void EndSourceFile() override {
     llvm::StringRef Code = SM.getBufferData(SM.getMainFileID());
 
     auto Results = analyze(AST.Roots, PP.MacroReferences, PP.Includes, &PI, SM,
                            HS, HeaderFilter);
     if (!Insert)
       Results.Missing.clear();
     if (!Remove)
       Results.Unused.clear();
-    std::string Final = fixIncludes(Results, Code, getStyle(Path));
+    std::string Final = fixIncludes(Results, Path, Code, getStyle(Path));
 
     if (Print.getNumOccurrences()) {
       switch (Print) {
       case PrintStyle::Changes:
         for (const Include *I : Results.Unused)
           llvm::outs() << "- " << I->quote() << " @Line:" << I->Line << "\n";
         for (const auto &I : Results.Missing)
           llvm::outs() << "+ " << I << "\n";

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

TEST_F(AnalyzeTest, NoCrashWhenUnresolved) {
   TestAST AST(Inputs);
   EXPECT_FALSE(PP.Includes.all().empty());
   auto Results = analyze({}, {}, PP.Includes, &PI, AST.sourceManager(),
                          AST.preprocessor().getHeaderSearchInfo());
   EXPECT_THAT(Results.Unused, testing::IsEmpty());
 }
 
 TEST(FixIncludes, Basic) {
-  llvm::StringRef Code = R"cpp(
+  llvm::StringRef Code = R"cpp(#include "d.h"
 #include "a.h"
 #include "b.h"
 #include <c.h>
 )cpp";
 
   Includes Inc;
   Include I;
   I.Spelled = "a.h";
)cpp";
 
   AnalysisResults Results;
   Results.Missing.push_back("\"aa.h\"");
   Results.Missing.push_back("\"ab.h\"");
   Results.Missing.push_back("<e.h>");
   Results.Unused.push_back(Inc.atLine(3));
   Results.Unused.push_back(Inc.atLine(4));
 
-  EXPECT_EQ(fixIncludes(Results, Code, format::getLLVMStyle()), R"cpp(
+  EXPECT_EQ(fixIncludes(Results, "d.cc", Code, format::getLLVMStyle()),
+R"cpp(#include "d.h"
 #include "a.h"
 #include "aa.h"
 #include "ab.h"
 #include <e.h>
 )cpp");
+
+  Results = {};
+  Results.Missing.push_back("\"d.h\"");
+  Code = R"cpp(#include "a.h")cpp";
+  // FIXME: this isn't correct, the main-file header d.h should be added before
+  // a.h.
+  EXPECT_EQ(fixIncludes(Results, "d.cc", Code, format::getLLVMStyle()),
+R"cpp(#include "a.h"
+#include "d.h"
+)cpp");
 }
 
 MATCHER_P3(expandedAt, FileID, Offset, SM, "") {
   auto [ExpanedFileID, ExpandedOffset] = SM->getDecomposedExpansionLoc(arg);
   return ExpanedFileID == FileID && ExpandedOffset == Offset;
 }
 MATCHER_P3(spelledAt, FileID, Offset, SM, "") {
   auto [SpelledFileID, SpelledOffset] = SM->getDecomposedSpellingLoc(arg);