Implement code lense for used symbols.

[VitaNuo]

Use vscode command.

[VitaNuo]

Remove unrelated code.

[VitaNuo]

Remove unneeded code.

[VitaNuo]

Replace the used symbol computation impl.

[VitaNuo]

Use custom command.

[VitaNuo]

Improve argument handling.

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   /// hierarchy.
   void onMemoryUsage(const NoParams &, Callback<MemoryTree>);
   void onCommand(const ExecuteCommandParams &, Callback<llvm::json::Value>);
 
   /// Implement commands.
   void onCommandApplyEdit(const WorkspaceEdit &, Callback<llvm::json::Value>);
   void onCommandApplyTweak(const TweakArgs &, Callback<llvm::json::Value>);
 
+  void onCodeLens(const CodeLensParams &Params, Callback<std::vector<CodeLens>> Reply);
+  void onCommandShowUsedSymbols(const IncludeSpelling &Spelling, Callback<llvm::json::Value> Reply);
+
   /// Outgoing LSP calls.
   LSPBinder::OutgoingMethod<ApplyWorkspaceEditParams,
                             ApplyWorkspaceEditResponse>
       ApplyWorkspaceEdit;
   LSPBinder::OutgoingNotification<ShowMessageParams> ShowMessage;
   LSPBinder::OutgoingNotification<PublishDiagnosticsParams> PublishDiagnostics;
   LSPBinder::OutgoingNotification<FileStatus> NotifyFileStatus;
   LSPBinder::OutgoingMethod<WorkDoneProgressCreateParams, std::nullptr_t>

clang-tools-extra/clangd/ClangdLSPServer.cpp

if (llvm::to_integer(Encoded, Result, 10))
     return Result;
   if (!Encoded.empty()) // Empty can be e.g. diagnostics on close.
     elog("unexpected non-numeric version {0}", Encoded);
   return std::nullopt;
 }
 
 const llvm::StringLiteral ApplyFixCommand = "clangd.applyFix";
 const llvm::StringLiteral ApplyTweakCommand = "clangd.applyTweak";
