[clangd] Change constness of parameters to findExplicitRefs

[kadircet]

Summary

Recursive AST requires non-const ast nodes, but it doesn't really
mutate them. In addition to that, in clangd we mostly have const ast nodes. So
it makes sense to move the const_cast into callee rather than having it at every
caller in the future.

[ilya-biryukov]

Who are the callers? Selection tree?
FWIW, I'd rather pass non-const everywhere, the concept of const-ness is just not very useful for AST nodes.

[ilya-biryukov]

@kadircet says we're using this pattern all over clangd. This somehow slipped my view before.
LGTM to be consistent with the rest of clangd (and functions in FindTarget.h).

I think we should switch to passing non-const pointers everywhere, but that's a discussion for another day...

clang-tools-extra/trunk/clangd/FindTarget.h

 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, ReferenceLoc R);
 
 /// Recursively traverse \p S and report all references explicitly written in
 /// the code. The main use-case is refactorings that need to process all
 /// references in some subrange of the file and apply simple edits, e.g. add
 /// qualifiers.
 /// FIXME: currently this does not report references to overloaded operators.
 /// FIXME: extend to report location information about declaration names too.
-void findExplicitReferences(Stmt *S,
+void findExplicitReferences(const Stmt *S,
                             llvm::function_ref<void(ReferenceLoc)> Out);
-void findExplicitReferences(Decl *D,
+void findExplicitReferences(const Decl *D,
                             llvm::function_ref<void(ReferenceLoc)> Out);
 
 /// Similar to targetDecl(), however instead of applying a filter, all possible
 /// decls are returned along with their DeclRelationSets.
 /// This is suitable for indexing, where everything is recorded and filtering
 /// is applied later.
 llvm::SmallVector<std::pair<const Decl *, DeclRelationSet>, 1>
 allTargetDecls(const ast_type_traits::DynTypedNode &);

clang-tools-extra/trunk/clangd/FindTarget.cpp

private:
 
   llvm::function_ref<void(ReferenceLoc)> Out;
   /// TypeLocs starting at these locations must be skipped, see
   /// TraverseElaboratedTypeSpecifierLoc for details.
   llvm::DenseSet</*SourceLocation*/ unsigned> TypeLocsToSkip;
 };
 } // namespace
 
-void findExplicitReferences(Stmt *S,
+void findExplicitReferences(const Stmt *S,
                             llvm::function_ref<void(ReferenceLoc)> Out) {
   assert(S);
-  ExplicitReferenceColletor(Out).TraverseStmt(S);
+  ExplicitReferenceColletor(Out).TraverseStmt(const_cast<Stmt *>(S));
 }
-void findExplicitReferences(Decl *D,
+void findExplicitReferences(const Decl *D,
                             llvm::function_ref<void(ReferenceLoc)> Out) {
   assert(D);
-  ExplicitReferenceColletor(Out).TraverseDecl(D);
+  ExplicitReferenceColletor(Out).TraverseDecl(const_cast<Decl *>(D));
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, DeclRelation R) {
   switch (R) {
 #define REL_CASE(X)                                                            \
   case DeclRelation::X:                                                        \
     return OS << #X;
     REL_CASE(Alias);