(WIP) Type hierarchy

[simark]

Summary

This is a work in progress patch to support an eventual "get type
hierarchy" request that does not exist in the LSP today. I only plan to
support getting parent types (i.e. base classes) for now, because it
doesn't require touching the index. Finding child classes would come
later.

[kadircet]

clangd/Protocol.h

889

I think comment and the name is in contradiction here, do you mean DefinesMethod?

clangd/XRefs.cpp

669

https://github.com/llvm-mirror/clang/blob/master/lib/Sema/SemaDecl.cpp

you can check this sample, which simply traverses all base classes and gets methods with the same name, then checks whether one is overload of the other. If it they are not overloads then one in the base classes gets overriden by the other.

Another approach could be to search for one method in others overriden_methods.

But they are both inefficient, I would suggest calling these functions only when one of them is defined in the base class of other then you can just check for name equality and not being an overload.

693

If you plan to keep it for later debugging info, consider using {d,v}log

unittests/clangd/XRefsTests.cpp

1075

NIT: Maybe format test code as well.

[simark]

clangd/Protocol.h

889

Actually I think the comment is wrong. Even if we only see a declaration of the method, it's enough to say that this type has its own version of the method.

clangd/XRefs.cpp

669

https://github.com/llvm-mirror/clang/blob/master/lib/Sema/SemaDecl.cpp

Did you mean to link to a particular line?

you can check this sample, which simply traverses all base classes and gets methods with the same name, then checks whether one is overload of the other. If it they are not overloads then one in the base classes gets overriden by the other.

Another approach could be to search for one method in others overriden_methods.

I have tried using overriden_methods, but it only contains methods marked virtual. For this feature, I would like to consider non-virtual methods too.

But they are both inefficient, I would suggest calling these functions only when one of them is defined in the base class of other then you can just check for name equality and not being an overload.

I am not sure I understand, but maybe it will be clearer when I will see the sample.

693

Yes of course :)

[ilya-biryukov]

Thanks for looking into this. Would be cool to get this supported after the proposal is finalized.

clangd/Protocol.h

891

What is the proposal to add children (i.e. overriden methods) to the hierarchy?
This seems like a place where we might want to have multiple requests from the clients when expanding the nodes.

clangd/XRefs.cpp

669

See the code that actually computes a list for override_methods(): Sema::AddOverriddenMethods.

732

Why special-case the variables? Maybe just return empty results for consistency with other use-cases (typedefs, etc)?

741

Maybe also return all base types for classes?

[kadircet]

clangd/ProtocolHandlers.cpp

70

LSP doesn't have such an entry, maybe we should use workspace/executeCommand. WDYT @ilya-biryukov

clangd/XRefs.cpp

669

Did you mean to link to a particular line?

Yeah sorry, I was trying to link the function ilya mentioned.
https://github.com/llvm-mirror/clang/blob/master/lib/Sema/SemaDecl.cpp#L7615

Since you also mentioned checking non-virtual method as well you might wanna look at https://github.com/llvm-mirror/clang/blob/master/lib/Sema/SemaDecl.cpp#L7555 as well.

Also I got the chance to look the rest of the patch, as I mentioned above you are already checking two methods iff one lies in the others base classes. So you can simply check for name equality and not being an overload case.

[ilya-biryukov]

clangd/XRefs.cpp

669

Also wanted to bring up what @sammccall already mentioned on clangd-dev: we probably shouldn't show methods that hide base methods rather than override the virtual base methods (at least, by default).

Those might be useful, but unless we can have a clear UI indicator of whether a method is overriding a virtual base method or is hiding some other method, it would to add more confusion than benefit IMO.

[simark]

clangd/Protocol.h

891

In my prototype, I fetch the whole parent hierarchy in a single request. In the proposal at

https://github.com/Microsoft/vscode-languageserver-node/pull/346

it has been suggested to only fetch one level at the time, and have the client issue as many request as it wants (until possibly getting the whole hierarchy). I don't know what the protocol will end up like.

clangd/ProtocolHandlers.cpp

70

I don't intend to merge this patch before the protocol actually defines the way to get type hierarchy. So this will be updated to reflect what the protocol will actually define.

clangd/XRefs.cpp

669

Also I got the chance to look the rest of the patch, as I mentioned above you are already checking two methods iff one lies in the others base classes. So you can simply check for name equality and not being an overload case.

To check for an overload case, you would use Sema::IsOverload? Do we have access to a Sema object in this context?

Also wanted to bring up what @sammccall already mentioned on clangd-dev: we probably shouldn't show methods that hide base methods rather than override the virtual base methods (at least, by default).

Those might be useful, but unless we can have a clear UI indicator of whether a method is overriding a virtual base method or is hiding some other method, it would to add more confusion than benefit IMO.

Ok, I was basing my implementation on the behavior of Eclipse CDT, I don't think it differentiates virtual and non-virtual methods in that context. It just shows you Types declaring "method". But if you think it's better to leave them out, I'm fine with that.

