[include-cleaner] Fix crash on unresolved headers

[kadircet]

Summary

Make sure unresolved headers are not analyzed as part of unused
includes.

Also introduces a testing fixture for analyze tests

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

 //===--- Analysis.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-include-cleaner/Analysis.h"
 #include "AnalysisInternal.h"
 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
-#include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Error.h"
+#include <string>
 
 namespace clang::include_cleaner {
 
 void walkUsed(llvm::ArrayRef<Decl *> ASTRoots,
               llvm::ArrayRef<SymbolReference> MacroRefs,
               const PragmaIncludes *PI, const SourceManager &SM,
               UsedSymbolCB CB) {
   // This is duplicated in writeHTMLReport, changes should be mirrored there.
walkUsed(ASTRoots, MacroRefs, PI, SM,
              }
              if (!Satisfied && !Providers.empty() &&
                  Ref.RT == RefType::Explicit)
                Missing.insert(spellHeader(Providers.front(), HS, MainFile));
            });
 
   AnalysisResults Results;
   for (const Include &I : Inc.all()) {
-    if (Used.contains(&I))
+    if (Used.contains(&I) || !I.Resolved)
       continue;
     if (PI) {
       if (PI->shouldKeep(I.Line))
         continue;
       // Check if main file is the public interface for a private header. If so
       // we shouldn't diagnose it as unused.
       if (auto PHeader = PI->getPublic(I.Resolved); !PHeader.empty()) {
         PHeader = PHeader.trim("<>\"");

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

 //===--- AnalysisTest.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-include-cleaner/Analysis.h"
 #include "AnalysisInternal.h"
+#include "TypesInternal.h"
 #include "clang-include-cleaner/Record.h"
 #include "clang-include-cleaner/Types.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/FileManager.h"
+#include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Testing/TestAST.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Testing/Annotations/Annotations.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstddef>
+#include <memory>
+#include <string>
 #include <vector>
 
 namespace clang::include_cleaner {
 namespace {
 using testing::AllOf;
 using testing::Contains;
 using testing::ElementsAre;
 using testing::Pair;
EXPECT_THAT(
                          SymbolReference{SM.getComposedLoc(SM.getMainFileID(),
                                                            Code.point("2")),
                                          Answer2, RefType::Explicit}}),
       UnorderedElementsAre(
           Pair(Code.point("1"), UnorderedElementsAre(HdrFile)),
           Pair(Code.point("2"), UnorderedElementsAre(HdrFile))));
 }
 
-TEST(Analyze, Basic) {
+class AnalyzeTest : public testing::Test {
+protected:
   TestInputs Inputs;
-  Inputs.Code = R"cpp(
-#include "a.h"
-#include "b.h"
-#include "keep.h" // IWYU pragma: keep
-
-int x = a + c;
-)cpp";
-  Inputs.ExtraFiles["a.h"] = guard("int a;");
-  Inputs.ExtraFiles["b.h"] = guard(R"cpp(
-    #include "c.h"
-    int b;
-  )cpp");
-  Inputs.ExtraFiles["c.h"] = guard("int c;");
-  Inputs.ExtraFiles["keep.h"] = guard("");
-
-  RecordedPP PP;
   PragmaIncludes PI;
-  Inputs.MakeAction = [&PP, &PI] {
+  RecordedPP PP;
+  AnalyzeTest() {
+    Inputs.MakeAction = [this] {
       struct Hook : public SyntaxOnlyAction {
       public:
         Hook(RecordedPP &PP, PragmaIncludes &PI) : PP(PP), PI(PI) {}
         bool BeginSourceFileAction(clang::CompilerInstance &CI) override {
           CI.getPreprocessor().addPPCallbacks(PP.record(CI.getPreprocessor()));
           PI.record(CI);
           return true;
         }
 
         RecordedPP &PP;
         PragmaIncludes &PI;
       };
       return std::make_unique<Hook>(PP, PI);
     };
+  }
+};
 
-  {
-    TestAST AST(Inputs);
-    auto Decls = AST.context().getTranslationUnitDecl()->decls();
-    auto Results =
-        analyze(std::vector<Decl *>{Decls.begin(), Decls.end()},
-                PP.MacroReferences, PP.Includes, &PI, AST.sourceManager(),
-                AST.preprocessor().getHeaderSearchInfo());
+TEST_F(AnalyzeTest, Basic) {
+  Inputs.Code = R"cpp(
+#include "a.h"
+#include "b.h"
+#include "keep.h" // IWYU pragma: keep
+
+int x = a + c;
+)cpp";
+  Inputs.ExtraFiles["a.h"] = guard("int a;");
+  Inputs.ExtraFiles["b.h"] = guard(R"cpp(
+    #include "c.h"
+    int b;
+  )cpp");
+  Inputs.ExtraFiles["c.h"] = guard("int c;");
+  Inputs.ExtraFiles["keep.h"] = guard("");
 
-    const Include *B = PP.Includes.atLine(3);
-    ASSERT_EQ(B->Spelled, "b.h");
-    EXPECT_THAT(Results.Missing, ElementsAre("\"c.h\""));
-    EXPECT_THAT(Results.Unused, ElementsAre(B));
-  }
 
+TEST_F(AnalyzeTest, PrivateUsedInPublic) {
   // Check that umbrella header uses private include.
-  {
-    Inputs.Code = R"cpp(#include "private.h")cpp";
-    Inputs.ExtraFiles["private.h"] =
-        guard("// IWYU pragma: private, include \"public.h\"");
-    Inputs.FileName = "public.h";
-    PP.Includes = {};
-    PI = {};
-    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_F(AnalyzeTest, NoCrashWhenUnresolved) {
+  // Check that umbrella header uses private include.
+  Inputs.Code = R"cpp(#include "not_found.h")cpp";
+  Inputs.ErrorOK = true;
+  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(
 #include "a.h"
 #include "b.h"
 #include <c.h>
 )cpp";