+const llvm::StringLiteral ApplyShowUsedSymbols = "HelloWorld";
 
 /// Transforms a tweak into a code action that would apply it if executed.
 /// EXPECTS: T.prepare() was called and returned true.
 CodeAction toCodeAction(const ClangdServer::TweakRef &T, const URIForFile &File,
                         Range Selection) {
   CodeAction CA;
   CA.title = T.Title;
   CA.kind = T.Kind.str();
llvm::json::Object ServerCaps{
       {"standardTypeHierarchyProvider", true}, // clangd extension
       {"memoryUsageProvider", true},           // clangd extension
       {"compilationDatabase",                  // clangd extension
        llvm::json::Object{{"automaticReload", true}}},
       {"callHierarchyProvider", true},
       {"clangdInlayHintsProvider", true},
       {"inlayHintProvider", true},
       {"foldingRangeProvider", true},
+      {"codeLensProvider", true},
   };
 
   {
     LSPBinder Binder(Handlers, *this);
     bindMethods(Binder, Params.capabilities);
     if (Opts.FeatureModules)
       for (auto &Mod : *Opts.FeatureModules)
         Mod.initializeLSP(Binder, Params.rawCapabilities, ServerCaps);
void ClangdLSPServer::onCommandApplyEdit(const WorkspaceEdit &WE,
   // 3. We send code actions, with the fixit embedded as context
   // 4. The user selects the fixit, the editor asks us to apply it
   // 5. We unwrap the changes and send them back to the editor
   // 6. The editor applies the changes (applyEdit), and sends us a reply
   // 7. We unwrap the reply and send a reply to the editor.
   applyEdit(WE, "Fix applied.", std::move(Reply));
 }
 
+void ClangdLSPServer::onCommandShowUsedSymbols(const IncludeSpelling &Spelling, Callback<llvm::json::Value> Reply) {
+  llvm::errs() << "ONCOMMAND SHOW USED SYMBOLS TRIGGERED\n";
+  llvm::json::Value Response = llvm::json::Object{
+    {"response", "Hello to you as well!!!"}
+  };
+  return Reply(Response);
+}
+
 void ClangdLSPServer::onCommandApplyTweak(const TweakArgs &Args,
                                           Callback<llvm::json::Value> Reply) {
   auto Action = [this, Reply = std::move(Reply)](
                     llvm::Expected<Tweak::Effect> R) mutable {
     if (!R)
       return Reply(R.takeError());
 
     assert(R->ShowMessage || (!R->ApplyEdits.empty() && "tweak has no effect"));

 void ClangdLSPServer::onChangeConfiguration(
     const DidChangeConfigurationParams &Params) {
   applyConfiguration(Params.settings);
 }
 
 void ClangdLSPServer::onReference(
     const ReferenceParams &Params,
     Callback<std::vector<ReferenceLocation>> Reply) {
+  llvm::errs() << "DOC: " << Params.textDocument.uri.file() << "\n";
+  llvm::errs() << "POSITION: " << Params.position << "\n";
   Server->findReferences(Params.textDocument.uri.file(), Params.position,
                          Opts.ReferencesLimit, SupportsReferenceContainer,
                          [Reply = std::move(Reply),
                           IncludeDecl(Params.context.includeDeclaration)](
                              llvm::Expected<ReferencesResult> Refs) mutable {
                            if (!Refs)
                              return Reply(Refs.takeError());
                            // Filter out declarations if the client asked.
                            std::vector<ReferenceLocation> Result;
                            Result.reserve(Refs->References.size());
                            for (auto &Ref : Refs->References) {
                              bool IsDecl =
                                  Ref.Attributes & ReferencesResult::Declaration;
                              if (IncludeDecl || !IsDecl)
                                Result.push_back(std::move(Ref.Loc));
                            }
                            return Reply(std::move(Result));
                          });
 }
 
+void ClangdLSPServer::onCodeLens(const CodeLensParams &Params,
+    Callback<std::vector<CodeLens>> Reply) {
+  llvm::errs() << "TRIGGERED CODE LENS: " << Params.textDocument.uri.file() << "\n";
+  Server->findCodeLens(Params.textDocument.uri.file(), std::move(Reply));
+}
+
 void ClangdLSPServer::onGoToType(const TextDocumentPositionParams &Params,
                                  Callback<std::vector<Location>> Reply) {
   Server->findType(
       Params.textDocument.uri.file(), Params.position,
       [Reply = std::move(Reply)](
           llvm::Expected<std::vector<LocatedSymbol>> Types) mutable {
         if (!Types)
           return Reply(Types.takeError());
void ClangdLSPServer::bindMethods(LSPBinder &Bind,
   Bind.method("textDocument/codeAction", this, &ClangdLSPServer::onCodeAction);
   Bind.method("textDocument/completion", this, &ClangdLSPServer::onCompletion);
   Bind.method("textDocument/signatureHelp", this, &ClangdLSPServer::onSignatureHelp);
   Bind.method("textDocument/definition", this, &ClangdLSPServer::onGoToDefinition);
   Bind.method("textDocument/declaration", this, &ClangdLSPServer::onGoToDeclaration);
   Bind.method("textDocument/typeDefinition", this, &ClangdLSPServer::onGoToType);
   Bind.method("textDocument/implementation", this, &ClangdLSPServer::onGoToImplementation);
   Bind.method("textDocument/references", this, &ClangdLSPServer::onReference);
+  Bind.method("textDocument/codeLens", this, &ClangdLSPServer::onCodeLens);
   Bind.method("textDocument/switchSourceHeader", this, &ClangdLSPServer::onSwitchSourceHeader);
   Bind.method("textDocument/prepareRename", this, &ClangdLSPServer::onPrepareRename);
   Bind.method("textDocument/rename", this, &ClangdLSPServer::onRename);
   Bind.method("textDocument/hover", this, &ClangdLSPServer::onHover);
   Bind.method("textDocument/documentSymbol", this, &ClangdLSPServer::onDocumentSymbol);
   Bind.method("workspace/executeCommand", this, &ClangdLSPServer::onCommand);
   Bind.method("textDocument/documentHighlight", this, &ClangdLSPServer::onDocumentHighlight);
   Bind.method("workspace/symbol", this, &ClangdLSPServer::onWorkspaceSymbol);
void ClangdLSPServer::bindMethods(LSPBinder &Bind,
   Bind.method("textDocument/semanticTokens/full", this, &ClangdLSPServer::onSemanticTokens);
   Bind.method("textDocument/semanticTokens/full/delta", this, &ClangdLSPServer::onSemanticTokensDelta);
   Bind.method("clangd/inlayHints", this, &ClangdLSPServer::onClangdInlayHints);
   Bind.method("textDocument/inlayHint", this, &ClangdLSPServer::onInlayHint);
   Bind.method("$/memoryUsage", this, &ClangdLSPServer::onMemoryUsage);
   Bind.method("textDocument/foldingRange", this, &ClangdLSPServer::onFoldingRange);
   Bind.command(ApplyFixCommand, this, &ClangdLSPServer::onCommandApplyEdit);
   Bind.command(ApplyTweakCommand, this, &ClangdLSPServer::onCommandApplyTweak);
+  Bind.command(ApplyShowUsedSymbols, this, &ClangdLSPServer::onCommandShowUsedSymbols);
 
   ApplyWorkspaceEdit = Bind.outgoingMethod("workspace/applyEdit");
   PublishDiagnostics = Bind.outgoingNotification("textDocument/publishDiagnostics");
   ShowMessage = Bind.outgoingNotification("window/showMessage");
   NotifyFileStatus = Bind.outgoingNotification("textDocument/clangd.fileStatus");
   CreateWorkDoneProgress = Bind.outgoingMethod("window/workDoneProgress/create");
   BeginWorkDoneProgress = Bind.outgoingNotification("$/progress");
   ReportWorkDoneProgress = Bind.outgoingNotification("$/progress");

clang-tools-extra/clangd/ClangdServer.h

public:
   /// Retrieve symbols for types referenced at \p Pos.
   void findType(PathRef File, Position Pos,
                 Callback<std::vector<LocatedSymbol>> CB);
 
   /// Retrieve locations for symbol references.
   void findReferences(PathRef File, Position Pos, uint32_t Limit,
                       bool AddContainer, Callback<ReferencesResult> CB);
 
+  void findCodeLens(PathRef File, Callback<std::vector<CodeLens>> CB);
+
   /// Run formatting for the \p File with content \p Code.
   /// If \p Rng is non-null, formats only that region.
   void formatFile(PathRef File, std::optional<Range> Rng,
                   Callback<tooling::Replacements> CB);
 
   /// Run formatting after \p TriggerText was typed at \p Pos in \p File with
   /// content \p Code.
   void formatOnType(PathRef File, Position Pos, StringRef TriggerText,

clang-tools-extra/clangd/ClangdServer.cpp

auto Action = [Pos, Limit, AddContainer, CB = std::move(CB),
     if (!InpAST)
       return CB(InpAST.takeError());
     CB(clangd::findReferences(InpAST->AST, Pos, Limit, Index, AddContainer));
   };
 
   WorkScheduler->runWithAST("References", File, std::move(Action));
 }
 
+void ClangdServer::findCodeLens(PathRef File, Callback<std::vector<CodeLens>> CB) {
+  auto Action = [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
+    if (!InpAST) 
+      return CB(InpAST.takeError());    
+    
+    CB(clangd::findCodeLens(InpAST->AST));
+  };
+
+  WorkScheduler->runWithAST("CodeLens", File, std::move(Action));
+}
+
 void ClangdServer::symbolInfo(PathRef File, Position Pos,
                               Callback<std::vector<SymbolDetails>> CB) {
   auto Action =
       [Pos, CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
         if (!InpAST)
           return CB(InpAST.takeError());
         CB(clangd::getSymbolInfo(InpAST->AST, Pos));
       };

clang-tools-extra/clangd/Protocol.h

struct WorkspaceEdit {
   std::map<std::string, std::vector<TextEdit>> changes;
 
   /// Note: "documentChanges" is not currently used because currently there is
   /// no support for versioned edits.
 };
 bool fromJSON(const llvm::json::Value &, WorkspaceEdit &, llvm::json::Path);
 llvm::json::Value toJSON(const WorkspaceEdit &WE);
 
+struct IncludeSpelling {
+  std::string spelling;
+};
+bool fromJSON(const llvm::json::Value &, IncludeSpelling &, llvm::json::Path);
+llvm::json::Value toJSON(const IncludeSpelling &IS);
+
 /// Arguments for the 'applyTweak' command. The server sends these commands as a
 /// response to the textDocument/codeAction request. The client can later send a
 /// command back to the server if the user requests to execute a particular code
 /// tweak.
 struct TweakArgs {
   /// A file provided by the client on a textDocument/codeAction request.
   URIForFile file;
   /// A selection provided by the client on a textDocument/codeAction request.
   Range selection;
   /// ID of the tweak that should be executed. Corresponds to Tweak::id().
   std::string tweakID;
 };
 bool fromJSON(const llvm::json::Value &, TweakArgs &, llvm::json::Path);
 llvm::json::Value toJSON(const TweakArgs &A);
 
 struct ExecuteCommandParams {
   /// The identifier of the actual command handler.
   std::string command;
 
   // This is `arguments?: []any` in LSP.
   // All clangd's commands accept a single argument (or none => null).
   llvm::json::Value argument = nullptr;
+  llvm::json::Value argument2 = nullptr;
 };
 bool fromJSON(const llvm::json::Value &, ExecuteCommandParams &,
               llvm::json::Path);
 
 struct Command : public ExecuteCommandParams {
   std::string title;
 };
 llvm::json::Value toJSON(const Command &C);
struct ASTNode {
   /// May be missing for implicit nodes, or those created by macro expansion.
   std::optional<Range> range;
   /// Nodes nested within this one, such as the operands of a BinaryOperator.
   std::vector<ASTNode> children;
 };
 llvm::json::Value toJSON(const ASTNode &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const ASTNode &);
 
+struct CodeLensParams {
+  TextDocumentIdentifier textDocument;
+};
+bool fromJSON(const llvm::json::Value &, CodeLensParams &,
+              llvm::json::Path);
+
+struct CodeLens {
+  Range range;
+  Command command;
+};
+llvm::json::Value toJSON(const CodeLens &);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &, const CodeLens &);
+
 } // namespace clangd
 } // namespace clang
 
 namespace llvm {
 template <> struct format_provider<clang::clangd::Position> {
   static void format(const clang::clangd::Position &Pos, raw_ostream &OS,
                      StringRef Style) {
     assert(Style.empty() && "style modifiers for this type are not supported");
     OS << Pos;
   }
 };
 } // namespace llvm
 
 // NOLINTEND(readability-identifier-naming)
 
 #endif

clang-tools-extra/clangd/Protocol.cpp

 }
 
 bool fromJSON(const llvm::json::Value &Params, DidCloseTextDocumentParams &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("textDocument", R.textDocument);
 }
 
+bool fromJSON(const llvm::json::Value &Params, CodeLensParams &R,
+              llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("textDocument", R.textDocument);
+}
+
+bool fromJSON(const llvm::json::Value &Params, IncludeSpelling &R, llvm::json::Path P) {
+  llvm::json::ObjectMapper O(Params, P);
+  return O && O.map("spelling", R.spelling);
+}
+
 bool fromJSON(const llvm::json::Value &Params, DidSaveTextDocumentParams &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("textDocument", R.textDocument);
 }
 
 bool fromJSON(const llvm::json::Value &Params, DidChangeTextDocumentParams &R,
               llvm::json::Path P) {

 
 llvm::json::Value toJSON(const DiagnosticRelatedInformation &DRI) {
   return llvm::json::Object{
       {"location", DRI.location},
       {"message", DRI.message},
   };
 }
 
+llvm::json::Value toJSON(const IncludeSpelling &IS) {
+  return llvm::json::Object{
+    {"spelling", IS.spelling}
+  };
+}
+
+llvm::json::Value toJSON(const CodeLens &CL) {
+  return llvm::json::Object {
+    {"range", CL.range},
+    {"command", CL.command}
+  };
+}
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const CodeLens &CL) {
+  return OS << "Code lens: " << CL.range.start << '-' << CL.range.end;
+}
+
 llvm::json::Value toJSON(DiagnosticTag Tag) { return static_cast<int>(Tag); }
 
 llvm::json::Value toJSON(const CodeDescription &D) {
   return llvm::json::Object{{"href", D.href}};
 }
 
 llvm::json::Value toJSON(const Diagnostic &D) {
   llvm::json::Object Diag{

 bool fromJSON(const llvm::json::Value &Params, WorkspaceSymbolParams &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   return O && O.map("query", R.query) &&
          mapOptOrNull(Params, "limit", R.limit, P);
 }
 
 llvm::json::Value toJSON(const Command &C) {
+  llvm::errs() << "ENCODING COMMAND: ";
+  llvm::errs() << C.title << "\n";
+  llvm::errs() << C.command << "\n";
+  llvm::errs() << C.argument << "\n";
+  llvm::errs() << C.argument2 << "\n";
   auto Cmd = llvm::json::Object{{"title", C.title}, {"command", C.command}};
   if (!C.argument.getAsNull())
-    Cmd["arguments"] = llvm::json::Array{C.argument};
+    Cmd["arguments"] = llvm::json::Array{C.argument, C.argument2};
+  
+  llvm::errs() << "DECODING COMMAND: ";
+  llvm::json::Array *Args = Cmd.getArray("arguments");
+  llvm::errs() << "FIRST ARG: " << (*Args)[0] << "\n";
+  llvm::errs() << "SECOND ARG: " << (*Args)[1] << "\n";
   return std::move(Cmd);
 }
 
 const llvm::StringLiteral CodeAction::QUICKFIX_KIND = "quickfix";
 const llvm::StringLiteral CodeAction::REFACTOR_KIND = "refactor";
 const llvm::StringLiteral CodeAction::INFO_KIND = "info";
 
 llvm::json::Value toJSON(const CodeAction &CA) {
bool fromJSON(const llvm::json::Value &Response, ApplyWorkspaceEditResponse &R,
   llvm::json::ObjectMapper O(Response, P);
   return O && O.map("applied", R.applied) &&
          O.map("failureReason", R.failureReason);
 }
 
 bool fromJSON(const llvm::json::Value &Params, TextDocumentPositionParams &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
+  const auto &PositionSuccess = O.map("position", R.position);
+  llvm::errs() << "REF PARAMS FROM JSON: " << R.position << "\n";
   return O && O.map("textDocument", R.textDocument) &&
-         O.map("position", R.position);
+         PositionSuccess;
 }
 
 bool fromJSON(const llvm::json::Value &Params, CompletionContext &R,
               llvm::json::Path P) {
   llvm::json::ObjectMapper O(Params, P);
   int TriggerKind;
   if (!O || !O.map("triggerKind", TriggerKind) ||
       !mapOptOrNull(Params, "triggerCharacter", R.triggerCharacter, P))

clang-tools-extra/clangd/XRefs.h

 namespace clang {
 namespace syntax {
 class Token;
 class TokenBuffer;
 } // namespace syntax
 namespace clangd {
 class ParsedAST;
 
+std::vector<CodeLens> findCodeLens(ParsedAST &AST);
+
 // Describes where a symbol is declared and defined (as far as clangd knows).
 // There are three cases:
 //  - a declaration only, no definition is known (e.g. only header seen)
 //  - a declaration and a distinct definition (e.g. function declared in header)
 //  - a declaration and an equal definition (e.g. inline function, or class)
 // For some types of symbol, e.g. macros, definition == declaration always.
 struct LocatedSymbol {
   // The (unqualified) name of the symbol.

clang-tools-extra/clangd/XRefs.cpp

 //===--- XRefs.cpp -----------------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "XRefs.h"
 #include "AST.h"
 #include "FindSymbols.h"
 #include "FindTarget.h"
 #include "HeuristicResolver.h"
+#include "IncludeCleaner.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "Quality.h"
 #include "Selection.h"
 #include "SourceCode.h"
 #include "URI.h"
+#include "clang-include-cleaner/Analysis.h"
+#include "clang-include-cleaner/Types.h"
 #include "index/Index.h"
 #include "index/Merge.h"
 #include "index/Relation.h"
 #include "index/SymbolCollector.h"
 #include "index/SymbolID.h"
 #include "index/SymbolLocation.h"
 #include "support/Logger.h"
 #include "clang/AST/ASTContext.h"

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 #include <vector>
+#include <string> 
 
 namespace clang {
 namespace clangd {
+std::string HelloString = "Hello";
 namespace {
 
 // Returns the single definition of the entity declared by D, if visible.
 // In particular:
 // - for non-redeclarable kinds (e.g. local vars), return D
 // - for kinds that allow multiple definitions (e.g. namespaces), return nullptr
 // Kinds of nodes that always return nullptr here will not have definitions
 // reported by locateSymbolAt().
 const NamedDecl *getDefinition(const NamedDecl *D) {
+  std::string AnotherString;
   assert(D);
   // Decl has one definition that we can find.
   if (const auto *TD = dyn_cast<TagDecl>(D))
     return TD->getDefinition();
   if (const auto *VD = dyn_cast<VarDecl>(D))
     return VD->getDefinition();
   if (const auto *FD = dyn_cast<FunctionDecl>(D))
     return FD->getDefinition();

 }
 
 // Convert a SymbolLocation to LSP's Location.
 // TUPath is used to resolve the path of URI.
 // FIXME: figure out a good home for it, and share the implementation with
 // FindSymbols.
 std::optional<Location> toLSPLocation(const SymbolLocation &Loc,
                                       llvm::StringRef TUPath) {
+  std::string ThirdString;
   if (!Loc)
     return std::nullopt;
   auto Uri = URI::parse(Loc.FileURI);
   if (!Uri) {
     elog("Could not parse URI {0}: {1}", Loc.FileURI, Uri.takeError());
     return std::nullopt;
   }
   auto U = URIForFile::fromURI(*Uri, TUPath);
if (const auto *Tok = TB.spelledTokenAt(Loc)) {
     DocumentHighlight Result;
     Result.range = halfOpenToRange(
         TB.sourceManager(),
         CharSourceRange::getCharRange(Tok->location(), Tok->endLocation()));
     return Result;
   }
   return std::nullopt;
 }
-
 } // namespace
 
 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
                                                       Position Pos) {
   const SourceManager &SM = AST.getSourceManager();
   // FIXME: show references to macro within file?
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return {};
   }
   std::vector<DocumentHighlight> Result;
   auto TryTree = [&](SelectionTree ST) {
     if (const SelectionTree::Node *N = ST.commonAncestor()) {
       DeclRelationSet Relations =
           DeclRelation::TemplatePattern | DeclRelation::Alias;
       auto TargetDecls =
           targetDecl(N->ASTNode, Relations, AST.getHeuristicResolver());
+
       if (!TargetDecls.empty()) {
         // FIXME: we may get multiple DocumentHighlights with the same location
         // and different kinds, deduplicate them.
         for (const auto &Ref : findRefs(TargetDecls, AST, /*PerToken=*/true))
           Result.push_back(toHighlight(Ref, SM));
         return true;
       }
       auto ControlFlow = relatedControlFlow(*N);
stringifyContainerForMainFileRef(const Decl *Container) {
   // FIXME We might also want to display the signature here
   // When doing so, remember to also add the Signature to index results!
   if (auto *ND = llvm::dyn_cast_if_present<NamedDecl>(Container))
     return printQualifiedName(*ND);
   return {};
 }
 } // namespace
 
+std::vector<CodeLens> findCodeLens(ParsedAST &AST) {
+  // TODO(bakalova) find ranges
+  // TODO(bakalova) find used symbols
+
+  std::vector<CodeLens> Result;
+  std::vector<Inclusion> Includes = AST.getIncludeStructure().MainFileIncludes;
+
+  for (auto Inclusion : Includes) {
+    std::set<std::string> UsedSymbols;
+    walkUsed(AST.getLocalTopLevelDecls(),
+        collectMacroReferences(AST),
+        AST.getPragmaIncludes(),
+        AST.getSourceManager(),
+        [&](const include_cleaner::SymbolReference &Ref,
+        llvm::ArrayRef<include_cleaner::Header> Providers) {
+
+    std::string Name;
+    switch(Ref.Target.kind()) {
+       case include_cleaner::Symbol::Declaration:
+        Name = cast<NamedDecl>(Ref.Target.declaration())
+            .getDeclName()
+            .getAsString();   
+        break;
+      case include_cleaner::Symbol::Macro:
+        Name = Ref.Target.macro().Name->getName(); 
+        break;
+    }      
+    for (const include_cleaner::Header &H : Providers) {
+      switch (H.kind()) {
+      case include_cleaner::Header::Physical:
+        if (H.physical()->tryGetRealPathName().contains(
+                llvm::StringRef(Inclusion.Written).trim("\"<>"))) {
+          UsedSymbols.insert(Name);
+        }
+        break;
+      case include_cleaner::Header::Standard:
+        if (Inclusion.Written == H.standard().name()) {
+          UsedSymbols.insert(Name);
+        }
+        break;
+      // TODO(bakalova) does the verbatim thing include quotes or not?
+      case include_cleaner::Header::Verbatim:
+        if (Inclusion.Written == H.verbatim()) {
+          UsedSymbols.insert(Name);
+        }
+        break;
+      }
+    }
+  });
+
+    CodeLens Lens;
+    Lens.range = clangd::Range{Position{Inclusion.HashLine, 0}, Position{Inclusion.HashLine, 0}};
+    Command cmd;
+    
+    std::vector<std::string> UsedSymbolsDeduped;
+    for (auto Sym : UsedSymbols) {
+      UsedSymbolsDeduped.push_back(Sym);
+    }
+
+    cmd.title = std::to_string(UsedSymbolsDeduped.size()) + " used symbols";
+    cmd.command = "references-view.findReferences";
+
+    // for (unsigned i = 0; i < 4 && i < UsedSymbolsDeduped.size(); i++) {
+    //   std::string Name = UsedSymbolsDeduped[i];
+    //   cmd.title += Name;
+    //   cmd.title += " | ";
+    // }
+    // if (UsedSymbols.size() >= 5) {
+    //   cmd.title += UsedSymbolsDeduped[4];
+    //   cmd.title += " | ...";
+    // }
+    
+    auto MainFilePath = AST.tuPath();
+    auto URIMainFile = URIForFile::canonicalize(MainFilePath, MainFilePath);
+   
+    cmd.argument = TextDocumentIdentifier{URIMainFile};
+    const auto &SM = AST.getSourceManager();
+    const Position &P = sourceLocToPosition(SM, SM.getComposedLoc(SM.getMainFileID(), Inclusion.HashOffset));
+    llvm::errs() << "Position in code lens computation: " << P << "\n";
+    cmd.argument2 = P;
+    Lens.command = cmd;
+    Result.push_back(Lens);  
+  }
+  
+  
+  for (auto CodeLens : Result) {
+    llvm::errs() << "CODE LENS: " << CodeLens << "\n";
+  }
+  return Result;
+}
+
 ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
                                 const SymbolIndex *Index, bool AddContext) {
+  llvm::errs() << "Path: " << AST.tuPath() << "\n";
+  llvm::errs() << "Position: " << Pos << "\n";
   ReferencesResult Results;
   const SourceManager &SM = AST.getSourceManager();
   auto MainFilePath = AST.tuPath();
   auto URIMainFile = URIForFile::canonicalize(MainFilePath, MainFilePath);
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return {};
   }
 
+  auto Includes = AST.getIncludeStructure().MainFileIncludes;
+  auto ConvertedMainFileIncludes = convertIncludes(SM, Includes);
+  for (auto &Inc : Includes) {
+    if (Inc.HashLine != Pos.line)
+      continue;
+
+    auto ReferencedInclude = convertIncludes(SM, Inc);
+    include_cleaner::walkUsed(
+        AST.getLocalTopLevelDecls(), collectMacroReferences(AST),
+        AST.getPragmaIncludes(), SM,
+        [&](const include_cleaner::SymbolReference &Ref,
+            llvm::ArrayRef<include_cleaner::Header> Providers) {
+          if (Ref.RT != include_cleaner::RefType::Explicit)
+            return;
+
+          auto Loc = SM.getFileLoc(Ref.RefLocation);
+          for (const auto &H : Providers) {
+            auto MatchingIncludes = ConvertedMainFileIncludes.match(H);
+            // No match for this provider in the main file.
+            if (MatchingIncludes.empty())
+              continue;
+
+            // Check if the referenced include matches this provider.
+            if (!ReferencedInclude.match(H).empty()) {
+              ReferencesResult::Reference Result;
+              auto TokLen =
+                  Lexer::MeasureTokenLength(Loc, SM, AST.getLangOpts());
+              Result.Loc.range =
+                  halfOpenToRange(SM, CharSourceRange::getCharRange(
+                                          Loc, Loc.getLocWithOffset(TokLen)));
+              Result.Loc.uri = URIMainFile;
+              Results.References.push_back(std::move(Result));
+            }
+
+            // Don't look for rest of the providers once we've found a match
+            // in the main file.
+            return;
+          }
+        });
+    if (Results.References.empty())
+      return {};
+
+    // Add the #include line to the references list.
+    auto IncludeLen =
+        std::string{"#include"}.length() + Inc.Written.length() + 1;
+    ReferencesResult::Reference Result;
+    Result.Loc.range = clangd::Range{Position{Inc.HashLine, 0},
+                                     Position{Inc.HashLine, (int)IncludeLen}};
+    Result.Loc.uri = URIMainFile;
+    Results.References.push_back(std::move(Result));
+  }
+
   llvm::DenseSet<SymbolID> IDsToQuery, OverriddenMethods;
 
   const auto *IdentifierAtCursor =
       syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
   std::optional<DefinedMacro> Macro;
   if (IdentifierAtCursor)
     Macro = locateMacroAt(*IdentifierAtCursor, AST.getPreprocessor());
   if (Macro) {