[include-cleaner] Dont boost private headers beyond public ones

[kadircet]

Summary

Private headers should be the last resort, even if they match the name
of a symbol. It's pretty common in umrella headers to have internal file names
that match the symbol (e.g. Eigen::Matrix, declared in private header Matrix.h,
and exposed in umbrella header Eigen/Core).

[VitaNuo]

Thanks.

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

474

nit: would be better to split this into multiple lines.

clang-tools-extra/include-cleaner/lib/TypesInternal.h

 enum class Hints : uint8_t {
   None = 0x00,
   /// Symbol is directly originating from this header, rather than being
   /// exported or included transitively.
   OriginHeader = 1 << 0,
   /// Provides a generally-usable definition for the symbol. (a function decl,
   /// or class definition and not a forward declaration of a template).
   CompleteSymbol = 1 << 1,
-  /// Symbol is provided by a public file. Only absent in the cases where file
-  /// is explicitly marked as such, non self-contained or IWYU private
-  /// pragmas.
-  PublicHeader = 1 << 2,
   /// Header providing the symbol is explicitly marked as preferred, with an
   /// IWYU private pragma that points at this provider or header and symbol has
   /// ~the same name.
-  PreferredHeader = 1 << 3,
-  LLVM_MARK_AS_BITMASK_ENUM(PreferredHeader),
+  PreferredHeader = 1 << 2,
+  /// Symbol is provided by a public file. Only absent in the cases where file
+  /// is explicitly marked as such, non self-contained or IWYU private
+  /// pragmas.
+  PublicHeader = 1 << 3,
+  LLVM_MARK_AS_BITMASK_ENUM(PublicHeader),
 };
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 /// A wrapper to augment values with hints.
 template <typename T> struct Hinted : public T {
   Hints Hint;
   Hinted(T &&Wrapped, Hints H) : T(std::move(Wrapped)), Hint(H) {}
 
   /// Since hints are sorted by relevance, use it directly.

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

struct Tag {
   }
 };
 TEST(Hints, Ordering) {
   auto Hinted = [](Hints Hints) {
     return clang::include_cleaner::Hinted<Tag>({}, Hints);
   };
   EXPECT_LT(Hinted(Hints::None), Hinted(Hints::CompleteSymbol));
   EXPECT_LT(Hinted(Hints::CompleteSymbol), Hinted(Hints::PublicHeader));
-  EXPECT_LT(Hinted(Hints::PublicHeader), Hinted(Hints::PreferredHeader));
-  EXPECT_LT(Hinted(Hints::CompleteSymbol | Hints::PublicHeader),
-            Hinted(Hints::PreferredHeader));
+  EXPECT_LT(Hinted(Hints::PreferredHeader), Hinted(Hints::PublicHeader));
+  EXPECT_LT(Hinted(Hints::CompleteSymbol | Hints::PreferredHeader),
+            Hinted(Hints::PublicHeader));
 }
 
 // Test ast traversal & redecl selection end-to-end for templates, as explicit
 // instantiations/specializations are not redecls of the primary template. We
 // need to make sure we're selecting the right ones.
 TEST_F(WalkUsedTest, TemplateDecls) {
   llvm::Annotations Code(R"cpp(
     #include "fwd.h"

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

Inputs.ExtraFiles["foo.h"] = guard(R"cpp(
     // IWYU pragma: private, include "public.h"
     struct foo {};
   )cpp");
   buildAST();
   EXPECT_THAT(headersForFoo(), ElementsAre(Header(StringRef("\"public.h\"")),
                                            physicalHeader("foo.h")));
 }
 
+TEST_F(HeadersForSymbolTest, PublicOverPrivateWithoutUmbrella) {
+  Inputs.Code = R"cpp(
+    #include "bar.h"
+    #include "foo.h"
+  )cpp";
+  Inputs.ExtraFiles["bar.h"] =
+      guard(R"cpp(#include "foo.h" // IWYU pragma: export)cpp");
+  Inputs.ExtraFiles["foo.h"] = guard(R"cpp(
+    // IWYU pragma: private
+    struct foo {};
+  )cpp");
+  buildAST();
+  EXPECT_THAT(headersForFoo(),
+              ElementsAre(physicalHeader("bar.h"), physicalHeader("foo.h")));
+}
+
 TEST_F(HeadersForSymbolTest, AmbiguousStdSymbols) {
   struct {
     llvm::StringRef Code;
     llvm::StringRef Name;
 
     llvm::StringRef ExpectedHeader;
   } TestCases[] = {
       {