732

I thought it would be useful as a shortcut, to be able to pop up the type hierarchy from a reference to a variable. But I guess to be really useful, it would need to work with pointers to. For example

Parent *parent = ...;
...
par^ent->method ();

Doing "type hierarchy" at the caret should open the type hierarchy for Parent, but it probably doesn't work in my patch. It's not an essential feature though, especially not for a first version.

741

Can you give an example? I think that's already what it does, but maybe I don't understand what you mean, or you found a bug.

clangd/ClangdLSPServer.h

private:
   void onGoToDefinition(TextDocumentPositionParams &Params) override;
   void onSwitchSourceHeader(TextDocumentIdentifier &Params) override;
   void onDocumentHighlight(TextDocumentPositionParams &Params) override;
   void onFileEvent(DidChangeWatchedFilesParams &Params) override;
   void onCommand(ExecuteCommandParams &Params) override;
   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;
 
   std::vector<Fix> getFixes(StringRef File, const clangd::Diagnostic &D);
 
   /// Forces a reparse of all currently opened files.  As a result, this method
   /// may be very expensive.  This method is normally called when the
   /// compilation database is changed.

clangd/ClangdLSPServer.cpp

Server.findHover(Params.textDocument.uri.file(), Params.position,
                                   llvm::toString(H.takeError()));
                        return;
                      }
 
                      reply(*H);
                    });
 }
 
+void ClangdLSPServer::onTypeHierarchy(TextDocumentPositionParams &Params) {
+  Server.findTypeHierarchy(Params.textDocument.uri.file(), Params.position,
+                           [](llvm::Expected<llvm::Optional<TypeHierarchy>> H) {
+                             if (!H) {
+                               replyError(ErrorCode::InternalError,
+                                          llvm::toString(H.takeError()));
+                               return;
+                             }
+
+                             reply(*H);
+                           });
+}
+
 void ClangdLSPServer::applyConfiguration(
     const ClangdConfigurationParamsChange &Settings) {
   // Compilation database change.
   if (Settings.compilationDatabasePath.hasValue()) {
     CDB.setCompileCommandsDir(Settings.compilationDatabasePath.getValue());
 
     reparseOpenedFiles();
   }

clangd/ClangdServer.h

public:
   /// Get document highlights for a given position.
   void findDocumentHighlights(PathRef File, Position Pos,
                               Callback<std::vector<DocumentHighlight>> CB);
 
   /// Get code hover for a given position.
   void findHover(PathRef File, Position Pos,
                  Callback<llvm::Optional<Hover>> CB);
 
+  /// Get type hierarchy information for a given position.
+  void findTypeHierarchy(PathRef File, Position Pos,
+                         Callback<llvm::Optional<TypeHierarchy>> CB);
+
   /// Retrieve the top symbols from the workspace matching a query.
   void workspaceSymbols(StringRef Query, int Limit,
                         Callback<std::vector<SymbolInformation>> CB);
 
   /// Retrieve the symbols within the specified file.
   void documentSymbols(StringRef File,
                        Callback<std::vector<SymbolInformation>> CB);
 

clangd/ClangdServer.cpp

auto Action = [Pos](Callback<llvm::Optional<Hover>> CB,
     if (!InpAST)
       return CB(InpAST.takeError());
     CB(clangd::getHover(InpAST->AST, Pos));
   };
 
   WorkScheduler.runWithAST("Hover", File, Bind(Action, std::move(CB)));
 }
 
+void ClangdServer::findTypeHierarchy(
+    PathRef File, Position Pos, Callback<llvm::Optional<TypeHierarchy>> CB) {
+  auto Action = [Pos](Callback<llvm::Optional<TypeHierarchy>> CB,
+                      llvm::Expected<InputsAndAST> 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<Diag> Diags) {
   // We need to serialize access to resulting diagnostics to avoid calling
   // `onDiagnosticsReady` in the wrong order.
   std::lock_guard<std::mutex> DiagsLock(DiagnosticsMutex);
   DocVersion &LastReportedDiagsVersion = ReportedDiagnosticVersions[File];
 
   // FIXME(ibiryukov): get rid of '<' comparison here. In the current

clangd/Protocol.h

struct CancelParams {
   /// This can be either a number or string, if it is a number simply print it
   /// out and always use a string.
   std::string ID;
 };
 llvm::json::Value toJSON(const CancelParams &);
 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<TypeHierarchyResult> 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<TypeHierarchyResult> 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<std::string> parseNumberOrString(const llvm::json::Value *Param);
 
 } // namespace clangd
 } // namespace clang
 
 namespace llvm {

clangd/Protocol.cpp

llvm::raw_ostream &operator<<(llvm::raw_ostream &O,
   O << V.range;
   if (V.kind == DocumentHighlightKind::Read)
     O << "(r)";
   if (V.kind == DocumentHighlightKind::Write)
     O << "(w)";
   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<TypeHierarchyResult> &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);
 }
 
 bool fromJSON(const llvm::json::Value &Params,
               ClangdCompileCommand &CDbUpdate) {
   json::ObjectMapper O(Params);

clangd/ProtocolHandlers.h

public:
   virtual void onGoToDefinition(TextDocumentPositionParams &Params) = 0;
   virtual void onSwitchSourceHeader(TextDocumentIdentifier &Params) = 0;
   virtual void onFileEvent(DidChangeWatchedFilesParams &Params) = 0;
   virtual void onCommand(ExecuteCommandParams &Params) = 0;
   virtual void onWorkspaceSymbol(WorkspaceSymbolParams &Params) = 0;
   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;
 };
 
 void registerCallbackHandlers(JSONRPCDispatcher &Dispatcher,
                               ProtocolCallbacks &Callbacks);
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clangd/ProtocolHandlers.cpp

