[include-fixer] Don't add missing header if the unindentified symbol isn't from the main file.

[hokein]

Summary

The further solution is to add the missing header to the file where the
symbol comes from.

[bkramer]

LG. It's a bit sad but I guess the cases where that legitimately can happen due to template weirdness are far outweighed by the cases where we have a non-self contained header. The cases I've been thinking of are stuff like:

header.h:

template <typename T>
class Foo {
  T t;
};

test.cc:

#include "header.h"

class Bar;
Foo<Bar> f;

Here we'd have to include the header for Bar into test.cc, but figuring that out is hard. Ignoring all of that for now is fine.

clang-tools-extra/trunk/include-fixer/IncludeFixer.cpp

clang::TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
                                     CorrectionCandidateCallback &CCC,
                                     DeclContext *MemberContext,
                                     bool EnteringContext,
                                     const ObjCObjectPointerType *OPT) override {
     // Ignore spurious callbacks from SFINAE contexts.
     if (getCompilerInstance().getSema().isSFINAEContext())
       return clang::TypoCorrection();
 
+    // We currently ignore the unidentified symbol which is not from the
+    // main file.
+    //
+    // However, this is not always true due to templates in a non-self contained
+    // header, consider the case:
+    //
+    //   // header.h
+    //   template <typename T>
+    //   class Foo {
+    //     T t;
+    //   };
+    //
+    //   // test.cc
+    //   // We need to add <bar.h> in test.cc instead of header.h.
+    //   class Bar;
+    //   Foo<Bar> foo;
+    //
+    // FIXME: Add the missing header to the header file where the symbol comes
+    // from.
+    if (!getCompilerInstance().getSourceManager().isWrittenInMainFile(
+            Typo.getLoc()))
+      return clang::TypoCorrection();
+
     std::string TypoScopeString;
     if (S) {
       // FIXME: Currently we only use namespace contexts. Use other context
       // types for query.
       for (const auto *Context = S->getEntity(); Context;
            Context = Context->getParent()) {
         if (const auto *ND = dyn_cast<NamespaceDecl>(Context)) {
           if (!ND->getName().empty())

clang-tools-extra/trunk/unittests/include-fixer/IncludeFixerTest.cpp

InMemoryFileSystem->addFile(FileName, 0,
                               llvm::MemoryBuffer::getMemBuffer(Code));
 
   InMemoryFileSystem->addFile("foo.h", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
   InMemoryFileSystem->addFile("dir/bar.h", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
   InMemoryFileSystem->addFile("dir/otherdir/qux.h", 0,
                               llvm::MemoryBuffer::getMemBuffer("\n"));
+  InMemoryFileSystem->addFile("header.h", 0,
+                              llvm::MemoryBuffer::getMemBuffer("bar b;"));
   return Invocation.run();
 }
 
 static std::string runIncludeFixer(
     StringRef Code,
     const std::vector<std::string> &ExtraArgs = std::vector<std::string>()) {
   std::vector<SymbolInfo> Symbols = {
       SymbolInfo("string", SymbolInfo::SymbolKind::Class, "<string>", 1,
EXPECT_EQ("#include \"bar.h\"\nnamespace A {\nb::bar b;\n}",
             runIncludeFixer("namespace A {\nb::bar b;\n}"));
 }
 
 TEST(IncludeFixer, EnumConstantSymbols) {
   EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n",
             runIncludeFixer("int test = a::b::Green;\n"));
 }
 
+TEST(IncludeFixer, IgnoreSymbolFromHeader) {
+  std::string Code = "#include \"header.h\"";
+  EXPECT_EQ(Code, runIncludeFixer(Code));
+}
+
 // FIXME: add test cases for inserting and sorting multiple headers when
 // include-fixer supports multiple headers insertion.
 TEST(IncludeFixer, InsertAndSortSingleHeader) {
   // Insert one header.
   std::string Code = "#include \"a.h\"\n"
                      "#include \"foo.h\"\n"
                      "\n"
                      "namespace a { b::bar b; }";