[include-cleaner] Don't consider the underlying type of Decltype MemberProvider as a use

[hokein]

Summary

For this case, the argument of decltype is the provider.

This fixes the sample in https://github.com/llvm/llvm-project/issues/59916#issuecomment-1377214667

[kadircet]

I am a little skeptical about this one. I think it's somewhat an obscure pattern, and probably warrants a use of the type when it can be deduced and the user code is accessing members (relying on the type more than an opaque manner). So what about waiting on this patch until we encounter examples in real world that require such a treatment?

[hokein]

In D141608#4050739, @kadircet wrote:

I am a little skeptical about this one. I think it's somewhat an obscure pattern, and probably warrants a use of the type when it can be deduced and the user code is accessing members (relying on the type more than an opaque manner). So what about waiting on this patch until we encounter examples in real world that require such a treatment?

Sure, sounds good.

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

NamedDecl *getMemberProvider(QualType Base) {
     // Unwrap the sugar ElaboratedType.
     if (const auto *ElTy = dyn_cast<ElaboratedType>(Base))
       return getMemberProvider(ElTy->getNamedType());
 
     if (const auto *TT = dyn_cast<TypedefType>(Base))
       return TT->getDecl();
     if (const auto *UT = dyn_cast<UsingType>(Base))
       return UT->getFoundDecl();
+    // Don't consider the underlying type of the decltype as a use (generally
+    // the argument of decltype should provide them).
+    if (const auto *DT = dyn_cast<DecltypeType>(Base))
+      return nullptr;
     // A heuristic: to resolve a template type to **only** its template name.
     // We're only using this method for the base type of MemberExpr, in general
     // the template provides the member, and the critical case `unique_ptr<Foo>`
     // is supported (the base type is a Foo*).
     //
     // There are some exceptions that this heuristic could fail (dependent base,
     // dependent typealias), but we believe these are rare.
     if (const auto *TST = dyn_cast<TemplateSpecializationType>(Base))

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

testWalk(R"cpp(
       namespace ns2 { using Bar = ns::Foo; }
       using ns2::$implicit^Bar;
       )cpp",
            "void test(Bar b) { b.^a; }");
   testWalk(R"cpp(
       namespace ns { template<typename> struct Foo { int a; }; }
       using ns::$implicit^Foo;)cpp",
            "void k(Foo<int> b) { b.^a; }");
+  testWalk("struct Foo { int a; };", "void test(decltype(Foo()) b) { b.^a; }");
   // Test the dependent-type case (CXXDependentScopeMemberExpr)
   testWalk("template<typename T> struct $implicit^Base { void method(); };",
            "template<typename T> void k(Base<T> t) { t.^method(); }");
   testWalk("template<typename T> struct $implicit^Base { void method(); };",
            "template<typename T> void k(Base<T>& t) { t.^method(); }");
   testWalk("template<typename T> struct $implicit^Base { void method(); };",
            "template<typename T> void k(Base<T>* t) { t->^method(); }");
 }