void clangd::registerCallbackHandlers(JSONRPCDispatcher &Dispatcher,
   Register("textDocument/codeAction", &ProtocolCallbacks::onCodeAction);
   Register("textDocument/completion", &ProtocolCallbacks::onCompletion);
   Register("textDocument/signatureHelp", &ProtocolCallbacks::onSignatureHelp);
   Register("textDocument/definition", &ProtocolCallbacks::onGoToDefinition);
   Register("textDocument/switchSourceHeader",
            &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);
   Register("textDocument/documentHighlight",
            &ProtocolCallbacks::onDocumentHighlight);
   Register("workspace/didChangeConfiguration",
            &ProtocolCallbacks::onChangeConfiguration);
   Register("workspace/symbol", &ProtocolCallbacks::onWorkspaceSymbol);
   Register("$/cancelRequest", &ProtocolCallbacks::onCancelRequest);
 }

clangd/XRefs.h

 
 /// Returns highlights for all usages of a symbol at \p Pos.
 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
                                                       Position Pos);
 
 /// Get the hover information when hovering at \p Pos.
 llvm::Optional<Hover> getHover(ParsedAST &AST, Position Pos);
 
+/// Get the type hierarchy information at \p Pos.
+llvm::Optional<TypeHierarchy> getTypeHierarchy(ParsedAST &AST, Position Pos);
+
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_XREFS_H

clangd/XRefs.cpp

 #include "SourceCode.h"
 #include "URI.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Index/IndexDataConsumer.h"
 #include "clang/Index/IndexingAction.h"
 #include "clang/Index/USRGeneration.h"
 #include "llvm/Support/Path.h"
+
+// temporary
+#include <iostream>
+
 namespace clang {
 namespace clangd {
 using namespace llvm;
 namespace {
 
 // Get the definition from a given declaration `D`.
 // Return nullptr if no definition is found, or the declaration type of `D` is
 // not supported.
Optional<Hover> getHover(ParsedAST &AST, Position Pos) {
 
   auto DeducedType = getDeducedType(AST, SourceLocationBeg);
   if (DeducedType && !DeducedType->isNull())
     return getHoverContents(*DeducedType, AST.getASTContext());
 
   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<TypeHierarchyResult> *Result) {
+  for (auto It = CXXRD->bases_begin(); It != CXXRD->bases_end(); It++) {
+    const RecordType *ParentType =
+        It->getType().getTypePtr()->getAs<RecordType>();
+    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<TypeHierarchy> 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<CXXMethodDecl>(D);
+  if (const VarDecl *VD = dyn_cast<VarDecl>(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<CXXRecordDecl>(D);
+  }
+
+  if (CXXRD)
+    return getTypeHierarchy(CXXRD, Method, SourceMgr);
+
+  return {};
+}
+
 } // namespace clangd
 } // namespace clang

unittests/clangd/XRefsTests.cpp

 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 using namespace llvm;
 
 namespace {
 using testing::ElementsAre;
+using testing::Eq;
 using testing::Field;
 using testing::IsEmpty;
 using testing::Matcher;
 using testing::UnorderedElementsAreArray;
 
 class IgnoreDiagnostics : public DiagnosticsConsumer {
   void onDiagnosticsReady(PathRef File,
                           std::vector<Diag> Diagnostics) override {}
TEST(GoToDefinition, WithPreamble) {
   // Both preamble and AST are built in this request.
   Server.addDocument(FooCpp, FooWithoutHeader.code(), WantDiagnostics::Yes);
   // Use the AST being built in above request.
   EXPECT_THAT(
       cantFail(runFindDefinitions(Server, FooCpp, FooWithoutHeader.point())),
       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<TypeHierarchy> 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<TypeHierarchy> 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<TypeHierarchy> 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<TypeHierarchy> Result =
+        getTypeHierarchy(AST, Source.point("p2"));
+    ASSERT_TRUE(bool(Result));
+    EXPECT_THAT(*Result, Eq(ExpectedResult));
+  }
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang