[clangd] Don't collect locations that implicitly refer to the target decl.

[hokein]

Summary

A followup of rL369514, the previous patch was fix the
DeclarationAndMacrosFinder (we will not get decl from implicit
node under the cursor).
This patch is to fix ReferenceFinder (we will not collect implicit references).

[ilya-biryukov]

This actually seems useful. If one starts the search at operator bool, it's nice to see its implicit calls too.
What are the cons of having this?

clang-tools-extra/clangd/XRefs.cpp

SymbolLocation getPreferredLocation(const Location &ASTLoc,
   Symbol ASTSym, IdxSym;
   ASTSym.ID = IdxSym.ID = SymbolID("dummy_id");
   ASTSym.CanonicalDeclaration = toIndexLocation(ASTLoc, Scratch);
   IdxSym.CanonicalDeclaration = IdxLoc;
   auto Merged = mergeSymbol(ASTSym, IdxSym);
   return Merged.CanonicalDeclaration;
 }
 
+// Returns true if the given expression is an implicit AST node.
+bool IsImplicitExpr(const Expr *E) {
+  if (!E)
+    return false;
+  // We assume that a constructor expression is implict (was inserted by
+  // clang) if it has an invalid paren/brace location, since such
+  // experssion is impossible to write down.
+  if (const auto *CtorExpr = dyn_cast<CXXConstructExpr>(E))
+    return CtorExpr->getParenOrBraceRange().isInvalid();
+  // Ignore implicit conversion-operator AST node.
+  if (const auto *ME = dyn_cast<MemberExpr>(E)) {
+    if (isa<CXXConversionDecl>(ME->getMemberDecl()))
+      return ME->getMemberLoc().isInvalid();
+  }
+  return isa<ImplicitCastExpr>(E);
+}
+
 /// Finds declarations locations that a given source location refers to.
 class DeclarationAndMacrosFinder : public index::IndexDataConsumer {
   std::vector<DefinedMacro> MacroInfos;
   llvm::DenseSet<const Decl *> Decls;
   const SourceLocation &SearchedLocation;
   Preprocessor &PP;
 
 public:
handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
                       llvm::ArrayRef<index::SymbolRelation> Relations,
                       SourceLocation Loc,
                       index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
     // Skip non-semantic references.
     if (Roles & static_cast<unsigned>(index::SymbolRole::NameReference))
       return true;
 
     if (Loc == SearchedLocation) {
-      auto IsImplicitExpr = [](const Expr *E) {
-        if (!E)
-          return false;
-        // We assume that a constructor expression is implict (was inserted by
-        // clang) if it has an invalid paren/brace location, since such
-        // experssion is impossible to write down.
-        if (const auto *CtorExpr = dyn_cast<CXXConstructExpr>(E))
-          return CtorExpr->getParenOrBraceRange().isInvalid();
-        // Ignore implicit conversion-operator AST node.
-        if (const auto *ME = dyn_cast<MemberExpr>(E)) {
-          if (isa<CXXConversionDecl>(ME->getMemberDecl()))
-            return ME->getMemberLoc().isInvalid();
-        }
-        return isa<ImplicitCastExpr>(E);
-      };
-
       if (IsImplicitExpr(ASTNode.OrigE))
         return true;
       // Find and add definition declarations (for GoToDefinition).
       // We don't use parameter `D`, as Parameter `D` is the canonical
       // declaration, which is the first declaration of a redeclarable
       // declaration, and it could be a forward declaration.
       if (const auto *Def = getDefinition(D)) {
         Decls.insert(Def);
public:
   bool
   handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
                       llvm::ArrayRef<index::SymbolRelation> Relations,
                       SourceLocation Loc,
                       index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
     assert(D->isCanonicalDecl() && "expect D to be a canonical declaration");
     const SourceManager &SM = AST.getSourceManager();
     Loc = SM.getFileLoc(Loc);
-    if (isInsideMainFile(Loc, SM) && CanonicalTargets.count(D))
+    if (isInsideMainFile(Loc, SM) && CanonicalTargets.count(D) &&
+        !IsImplicitExpr(ASTNode.OrigE))
       References.push_back({Loc, Roles});
     return true;
   }
 
 private:
   llvm::SmallSet<const Decl *, 4> CanonicalTargets;
   std::vector<Reference> References;
   const ASTContext &AST;

clang-tools-extra/clangd/unittests/XRefsTests.cpp

const char *Tests[] = {
         operator bool();
       };
 
       int test() {
         X [[a]];
         [[a]].operator bool();
         if ([[a^]]) {} // ignore implicit conversion-operator AST node
       }
       )cpp",
+      R"cpp(
+      struct X {
+        [[operator]] bool();
+      };
+
+      int test() {
+        X a;
+        a.[[oper^ator]] bool();
+        if (a) {}
+      }
+      )cpp",
   };
   for (const char *Test : Tests) {
     Annotations T(Test);
     auto AST = TestTU::withCode(T.code()).build();
     std::vector<Matcher<Location>> ExpectedLocations;
     for (const auto &R : T.ranges())
       ExpectedLocations.push_back(RangeIs(R));
     ASSERT_THAT(ExpectedLocations, Not(IsEmpty()));