[include-cleaner] Always treat constructor calls as implicit

[kadircet]

Summary

Treating constructor calls when the type name isn't explicitly spelled
can cause spurious results, so turn them into implicit references.
This doesn't change the behaviour for constructor calls that explicitly spell
the type name, as we should see a reference through the typeloc.

Fixes https://github.com/llvm/llvm-project/issues/60812

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

public:
   }
   bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
     report(E->getMemberLoc(), getMemberProvider(E->getBaseType()),
            RefType::Implicit);
     return true;
   }
 
   bool VisitCXXConstructExpr(CXXConstructExpr *E) {
+    // Always treat consturctor calls as implicit. We'll have an explicit
+    // reference for the constructor calls that mention the type-name (through
+    // TypeLocs). This reference only matters for cases where there's no
+    // explicit syntax at all or there're only braces.
     report(E->getLocation(), getMemberProvider(E->getType()),
-           E->getParenOrBraceRange().isValid() ? RefType::Explicit
-                                               : RefType::Implicit);
+           RefType::Implicit);
     return true;
   }
 
   bool VisitOverloadExpr(OverloadExpr *E) {
     // Since we can't prove which overloads are used, report all of them.
     llvm::for_each(E->decls(), [this, E](NamedDecl *D) {
       report(E->getNameLoc(), D, RefType::Ambiguous);
     });

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

TEST(WalkAST, DeclRef) {
   // Return type of `foo` isn't used.
   testWalk("struct S{}; S $explicit^foo();", "auto bar() { return ^foo(); }");
 }
 
 TEST(WalkAST, TagType) {
   testWalk("struct $explicit^S {};", "^S *y;");
   testWalk("enum $explicit^E {};", "^E *y;");
   testWalk("struct $explicit^S { static int x; };", "int y = ^S::x;");
+  // One explicit call from the TypeLoc in constructor spelling, another
+  // implicit reference through the constructor call.
+  testWalk("struct $explicit^$implicit^S { static int x; };", "auto y = ^S();");
 }
 
 TEST(WalkAST, Alias) {
   testWalk(R"cpp(
     namespace ns { int x; }
     using ns::$explicit^x;
   )cpp",
            "int y = ^x;");
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(); }");
 }
 
 TEST(WalkAST, ConstructExprs) {
   testWalk("struct $implicit^S {};", "S ^t;");
   testWalk("struct $implicit^S { S(); };", "S ^t;");
-  testWalk("struct $explicit^S { S(int); };", "S ^t(42);");
+  testWalk("struct $implicit^S { S(int); };", "S ^t(42);");
   testWalk("struct $implicit^S { S(int); };", "S t = ^42;");
   testWalk("namespace ns { struct S{}; } using ns::$implicit^S;", "S ^t;");
 }
 
 TEST(WalkAST, Operator) {
   // References to operators are not counted as uses.
   testWalk("struct string {}; int operator+(string, string);",
            "int k = string() ^+ string();");