fix: Emit references for non-TagType specifiers (#317)

Author: varungandhi-src

indexer/Indexer.cc

@@ -530,6 +530,31 @@ void TuIndexer::saveNamespaceDecl(const clang::NamespaceDecl &namespaceDecl) {
   this->saveDefinition(symbol, startLoc, std::move(symbolInfo));
 }
 
+void TuIndexer::trySaveTypeReference(const clang::Type *type,
+                                     clang::SourceLocation loc) {
+  if (!type) {
+    return;
+  }
+  const clang::NamedDecl *namedDecl = nullptr;
+  if (auto *typedefType = llvm::dyn_cast<clang::TypedefType>(type)) {
+    namedDecl = typedefType->getDecl();
+  } else if (auto *tagDecl = type->getAsTagDecl()) {
+    namedDecl = tagDecl;
+  } else if (auto *templateSpecializationType =
+                 llvm::dyn_cast<clang::TemplateSpecializationType>(type)) {
+    if (auto *templateDecl =
+            templateSpecializationType->getTemplateName().getAsTemplateDecl()) {
+      namedDecl = templateDecl->getTemplatedDecl();
+    }
+  }
+  if (!namedDecl) {
+    return;
+  }
+  if (auto optSymbol = this->symbolFormatter.getNamedDeclSymbol(*namedDecl)) {
+    this->saveReference(*optSymbol, loc);
+  }
+}
+
 void TuIndexer::saveNestedNameSpecifierLoc(
     const clang::NestedNameSpecifierLoc &argNameSpecLoc) {
   clang::NestedNameSpecifierLoc nameSpecLoc = argNameSpecLoc;
@@ -554,9 +579,7 @@ void TuIndexer::saveNestedNameSpecifierLoc(
     }
     case Kind::TypeSpec: {
       auto *type = nameSpec->getAsType();
-      if (auto *tagDecl = type->getAsTagDecl()) {
-        tryEmit(nameSpecLoc, *tagDecl);
-      }
+      this->trySaveTypeReference(type, nameSpecLoc.getLocalBeginLoc());
       break;
     }
     // FIXME(issue: https://github.com/sourcegraph/scip-clang/issues/109)

indexer/Indexer.h

@@ -45,6 +45,7 @@ class SourceManager;
 class TagDecl;
 class TagTypeLoc;
 class Token;
+class Type;
 } // namespace clang
 
 namespace scip {
@@ -265,6 +266,9 @@ class TuIndexer final {
   void saveTagDecl(const clang::TagDecl &);
   void saveTagTypeLoc(const clang::TagTypeLoc &);
 
+  // Save a reference to a possibly-sugared type, without canonicalization.
+  void trySaveTypeReference(const clang::Type *, clang::SourceLocation);
+
 #define SAVE_EXPR(ExprName) \
   void save##ExprName##Expr(const clang::ExprName##Expr &);
   FOR_EACH_EXPR_TO_BE_INDEXED(SAVE_EXPR)

test/index/functions/ctors_dtors.snapshot.cc

@@ -22,10 +22,12 @@
   template <typename T>
 //                   ^ definition local 3
   typename remove_ref<T>::type&& move(T&& arg) {
+//         ^^^^^^^^^^ reference [..] remove_ref#
 //                               ^^^^ definition [..] move(721d19cf58c53974).
 //                                    ^ reference local 3
 //                                        ^^^ definition local 4
     return static_cast<typename remove_ref<T>::type&&>(arg);
+//                              ^^^^^^^^^^ reference [..] remove_ref#
 //                                                     ^^^ reference local 4
   }
 

test/index/types/bad_tagdecl.snapshot.cc

@@ -29,6 +29,7 @@
 //                        ^ definition local 4
   using enable_if_t = typename enable_if<B,T>::type;
 //      ^^^^^^^^^^^ definition [..] enable_if_t#
+//                             ^^^^^^^^^ reference [..] enable_if#
 
   template <typename T, typename Enable = void> struct MyTemplate { };
 //                   ^ definition local 5

test/index/types/templates.cc

@@ -49,3 +49,14 @@ void use_empty() {
   Empty<PointerType<void *>> z;
   RefPtr<int> w;
 }
+
+template <typename T>
+struct M0 {
+  using A = int;
+};
+
+template <typename T>
+struct M1: M0<T> {
+  using B = M0<T>;
+  using B::A;
+};

test/index/types/templates.snapshot.cc

@@ -68,6 +68,7 @@
 //                   ^ definition local 13
   using RefPtr = typename PointerType<T &>::type;
 //      ^^^^^^ definition [..] RefPtr#
+//                        ^^^^^^^^^^^ reference [..] PointerType#
 
   using IntRefPtr = RefPtr<int>;
 //      ^^^^^^^^^ definition [..] IntRefPtr#
@@ -77,10 +78,12 @@
 //                   ^ definition local 14
   using PtrPtr = typename PointerType<T *>::type;
 //      ^^^^^^ definition [..] PtrPtr#
+//                        ^^^^^^^^^^^ reference [..] PointerType#
 
   template <typename T, typename S = typename PointerType<T>::type>
 //                   ^ definition local 15
 //                               ^ definition local 16
+//                                            ^^^^^^^^^^^ reference [..] PointerType#
   void specialized(T) {}
 //     ^^^^^^^^^^^ definition [..] specialized(9b289cee16747614).
 //                 ^ reference local 15
@@ -111,3 +114,25 @@
 //  ^^^^^^ reference [..] RefPtr#
 //              ^ definition local 21
   }
+  
+  template <typename T>
+//                   ^ definition local 22
+  struct M0 {
+//       ^^ definition [..] M0#
+    using A = int;
+//        ^ definition [..] M0#A#
+  };
+  
+  template <typename T>
+//                   ^ definition local 23
+  struct M1: M0<T> {
+//       ^^ definition [..] M1#
+//           ^^ reference [..] M0#
+//              ^ reference local 23
+    using B = M0<T>;
+//        ^ definition [..] M1#B#
+//            ^^ reference [..] M0#
+//               ^ reference local 23
+    using B::A;
+//        ^ reference [..] M1#B#
+  };

test/index/types/types.cc

@@ -124,3 +124,12 @@ auto trailing_return_type() -> L {
   };
   return ignore_first("", L{});
 }
+
+struct M0 {
+  using A = int;
+};
+
+struct M1: M0 {
+  using B = M0;
+  using B::A;
+};

test/index/types/types.snapshot.cc

@@ -344,3 +344,32 @@
 //                     ^ reference [..] trailing_return_type(693bfa61ed1914d5).$anonymous_type_4#`operator()`(dc97d1a1ce4cdab3).
 //                          ^ reference [..] L#
   }
+  
+  struct M0 {
+//       ^^ definition [..] M0#
+//       documentation
+//       | No documentation available.
+    using A = int;
+//        ^ definition [..] M0#A#
+//        documentation
+//        | No documentation available.
+  };
+  
+  struct M1: M0 {
+//       ^^ definition [..] M1#
+//       documentation
+//       | No documentation available.
+//       relation implementation [..] M0#
+//           ^^ reference [..] M0#
+    using B = M0;
+//        ^ definition [..] M1#B#
+//        documentation
+//        | No documentation available.
+//            ^^ reference [..] M0#
+    using B::A;
+//        ^ reference [..] M1#B#
+//           ^ reference [..] M0#A#
+//           ^ definition [..] M1#A#
+//           documentation
+//           | No documentation available.
+  };