[clang][Index] Visit UsingDecls and generate USRs for them

[kadircet]

Summary

Add indexing of UsingDecl itself.
Also enable generation of USRs for UsingDecls, using the qualified name of the
decl.

[ilya-biryukov]

lib/Index/IndexDecl.cpp

589

Any reason to add this to the middle of the function?
Could we move it to the end or to the start of the function instead?

So that the function logically reads as

visitDecl();
traverseSubdecls();
processReferences();

lib/Index/USRGeneration.cpp

115

We need to add a unique tag character here, e.g. namespace aliases are tagged as "@NA@", "@UD@" should be a good fit for using-decls.

118

This comment does not make sense for the using-decl, ParmDecl is not a using-decl.
If there are other cases where it may fail, let's put them into the comment.
If EmitDeclName should not fail for UsingDecl, let's add an assertion.

[kadircet]

• Address comments

[ilya-biryukov]

lib/Index/IndexDecl.cpp

587

NIT: maybe put it at the very first line of the function, before the DC and Parent decls?
To keep the variable declarations closer to their usages.

lib/Index/USRGeneration.cpp

118

add (void)EmittedDeclName to avoid unused warning with assertions disabled.

[ilya-biryukov]

LGTM, but we need to make sure the variable is used in configs without assertions, otherwise we'll break buildbots.

[kadircet]

• Address comments

[kadircet]

• Add SymbolSubKind for UsingDeclarations

[ilya-biryukov]

include/clang/Index/IndexSymbol.h

75

We don't seem to use the subkind anywhere. Let's remove it.

unittests/Index/IndexTests.cpp

253

Could we also test the kind is correct here?

[kadircet]

• Revert SymbolSubKind change
• Add test to check for SymbolKind

include/clang/Index/IndexSymbol.h

 enum class SymbolSubKind : uint8_t {
   None,
   CXXCopyConstructor,
   CXXMoveConstructor,
   AccessorGetter,
   AccessorSetter,
   UsingTypename,
   UsingValue,
+  UsingDeclaration,
 };
 
 typedef uint16_t SymbolPropertySet;
 /// Set of properties that provide additional info about a symbol.
 enum class SymbolProperty : SymbolPropertySet {
   Generic                       = 1 << 0,
   TemplatePartialSpecialization = 1 << 1,
   TemplateSpecialization        = 1 << 2,

lib/Index/IndexDecl.cpp

bool VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
     TRY_DECL(D, IndexCtx.handleDecl(D));
     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), D);
     IndexCtx.handleReference(D->getAliasedNamespace(), D->getTargetNameLoc(), D,
                              D->getLexicalDeclContext());
     return true;
   }
 
   bool VisitUsingDecl(const UsingDecl *D) {
+    IndexCtx.handleDecl(D);
+
     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);
-
     IndexCtx.indexNestedNameSpecifierLoc(D->getQualifierLoc(), Parent,
                                          D->getLexicalDeclContext());
     for (const auto *I : D->shadows())
       IndexCtx.handleReference(I->getUnderlyingDecl(), D->getLocation(), Parent,
                                D->getLexicalDeclContext(), SymbolRoleSet());
     return true;
   }
 
   bool VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
     const DeclContext *DC = D->getDeclContext()->getRedeclContext();
     const NamedDecl *Parent = dyn_cast<NamedDecl>(DC);

lib/Index/IndexSymbol.cpp

case Decl::UnresolvedUsingTypename:
       Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
       break;
     case Decl::UnresolvedUsingValue:
       Info.Kind = SymbolKind::Using;
       Info.SubKind = SymbolSubKind::UsingValue;
       Info.Lang = SymbolLanguage::CXX;
       Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
       break;
+    case Decl::Using:
+      Info.Kind = SymbolKind::Using;
+      Info.SubKind = SymbolSubKind::UsingDeclaration;
+      Info.Lang = SymbolLanguage::CXX;
+      Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
+      break;
     case Decl::Binding:
       Info.Kind = SymbolKind::Variable;
       Info.Lang = SymbolLanguage::CXX;
       break;
     default:
       break;
     }
   }
