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>);
 
+  /// Implement code lens.
+  void onCodeLens(const CodeLensParams &Params, Callback<std::vector<CodeLens>> 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

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);
Server->findReferences(Params.textDocument.uri.file(), Params.position,
                                  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) {
+  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);

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);
 
+  /// Retrieve code lenses.
+  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 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 &);
 
+/// Parameters for the code lens request.
+struct CodeLensParams {
+  TextDocumentIdentifier textDocument;
+};
+bool fromJSON(const llvm::json::Value &, CodeLensParams &,
+              llvm::json::Path);
+
+/// Code lens response payload.
+struct CodeLens {
+  /// The range in which this code lens is valid.
+  Range range;
+  /// The command this code lens represents.
+  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);
+}
+
+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;
+}
+
 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) {

 
 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::json::Value toJSON(const Command &C) {  
   auto Cmd = llvm::json::Object{{"title", C.title}, {"command", C.command}};
-  if (!C.argument.getAsNull())
+  if (!C.argument.getAsNull() && !C.argument2.getAsNull()) {
+    Cmd["arguments"] = llvm::json::Array{C.argument, C.argument2};
+  } else if (!C.argument.getAsNull()) {
     Cmd["arguments"] = llvm::json::Array{C.argument};
+  }
+
   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) {

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 "clang/Index/IndexDataConsumer.h"
 #include "clang/Index/IndexSymbol.h"
 #include "clang/Index/IndexingAction.h"
 #include "clang/Index/IndexingOptions.h"
 #include "clang/Index/USRGeneration.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallSet.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 <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 // Returns the single definition of the entity declared by D, if visible.
 // In particular:
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) {
+  const auto &SM = AST.getSourceManager();
+  std::vector<CodeLens> Result;
+  auto Includes = AST.getIncludeStructure().MainFileIncludes;
+  auto ConvertedMainFileIncludes = convertIncludes(SM, Includes);
+  for (auto &Inc : Includes) {
+    llvm::DenseSet<include_cleaner::Symbol> UsedSyms;
+    auto AnalyzedInclude = 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;
+
+          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 (!AnalyzedInclude.match(H).empty()) {
+              UsedSyms.insert(Ref.Target);
+            }
+
+            // Don't look for rest of the providers once we've found a match
+            // in the main file.
+            break;
+          }
+        });
+
+    // Compute the length of the #include line
+    auto IncludeLen =
+        std::string{"#include"}.length() + Inc.Written.length() + 1;
+    CodeLens Lens;
+    Lens.range = clangd::Range{Position{Inc.HashLine, 0},
+                               Position{Inc.HashLine, (int)IncludeLen}};
+
+    Command Cmd;
+    Cmd.title = std::to_string(UsedSyms.size()) + " used symbols";
+    Cmd.command = "clangd/findReferences";
+    
+    auto MainFilePath = AST.tuPath();
+    auto URIMainFile = URIForFile::canonicalize(MainFilePath, MainFilePath);
+   
+    Cmd.argument = URIMainFile;
+    Position P = sourceLocToPosition(SM, SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset));
+    Cmd.argument2 = P;
+    Lens.command = Cmd;
+    Result.push_back(Lens);  
+  }
+  
+  return Result;
+}
+
 ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
                                 const SymbolIndex *Index, bool AddContext) {
   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) {

clang-tools-extra/clangd/test/initialize-params.test

 # RUN: clangd -lit-test < %s | FileCheck -strict-whitespace %s
 # Test initialize request parameters with rootUri
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootUri":"test:///workspace","capabilities":{},"trace":"off"}}
 #      CHECK:  "id": 0,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": {
 # CHECK-NEXT:    "capabilities": {
 # CHECK-NEXT:      "astProvider": true,
 # CHECK-NEXT:      "callHierarchyProvider": true,
 # CHECK-NEXT:      "clangdInlayHintsProvider": true,
 # CHECK-NEXT:      "codeActionProvider": true,
+# CHECK-NEXT:      "codeLensProvider": true,
 # CHECK-NEXT:      "compilationDatabase": {
 # CHECK-NEXT:        "automaticReload": true
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "completionProvider": {
 # CHECK-NEXT:        "resolveProvider": false,
 # CHECK-NEXT:        "triggerCharacters": [
 # CHECK-NEXT:          ".",
 # CHECK-NEXT:          "<",