Index: clangd/ClangdLSPServer.h =================================================================== --- clangd/ClangdLSPServer.h +++ clangd/ClangdLSPServer.h @@ -74,6 +74,7 @@ void onWorkspaceSymbol(WorkspaceSymbolParams &Params) override; void onRename(RenameParams &Parames) override; void onHover(TextDocumentPositionParams &Params) override; + void onTypeHierarchy(TextDocumentPositionParams &Params) override; void onChangeConfiguration(DidChangeConfigurationParams &Params) override; void onCancelRequest(CancelParams &Params) override; Index: clangd/ClangdLSPServer.cpp =================================================================== --- clangd/ClangdLSPServer.cpp +++ clangd/ClangdLSPServer.cpp @@ -414,6 +414,19 @@ }); } +void ClangdLSPServer::onTypeHierarchy(TextDocumentPositionParams &Params) { + Server.findTypeHierarchy(Params.textDocument.uri.file(), Params.position, + [](llvm::Expected> H) { + if (!H) { + replyError(ErrorCode::InternalError, + llvm::toString(H.takeError())); + return; + } + + reply(*H); + }); +} + void ClangdLSPServer::applyConfiguration( const ClangdConfigurationParamsChange &Settings) { // Compilation database change. Index: clangd/ClangdServer.h =================================================================== --- clangd/ClangdServer.h +++ clangd/ClangdServer.h @@ -149,6 +149,10 @@ void findHover(PathRef File, Position Pos, Callback> CB); + /// Get type hierarchy information for a given position. + void findTypeHierarchy(PathRef File, Position Pos, + Callback> CB); + /// Retrieve the top symbols from the workspace matching a query. void workspaceSymbols(StringRef Query, int Limit, Callback> CB); Index: clangd/ClangdServer.cpp =================================================================== --- clangd/ClangdServer.cpp +++ clangd/ClangdServer.cpp @@ -476,6 +476,18 @@ WorkScheduler.runWithAST("Hover", File, Bind(Action, std::move(CB))); } +void ClangdServer::findTypeHierarchy( + PathRef File, Position Pos, Callback> CB) { + auto Action = [Pos](Callback> CB, + llvm::Expected InpAST) { + if (!InpAST) + return CB(InpAST.takeError()); + CB(clangd::getTypeHierarchy(InpAST->AST, Pos)); + }; + + WorkScheduler.runWithAST("Type Hierarchy", File, Bind(Action, std::move(CB))); +} + void ClangdServer::consumeDiagnostics(PathRef File, DocVersion Version, std::vector Diags) { // We need to serialize access to resulting diagnostics to avoid calling Index: clangd/Protocol.h =================================================================== --- clangd/Protocol.h +++ clangd/Protocol.h @@ -881,6 +881,36 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &, const CancelParams &); bool fromJSON(const llvm::json::Value &, CancelParams &); +struct TypeHierarchyResult { + std::string Name; + Position Pos; + + // Does this node implement the method targeted by the request? + bool DeclaresMethod; + + std::vector Parents; + + friend bool operator==(const TypeHierarchyResult &lhs, + const TypeHierarchyResult &rhs) { + return lhs.Name == rhs.Name && lhs.Pos == rhs.Pos && + lhs.DeclaresMethod == rhs.DeclaresMethod && + lhs.Parents == rhs.Parents; + } +}; + +llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TypeHierarchyResult &); + +struct TypeHierarchy { + std::vector Parents; + + friend bool operator==(const TypeHierarchy &lhs, const TypeHierarchy &rhs) { + return lhs.Parents == rhs.Parents; + } +}; + +llvm::json::Value toJSON(const TypeHierarchy &DH); +llvm::raw_ostream &operator<<(llvm::raw_ostream &, const TypeHierarchy &); + /// Param can be either of type string or number. Returns the result as a /// string. llvm::Optional parseNumberOrString(const llvm::json::Value *Param); Index: clangd/Protocol.cpp =================================================================== --- clangd/Protocol.cpp +++ clangd/Protocol.cpp @@ -597,6 +597,53 @@ return O; } +json::Value toJSON(const TypeHierarchyResult &THR) { + json::Object Result; + + Result["name"] = THR.Name; + Result["position"] = toJSON(THR.Pos); + // FIXME: write the rest + + return Result; +} + +static llvm::raw_ostream & +operator<<(llvm::raw_ostream &O, const std::vector &V) { + O << '{'; + + for (size_t i = 0; i < V.size(); i++) { + O << V[i]; + if (i != 0) { + O << " ,"; + } + } + + O << '}'; + + return O; +} + +llvm::raw_ostream &operator<<(llvm::raw_ostream &O, + const TypeHierarchyResult &V) { + O << "{Name=" << V.Name << ", Pos=" << V.Pos + << ", DeclaresMethod=" << V.DeclaresMethod << ", Parents=" << V.Parents + << "}"; + return O; +} + +json::Value toJSON(const TypeHierarchy &TH) { + json::Object Result; + + Result["parents"] = json::Array(TH.Parents); + + return Result; +} + +llvm::raw_ostream &operator<<(llvm::raw_ostream &O, const TypeHierarchy &V) { + O << "Parents=" << V.Parents; + return O; +} + bool fromJSON(const json::Value &Params, DidChangeConfigurationParams &CCP) { json::ObjectMapper O(Params); return O && O.map("settings", CCP.settings); Index: clangd/ProtocolHandlers.h =================================================================== --- clangd/ProtocolHandlers.h +++ clangd/ProtocolHandlers.h @@ -54,6 +54,7 @@ virtual void onRename(RenameParams &Parames) = 0; virtual void onDocumentHighlight(TextDocumentPositionParams &Params) = 0; virtual void onHover(TextDocumentPositionParams &Params) = 0; + virtual void onTypeHierarchy(TextDocumentPositionParams &Params) = 0; virtual void onChangeConfiguration(DidChangeConfigurationParams &Params) = 0; virtual void onCancelRequest(CancelParams &Params) = 0; }; Index: clangd/ProtocolHandlers.cpp =================================================================== --- clangd/ProtocolHandlers.cpp +++ clangd/ProtocolHandlers.cpp @@ -67,6 +67,7 @@ &ProtocolCallbacks::onSwitchSourceHeader); Register("textDocument/rename", &ProtocolCallbacks::onRename); Register("textDocument/hover", &ProtocolCallbacks::onHover); + Register("textDocument/typeHierarchy", &ProtocolCallbacks::onTypeHierarchy); Register("textDocument/documentSymbol", &ProtocolCallbacks::onDocumentSymbol); Register("workspace/didChangeWatchedFiles", &ProtocolCallbacks::onFileEvent); Register("workspace/executeCommand", &ProtocolCallbacks::onCommand); Index: clangd/XRefs.h =================================================================== --- clangd/XRefs.h +++ clangd/XRefs.h @@ -34,6 +34,9 @@ /// Get the hover information when hovering at \p Pos. llvm::Optional getHover(ParsedAST &AST, Position Pos); +/// Get the type hierarchy information at \p Pos. +llvm::Optional getTypeHierarchy(ParsedAST &AST, Position Pos); + } // namespace clangd } // namespace clang Index: clangd/XRefs.cpp =================================================================== --- clangd/XRefs.cpp +++ clangd/XRefs.cpp @@ -17,6 +17,10 @@ #include "clang/Index/IndexingAction.h" #include "clang/Index/USRGeneration.h" #include "llvm/Support/Path.h" + +// temporary +#include + namespace clang { namespace clangd { using namespace llvm; @@ -660,5 +664,84 @@ return None; } +static bool MethodMatches(const CXXMethodDecl *Method, + const CXXMethodDecl *Candidate) { + // FIXME: How do I determine if Method overrides Candidate? + + return true; +} + +static void getTypeHierarchyParents(const CXXRecordDecl *CXXRD, + const CXXMethodDecl *Method, + const SourceManager &SourceMgr, + std::vector *Result) { + for (auto It = CXXRD->bases_begin(); It != CXXRD->bases_end(); It++) { + const RecordType *ParentType = + It->getType().getTypePtr()->getAs(); + if (!ParentType) + continue; + + const CXXRecordDecl *ParentDecl = ParentType->getAsCXXRecordDecl(); + if (!ParentDecl) + continue; + + StringRef Name = ParentDecl->getName(); + SourceLocation Loc = ParentDecl->getBeginLoc(); + Position Pos = sourceLocToPosition(SourceMgr, Loc); + Result->emplace_back(TypeHierarchyResult{Name, Pos, false, {}}); + + std::cerr << " >>> A parent is " << ParentDecl->getName().str() + << std::endl; + + for (const auto &CandidateMethod : ParentDecl->methods()) { + if (MethodMatches(Method, CandidateMethod)) { + Result->back().DeclaresMethod = true; + break; + } + } + + getTypeHierarchyParents(ParentDecl, Method, SourceMgr, + &Result->back().Parents); + } +} + +static TypeHierarchy getTypeHierarchy(const CXXRecordDecl *CXXRD, + const CXXMethodDecl *Method, + const SourceManager &SourceMgr) { + TypeHierarchy Result; + getTypeHierarchyParents(CXXRD, Method, SourceMgr, &Result.Parents); + return Result; +} + +Optional getTypeHierarchy(ParsedAST &AST, Position Pos) { + const SourceManager &SourceMgr = AST.getASTContext().getSourceManager(); + SourceLocation SourceLocationBeg = + getBeginningOfIdentifier(AST, Pos, SourceMgr.getMainFileID()); + // Identified symbols at a specific position. + auto Symbols = getSymbolAtPosition(AST, SourceLocationBeg); + + if (Symbols.Decls.empty()) + return {}; + + const Decl *D = Symbols.Decls[0]; + const CXXRecordDecl *CXXRD; + + const CXXMethodDecl *Method = dyn_cast(D); + if (const VarDecl *VD = dyn_cast(D)) { + // If this is a variable, use the type of the variable. + CXXRD = VD->getType().getTypePtr()->getAsCXXRecordDecl(); + } else if (Method) { + // If this is a method, use the type of the class, but + CXXRD = Method->getParent(); + } else { + CXXRD = dyn_cast(D); + } + + if (CXXRD) + return getTypeHierarchy(CXXRD, Method, SourceMgr); + + return {}; +} + } // namespace clangd } // namespace clang Index: unittests/clangd/XRefsTests.cpp =================================================================== --- unittests/clangd/XRefsTests.cpp +++ unittests/clangd/XRefsTests.cpp @@ -27,6 +27,7 @@ namespace { using testing::ElementsAre; +using testing::Eq; using testing::Field; using testing::IsEmpty; using testing::Matcher; @@ -1068,6 +1069,166 @@ ElementsAre(Location{FooCppUri, FooWithoutHeader.range()})); } +TEST(TypeHierarchy, SimpleInheritanceOnTypeOrVariable) { + Annotations Source(R"cpp( +$ParentDef^struct Parent +{ + int a; +}; + +$Child1Def^struct Child1 : Parent +{ + int b; +}; + +struct Ch$p1^ild2 : Child1 +{ + int c; +}; + +struct Child3 : Child2 +{ + int d; +}; + +int main() +{ + Ch$p2^ild2 ch$p3^ild2; + + parent.a = 1; + ch$p4^ild2.c = 1; +} +)cpp"); + + TestTU TU = TestTU::withCode(Source.code()); + auto AST = TU.build(); + + llvm::Optional Result; + + TypeHierarchy ExpectedResult{{TypeHierarchyResult{ + "Child1", + Source.point("Child1Def"), + false, + {TypeHierarchyResult{"Parent", Source.point("ParentDef"), false, {}}}}}}; + + for (auto Pt : {"p1", "p2", "p3", "p4"}) { + Result = getTypeHierarchy(AST, Source.point(Pt)); + ASSERT_TRUE(bool(Result)); + EXPECT_THAT(*Result, Eq(ExpectedResult)); + } +} + +TEST(TypeHierarchy, MultipleInheritanceOnTypeOrVariable) { + Annotations Source(R"cpp( +$Parent1Def^struct Parent1 +{ + int a; +}; + +$Parent2Def^struct Parent2 +{ + int b; +}; + +$Parent3Def^struct Parent3 : Parent2 +{ + int c; +}; + +struct Ch$c1^ild : Parent1, Parent3 +{ + int d; +}; + +int main() +{ + Ch$c2^ild ch$c3^ild; + + ch$c4^ild.a = 1; +} +)cpp"); + + TestTU TU = TestTU::withCode(Source.code()); + auto AST = TU.build(); + + llvm::Optional Result; + TypeHierarchy ExpectedResult{{ + TypeHierarchyResult{"Parent1", Source.point("Parent1Def"), false, {}}, + TypeHierarchyResult{ + "Parent3", + Source.point("Parent3Def"), + false, + {TypeHierarchyResult{ + "Parent2", Source.point("Parent2Def"), false, {}}}}, + }}; + + for (auto Pt : {"c1", "c2", "c3", "c4"}) { + Result = getTypeHierarchy(AST, Source.point(Pt)); + ASSERT_TRUE(bool(Result)); + EXPECT_THAT(*Result, Eq(ExpectedResult)); + } +} + +TEST(TypeHierarchy, OnMethod) { + Annotations Source(R"cpp( +$ParentDef^struct Parent +{ + void method (); + void method () const; + void method (int x); + void method (char x); +}; + +$Child1Def^struct Child1 : Parent +{ + void method (); + void method (char x); +}; + +struct Child2 : Child1 +{ + void met$p1^hod (); + void met$p2^hod (int x); +}; + +struct Child3 : Child2 +{ + void method (int x); +}; +)cpp"); + + TestTU TU = TestTU::withCode(Source.code()); + auto AST = TU.build(); + + ASSERT_TRUE(AST.getDiagnostics().empty()); + + { + TypeHierarchy ExpectedResult{{TypeHierarchyResult{ + "Child1", + Source.point("Child1Def"), + true, + {TypeHierarchyResult{"Parent", Source.point("ParentDef"), true, {}}}}}}; + + llvm::Optional Result = + getTypeHierarchy(AST, Source.point("p1")); + ASSERT_TRUE(bool(Result)); + EXPECT_THAT(*Result, Eq(ExpectedResult)); + } + + { + TypeHierarchy ExpectedResult{{TypeHierarchyResult{ + "Child1", + Source.point("Child1Def"), + false, + {TypeHierarchyResult{"Parent", Source.point("ParentDef"), true, {}}}}}}; + + llvm::Optional Result = + getTypeHierarchy(AST, Source.point("p2")); + ASSERT_TRUE(bool(Result)); + EXPECT_THAT(*Result, Eq(ExpectedResult)); + } +} + } // namespace } // namespace clangd } // namespace clang