feat: Support code nav for data members and globals (#131)

varungandhi-src · web-flow · commit 8ef745427961 · 2023-03-22T19:49:33.000+09:00
diff --git a/indexer/Indexer.cc b/indexer/Indexer.cc
@@ -297,6 +297,25 @@ void TuIndexer::saveEnumTypeLoc(const clang::EnumTypeLoc &enumTypeLoc) {
   this->saveTagTypeLoc(enumTypeLoc);
 }
 
+void TuIndexer::saveFieldDecl(const clang::FieldDecl &fieldDecl) {
+  auto optSymbol = this->symbolFormatter.getFieldSymbol(fieldDecl);
+  if (!optSymbol.has_value()) {
+    return;
+  }
+  scip::SymbolInformation symbolInfo{};
+  for (auto &docComment : this->tryGetDocComment(fieldDecl)) {
+    *symbolInfo.add_documentation() = std::move(docComment.Text);
+  }
+  this->saveDefinition(optSymbol.value(), fieldDecl.getLocation(), symbolInfo);
+}
+
+void TuIndexer::saveFieldReference(const clang::FieldDecl &fieldDecl,
+                                   clang::SourceLocation loc) {
+  if (auto optSymbol = this->symbolFormatter.getFieldSymbol(fieldDecl)) {
+    this->saveReference(*optSymbol, loc);
+  }
+}
+
 void TuIndexer::saveFunctionDecl(const clang::FunctionDecl &functionDecl) {
   auto optSymbol = this->symbolFormatter.getFunctionSymbol(functionDecl);
   if (!optSymbol.has_value()) {
@@ -518,7 +537,18 @@ void TuIndexer::saveVarDecl(const clang::VarDecl &varDecl) {
     this->saveDefinition(optSymbol.value(), varDecl.getLocation(),
                          std::nullopt);
   }
-  // TODO: Add support for static and non-static data members.
+  if (varDecl.isStaticDataMember() || varDecl.isFileVarDecl()) {
+    // Non-static data members are handled by saveFieldDecl
+    auto optSymbol = this->symbolFormatter.getVarSymbol(varDecl);
+    if (!optSymbol.has_value()) {
+      return;
+    }
+    scip::SymbolInformation symbolInfo{};
+    for (auto &docComment : this->tryGetDocComment(varDecl)) {
+      *symbolInfo.add_documentation() = std::move(docComment.Text);
+    }
+    this->saveDefinition(optSymbol.value(), varDecl.getLocation(), symbolInfo);
+  }
 }
 
 void TuIndexer::saveDeclRefExpr(const clang::DeclRefExpr &declRefExpr) {
diff --git a/indexer/Indexer.h b/indexer/Indexer.h
@@ -217,6 +217,7 @@ class TuIndexer final {
   FOR_EACH_DECL_TO_BE_INDEXED(SAVE_DECL)
 #undef SAVE_DECL
 
+  void saveFieldReference(const clang::FieldDecl &, clang::SourceLocation);
   void saveTagDecl(const clang::TagDecl &);
   void saveTagTypeLoc(const clang::TagTypeLoc &);
 
diff --git a/indexer/SymbolFormatter.cc b/indexer/SymbolFormatter.cc
@@ -395,6 +395,25 @@ SymbolFormatter::getFunctionSymbol(const clang::FunctionDecl &functionDecl) {
       });
 }
 
+std::optional<std::string_view>
+SymbolFormatter::getFieldSymbol(const clang::FieldDecl &fieldDecl) {
+  if (fieldDecl.getDeclName().isEmpty()) {
+    return {};
+  }
+  return this->getSymbolCached(fieldDecl, [&]() -> std::optional<std::string> {
+    auto optContextSymbol = this->getContextSymbol(*fieldDecl.getDeclContext());
+    if (!optContextSymbol.has_value()) {
+      return {};
+    }
+    return SymbolBuilder::formatContextual(
+        optContextSymbol.value(),
+        DescriptorBuilder{
+            .name = llvm_ext::toStringView(fieldDecl.getName()),
+            .suffix = scip::Descriptor::Term,
+        });
+  });
+}
+
 std::optional<std::string_view>
 SymbolFormatter::getNamedDeclSymbol(const clang::NamedDecl &namedDecl) {
 #define HANDLE(kind_)                                                \
@@ -459,6 +478,9 @@ SymbolFormatter::getVarSymbol(const clang::VarDecl &varDecl) {
   if (varDecl.isLocalVarDeclOrParm()) {
     return this->getLocalVarOrParmSymbol(varDecl);
   }
+  if (varDecl.getDeclName().isEmpty()) {
+    return {};
+  }
   return this->getSymbolCached(varDecl, [&]() -> std::optional<std::string> {
     using Kind = clang::Decl::Kind;
     // Based on
@@ -470,12 +492,20 @@ SymbolFormatter::getVarSymbol(const clang::VarDecl &varDecl) {
                      " they should be handled in TuIndexer");
     case Kind::ParmVar:
       ENFORCE(false, "already handled parameter case earlier");
-    // TODO: Add support for template specializations and OMP captured exprs.
     case Kind::VarTemplatePartialSpecialization:
     case Kind::VarTemplateSpecialization:
+    case Kind::Var: {
+      if (auto optContextSymbol =
+              this->getContextSymbol(*varDecl.getDeclContext())) {
+        auto descriptor = DescriptorBuilder{
+            .name = llvm_ext::toStringView(varDecl.getName()),
+            .suffix = scip::Descriptor::Term,
+        };
+        return SymbolBuilder::formatContextual(*optContextSymbol, descriptor);
+      }
+      return {};
+    }
     case Kind::OMPCapturedExpr:
-    case Kind::Var:
-      // TODO: Add support for static and non-static data members
       return {};
     default: {
       spdlog::warn("unhandled kind {} of VarDecl: {}",
diff --git a/indexer/SymbolFormatter.h b/indexer/SymbolFormatter.h
@@ -20,6 +20,7 @@
   F(Binding)                           \
   F(EnumConstant)                      \
   F(Enum)                              \
+  F(Field)                             \
   F(Function)                          \
   F(Namespace)                         \
   F(Record)                            \
diff --git a/indexer/Worker.cc b/indexer/Worker.cc
@@ -20,6 +20,7 @@
 #include "spdlog/fmt/fmt.h"
 #include "spdlog/spdlog.h"
 
+#include "clang/AST/DeclCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Frontend/CompilerInstance.h"
@@ -732,6 +733,34 @@ class IndexerAstVisitor : public clang::RecursiveASTVisitor<IndexerAstVisitor> {
     return true;
   }
 
+#define TRY_TO(CALL_EXPR)              \
+  do {                                 \
+    if (!this->getDerived().CALL_EXPR) \
+      return false;                    \
+  } while (false)
+
+  /// Replace the default implementation of the Traverse* method as there
+  /// is no matching Visit* method, and the default implementation
+  /// does not visit member field references.
+  /// See https://github.com/llvm/llvm-project/issues/61602
+  bool TraverseConstructorInitializer(
+      const clang::CXXCtorInitializer *cxxCtorInitializer) {
+    if (clang::TypeSourceInfo *TInfo =
+            cxxCtorInitializer->getTypeSourceInfo()) {
+      TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
+    }
+    if (clang::FieldDecl *fieldDecl = cxxCtorInitializer->getAnyMember()) {
+      this->tuIndexer.saveFieldReference(
+          *fieldDecl, cxxCtorInitializer->getSourceLocation());
+    }
+    if (cxxCtorInitializer->isWritten()
+        || this->getDerived().shouldVisitImplicitCode()) {
+      TRY_TO(TraverseStmt(cxxCtorInitializer->getInit()));
+    }
+    return true;
+  }
+#undef TRY_TO
+
   void writeIndex(SymbolFormatter &&symbolFormatter, MacroIndexer &&macroIndex,
                   scip::Index &scipIndex) {
     std::vector<std::pair<RootRelativePathRef, clang::FileID>> relativePaths;
diff --git a/test/index/functions/ctors_dtors.snapshot.cc b/test/index/functions/ctors_dtors.snapshot.cc
@@ -18,13 +18,17 @@
   struct C {
 //       ^ definition [..] C#
     int x;
+//      ^ definition [..] C#x.
     int y;
+//      ^ definition [..] C#y.
   };
   
   struct D {
 //       ^ definition [..] D#
     int x;
+//      ^ definition [..] D#x.
     int y;
+//      ^ definition [..] D#y.
   
     D() = default;
 //  ^ definition [..] D#D(ced63f7c635d850d).
diff --git a/test/index/functions/operators.snapshot.cc b/test/index/functions/operators.snapshot.cc
@@ -20,10 +20,13 @@
   
   struct Int { int val; };
 //       ^^^ definition [..] Int#
+//                 ^^^ definition [..] Int#val.
   struct IntPair { Int x; Int y; };
 //       ^^^^^^^ definition [..] IntPair#
 //                 ^^^ reference [..] Int#
+//                     ^ definition [..] IntPair#x.
 //                        ^^^ reference [..] Int#
+//                            ^ definition [..] IntPair#y.
   
   IntPair operator,(Int x, Int y) {
 //^^^^^^^ reference [..] IntPair#
@@ -46,6 +49,7 @@
     return Int{i.val+1};
 //         ^^^ reference [..] Int#
 //             ^ reference local 4
+//               ^^^ reference [..] Int#val.
   }
   
   struct FnLike {
@@ -57,21 +61,25 @@
   struct Table {
 //       ^^^^^ definition [..] Table#
     int value;
+//      ^^^^^ definition [..] Table#value.
     int &operator[](int i, int j) { // since C++23
 //       ^^^^^^^^ definition [..] Table#`operator[]`(77cf9b7ed2f5124c).
 //                      ^ definition local 5
 //                             ^ definition local 6
       return this->value;
+//                 ^^^^^ reference [..] Table#value.
     }
   };
   
   struct TablePtr {
 //       ^^^^^^^^ definition [..] TablePtr#
     Table *t;
 //  ^^^^^ reference [..] Table#
+//         ^ definition [..] TablePtr#t.
     Table *operator->() { return t; }
 //  ^^^^^ reference [..] Table#
 //         ^^^^^^^^ definition [..] TablePtr#`operator->`(ed921902444779f1).
+//                               ^ reference [..] TablePtr#t.
   };
   
   void test_overloaded_operators() {
@@ -97,6 +105,7 @@
 //                  ^ reference local 9
     p.x++;
 //  ^ reference local 10
+//    ^ reference [..] IntPair#x.
 //     ^^ reference [..] operator++(be31e3af2b2ba0e).
   
     FnLike()();
@@ -108,6 +117,7 @@
     TablePtr{}->value;
 //  ^^^^^^^^ reference [..] TablePtr#
 //            ^^ reference [..] TablePtr#`operator->`(ed921902444779f1).
+//              ^^^^^ reference [..] Table#value.
   }
   
   // User-defined conversion function
diff --git a/test/index/macros/macros.snapshot.cc b/test/index/macros/macros.snapshot.cc
@@ -3,6 +3,7 @@
   #include "macros.h"
   
   int a = MY_MACRO + MY_MACRO_ALIAS;
+//    ^ definition [..] a.
 //        ^^^^^^^^ reference [..] `macros.h:1:9`!
 //                   ^^^^^^^^^^^^^^ reference [..] `macros.h:9:9`!
   
@@ -16,6 +17,7 @@
 //        ^^^^^^^^ definition [..] `macros.cc:12:9`!
   
   int b = MY_MACRO;
+//    ^ definition [..] b.
 //        ^^^^^^^^ reference [..] `macros.cc:12:9`!
   
   #if defined(MY_MACRO)
@@ -44,6 +46,7 @@
 //        ^^^^^^^^^^^^^^ definition [..] `macros.cc:32:9`!
   
   int c = IDENTITY_MACRO(10);
+//    ^ definition [..] c.
 //        ^^^^^^^^^^^^^^ reference [..] `macros.cc:32:9`!
   
   #define MACRO_USING_MACRO \
@@ -53,5 +56,6 @@
   
   // two uses of a macro that expands to another macro
   int d = MACRO_USING_MACRO + MACRO_USING_MACRO;
+//    ^ definition [..] d.
 //        ^^^^^^^^^^^^^^^^^ reference [..] `macros.cc:36:9`!
 //                            ^^^^^^^^^^^^^^^^^ reference [..] `macros.cc:36:9`!
diff --git a/test/index/macros/use_system_header.snapshot.cc b/test/index/macros/use_system_header.snapshot.cc
@@ -1,5 +1,6 @@
   #include "system_header.h"
   
   const int total = SYSTEM_INT + OTHER_SYSTEM_INT;
+//          ^^^^^ definition [..] total.
 //                  ^^^^^^^^^^ reference [..] `system_header.h:3:9`!
 //                               ^^^^^^^^^^^^^^^^ reference [..] `system_header.h:5:9`!
diff --git a/test/index/types/bad_tagdecl.snapshot.cc b/test/index/types/bad_tagdecl.snapshot.cc
@@ -26,5 +26,6 @@
   template <class T>
   struct ShouldEnable { static bool const value = false; };
 //       ^^^^^^^^^^^^ definition [..] ShouldEnable#
+//                                        ^^^^^ definition [..] ShouldEnable#value.
   
   struct MyTemplate<Undeclared, enable_if_t<ShouldEnable<int8_t>::value>> { };
diff --git a/test/index/types/types.snapshot.cc b/test/index/types/types.snapshot.cc
@@ -69,6 +69,7 @@
 //    | Everywhere a moo-moo 
 //         ^^ reference [..] has_anon_enum/E2.
     } f = F1;
+//    ^ definition [..] has_anon_enum/f.
 //        ^^ reference [..] has_anon_enum/F1.
   }
   
@@ -83,10 +84,12 @@
     enum { ANON1 } anon1;
 //  ^^^^ definition [..] F1#$anonymous_type_2#
 //         ^^^^^ definition [..] F1#ANON1.
+//                 ^^^^^ definition [..] F1#anon1.
     enum { ANON2 = ANON1 } anon2;
 //  ^^^^ definition [..] F1#$anonymous_type_3#
 //         ^^^^^ definition [..] F1#ANON2.
 //                 ^^^^^ reference [..] F1#ANON1.
+//                         ^^^^^ definition [..] F1#anon2.
   };
   
   class F0 {
@@ -212,6 +215,7 @@
   struct L {};
 //       ^ definition [..] L#
   auto trailing_return_type() -> L {
+//     ^^^^^^^^^^^^^^^^^^^^ definition [..] trailing_return_type(693bfa61ed1914d5).
 //                               ^ reference [..] L#
     // Explicit template param list on lambda needs C++20
     auto ignore_first = []<class T>(T, L l) -> L {
diff --git a/test/index/types/types.snapshot.h b/test/index/types/types.snapshot.h
@@ -5,5 +5,6 @@
 //  ^^^^ definition [..] has_anon_enum/$anonymous_type_a58c49fe3a7ec9aa_0#
 //         ^^ definition [..] has_anon_enum/E1.
 //             ^^ definition [..] has_anon_enum/E2.
+//                  ^ definition [..] has_anon_enum/e.
 //                      ^^ reference [..] has_anon_enum/E1.
   }
diff --git a/test/index/vars/members.cc b/test/index/vars/members.cc
@@ -0,0 +1,29 @@
+struct S0 {
+  int x = a;
+  static constexpr int a = 0;
+  static int y;
+
+  S0(): x(a) {
+    x += y;
+  }
+};
+
+int S0::y = 3;
+
+struct S1: S0 {
+  S1(): S0() {
+    x = y;
+  }
+};
+
+struct S2 {
+  struct { int a; };
+  union u { float x; int y; };
+  int : 4;
+  int b: 3;
+
+  S2(): b(1) {
+    a = 10; // Indirect field access
+  }
+};
+
diff --git a/test/index/vars/members.snapshot.cc b/test/index/vars/members.snapshot.cc
diff --git a/test/index/vars/vars.cc b/test/index/vars/vars.cc
diff --git a/test/index/vars/vars.snapshot.cc b/test/index/vars/vars.snapshot.cc
