[include-cleaner] Base-type usage from member exprs is implicit.

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

bool VisitMemberExpr(MemberExpr *E) {
     // Reporting a usage of the member decl would cause issues (e.g. force
     // including the base class for inherited members). Instead, we report a
     // usage of the base type of the MemberExpr, so that e.g. code
     // `returnFoo().bar` can keep #include "foo.h" (rather than inserting
     // "bar.h" for the underlying base type `Bar`).
     //
     // FIXME: support dependent types, e.g., "std::vector<T>().size()".
     QualType Type = E->getBase()->IgnoreImpCasts()->getType();
-    // FIXME: this should report as implicit reference.
-    report(E->getMemberLoc(), getMemberProvider(Type));
+    report(E->getMemberLoc(), getMemberProvider(Type), RefType::Implicit);
     return true;
   }
   bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
-    report(E->getMemberLoc(), getMemberProvider(E->getBaseType()));
+    report(E->getMemberLoc(), getMemberProvider(E->getBaseType()),
+           RefType::Implicit);
     return true;
   }
 
   bool VisitCXXConstructExpr(CXXConstructExpr *E) {
     report(E->getLocation(), E->getConstructor(),
            E->getParenOrBraceRange().isValid() ? RefType::Explicit
                                                : RefType::Implicit);
     return true;

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

TEST(WalkAST, TemplateNames) {
   testWalk("template<typename T> struct $explicit^S { S(T); };", "^S s(42);");
   // Should we mark the specialization instead?
   testWalk(
       "template<typename> struct $explicit^S {}; template <> struct S<int> {};",
       "^S<int> s;");
 }
 
 TEST(WalkAST, MemberExprs) {
-  testWalk("struct $explicit^S { void foo(); };", "void foo() { S{}.^foo(); }");
+  testWalk("struct $implicit^S { void foo(); };", "void foo() { S{}.^foo(); }");
   testWalk(
-      "struct S { void foo(); }; struct $explicit^X : S { using S::foo; };",
+      "struct S { void foo(); }; struct $implicit^X : S { using S::foo; };",
       "void foo() { X{}.^foo(); }");
-  testWalk("struct Base { int a; }; struct $explicit^Derived : public Base {};",
+  testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "void fun(Derived d) { d.^a; }");
-  testWalk("struct Base { int a; }; struct $explicit^Derived : public Base {};",
+  testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "void fun(Derived* d) { d->^a; }");
-  testWalk("struct Base { int a; }; struct $explicit^Derived : public Base {};",
+  testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "void fun(Derived& d) { d.^a; }");
-  testWalk("struct Base { int a; }; struct $explicit^Derived : public Base {};",
+  testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "void fun() { Derived().^a; }");
-  testWalk("struct Base { int a; }; struct $explicit^Derived : public Base {};",
+  testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "Derived foo(); void fun() { foo().^a; }");
-  testWalk("struct Base { int a; }; struct $explicit^Derived : public Base {};",
+  testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
            "Derived& foo(); void fun() { foo().^a; }");
   testWalk(R"cpp(
       template <typename T>
       struct unique_ptr {
         T *operator->();
       };
-      struct $explicit^Foo { int a; };)cpp",
+      struct $implicit^Foo { int a; };)cpp",
            "void test(unique_ptr<Foo> &V) { V->^a; }");
   testWalk(R"cpp(
       template <typename T>
-      struct $explicit^unique_ptr {
+      struct $implicit^unique_ptr {
         void release();
       };
       struct Foo {};)cpp",
            "void test(unique_ptr<Foo> &V) { V.^release(); }");
   // Respect the sugar type (typedef, using-type).
   testWalk(R"cpp(
       namespace ns { struct Foo { int a; }; }
-      using $explicit^Bar = ns::Foo;)cpp",
+      using $implicit^Bar = ns::Foo;)cpp",
            "void test(Bar b) { b.^a; }");
   testWalk(R"cpp(
       namespace ns { struct Foo { int a; }; }
-      using ns::$explicit^Foo;)cpp",
+      using ns::$implicit^Foo;)cpp",
            "void test(Foo b) { b.^a; }");
   testWalk(R"cpp(
       namespace ns { struct Foo { int a; }; }
       namespace ns2 { using Bar = ns::Foo; }
-      using ns2::$explicit^Bar;
+      using ns2::$implicit^Bar;
       )cpp",
            "void test(Bar b) { b.^a; }");
   testWalk(R"cpp(
       namespace ns { template<typename> struct Foo { int a; }; }
-      using ns::$explicit^Foo;)cpp",
+      using ns::$implicit^Foo;)cpp",
            "void k(Foo<int> b) { b.^a; }");
   // Test the dependent-type case (CXXDependentScopeMemberExpr)
-  testWalk("template<typename T> struct $explicit^Base { void 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 $explicit^Base { void 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 $explicit^Base { void method(); };",
+  testWalk("template<typename T> struct $implicit^Base { void method(); };",
            "template<typename T> void k(Base<T>* t) { t->^method(); }");
 }
 
 TEST(WalkAST, ConstructExprs) {
   testWalk("struct $implicit^S {};", "S ^t;");
   testWalk("struct S { $implicit^S(); };", "S ^t;");
   testWalk("struct S { $explicit^S(int); };", "S ^t(42);");
   testWalk("struct S { $implicit^S(int); };", "S t = ^42;");