StringRef index::getSymbolSubKindString(SymbolSubKind K) {
   switch (K) {
   case SymbolSubKind::None: return "<none>";
   case SymbolSubKind::CXXCopyConstructor: return "cxx-copy-ctor";
   case SymbolSubKind::CXXMoveConstructor: return "cxx-move-ctor";
   case SymbolSubKind::AccessorGetter: return "acc-get";
   case SymbolSubKind::AccessorSetter: return "acc-set";
   case SymbolSubKind::UsingTypename: return "using-typename";
   case SymbolSubKind::UsingValue: return "using-value";
+  case SymbolSubKind::UsingDeclaration: return "using-declaration";
   }
   llvm_unreachable("invalid symbol subkind");
 }
 
 StringRef index::getSymbolLanguageString(SymbolLanguage K) {
   switch (K) {
   case SymbolLanguage::C: return "C";
   case SymbolLanguage::ObjC: return "ObjC";

lib/Index/USRGeneration.cpp

void VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
     IgnoreResults = true; // No USRs for linkage specs themselves.
   }
 
   void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
     IgnoreResults = true;
   }
 
   void VisitUsingDecl(const UsingDecl *D) {
-    IgnoreResults = true;
+    VisitDeclContext(D->getDeclContext());
+    Out << "@UD@";
+
+    bool EmittedDeclName = !EmitDeclName(D);
+    assert(EmittedDeclName && "EmitDeclName can not fail for UsingDecls");
+    (void)EmittedDeclName;
   }
 
   bool ShouldGenerateLocation(const NamedDecl *D);
 
   bool isLocal(const NamedDecl *D) {
     return D->getParentFunctionOrMethod() != nullptr;
   }
 

test/Index/usrs.cpp

 // CHECK: usrs.cpp c:@N@foo@N@taz@S@ClsD@F@operator==#&1$@N@foo@N@taz@S@ClsD#1 Extent=[50:5 - 50:62]
 // CHECK: usrs.cpp c:usrs.cpp@866@N@foo@N@taz@S@ClsD@F@operator==#&1$@N@foo@N@taz@S@ClsD#1@x Extent=[50:21 - 50:34]
 // CHECK: usrs.cpp c:@F@rez Extent=[55:3 - 55:25]
 // CHECK: usrs.cpp c:usrs.cpp@941@F@rez@a Extent=[55:12 - 55:17]
 // CHECK: usrs.cpp c:usrs.cpp@948@F@rez@b Extent=[55:19 - 55:24]
 // CHECK: usrs.cpp c:@NA@foo_alias
 // CHECK-NOT: foo
 // CHECK: usrs.cpp c:@NA@foo_alias2
-// CHECK-NOT: ClsB
+// CHECK: usrs.cpp c:@UD@ClsB Extent=[64:1 - 64:16]
 // CHECK: usrs.cpp c:@NA@foo_alias3
 // CHECK: usrs.cpp c:@aN Extent=[68:1 - 73:2]
 // CHECK: usrs.cpp c:usrs.cpp@aN@S@RDar9371763_Foo Extent=[69:1 - 72:2]
 // CHECK: usrs.cpp c: Extent=[70:1 - 70:8]
 // CHECK: usrs.cpp c:usrs.cpp@aN@S@RDar9371763_Foo@F@bar# Extent=[71:3 - 71:13]
 // CHECK: usrs.cpp c:usrs.cpp@aN@S@RDar9371763_Foo@F@bar# Extent=[75:1 - 75:31]
 // CHECK: usrs.cpp c:@F@rdar9371763# Extent=[77:1 - 80:2]
 // CHECK: usrs.cpp c:usrs.cpp@1204@F@rdar9371763#@foo Extent=[78:3 - 78:22]

unittests/Index/IndexTests.cpp

TEST(IndexTest, IndexTypeParmDecls) {
   Opts.IndexTemplateParameters = true;
   Index->Symbols.clear();
   tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols,
               AllOf(Contains(QName("Foo::T")), Contains(QName("Foo::I")),
                     Contains(QName("Foo::C")), Contains(QName("Foo::NoRef"))));
 }
 
+TEST(IndexTest, UsingDecls) {
+  std::string Code = R"cpp(
+    void foo(int bar);
+    namespace std {
+      using ::foo;
+    }
+  )cpp";
+  auto Index = std::make_shared<Indexer>();
+  IndexingOptions Opts;
+  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  EXPECT_THAT(Index->Symbols, Contains(QName("std::foo")));
+}
+
 } // namespace
 } // namespace index
 } // namespace clang