[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

588 ↗

(On Diff #187201)

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 ↗

(On Diff #187201)

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 ↗

(On Diff #187201)

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

586 ↗

(On Diff #187208)

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 ↗

(On Diff #187208)

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 ↗

(On Diff #188171)

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

unittests/Index/IndexTests.cpp

253 ↗

(On Diff #188171)

Could we also test the kind is correct here?

[kadircet]

• Revert SymbolSubKind change
• Add test to check for SymbolKind

cfe/trunk/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;
   }
 

cfe/trunk/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.Lang = SymbolLanguage::CXX;
+      break;
     case Decl::Binding:
       Info.Kind = SymbolKind::Variable;
       Info.Lang = SymbolLanguage::CXX;
       break;
     default:
       break;
     }
   }

cfe/trunk/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;
   }
 

cfe/trunk/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]

cfe/trunk/unittests/Index/IndexTests.cpp

 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Position &Pos) {
   return OS << Pos.Line << ':' << Pos.Column;
 }
 
 struct TestSymbol {
   std::string QName;
   Position WrittenPos;
   Position DeclPos;
+  SymbolInfo SymInfo;
   // FIXME: add more information.
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const TestSymbol &S) {
   return OS << S.QName << '[' << S.WrittenPos << ']' << '@' << S.DeclPos;
 }
 
 class Indexer : public IndexDataConsumer {
 public:
   void initialize(ASTContext &Ctx) override {
     AST = &Ctx;
     IndexDataConsumer::initialize(Ctx);
   }
 
   bool handleDeclOccurence(const Decl *D, SymbolRoleSet Roles,
                            ArrayRef<SymbolRelation>, SourceLocation Loc,
                            ASTNodeInfo) override {
     const auto *ND = llvm::dyn_cast<NamedDecl>(D);
     if (!ND)
       return true;
     TestSymbol S;
+    S.SymInfo = getSymbolInfo(D);
     S.QName = ND->getQualifiedNameAsString();
     S.WrittenPos = Position::fromSourceLocation(Loc, AST->getSourceManager());
     S.DeclPos =
         Position::fromSourceLocation(D->getLocation(), AST->getSourceManager());
     Symbols.push_back(std::move(S));
     return true;
   }
 

 using testing::AllOf;
 using testing::Contains;
 using testing::Not;
 using testing::UnorderedElementsAre;
 
 MATCHER_P(QName, Name, "") { return arg.QName == Name; }
 MATCHER_P(WrittenAt, Pos, "") { return arg.WrittenPos == Pos; }
 MATCHER_P(DeclAt, Pos, "") { return arg.DeclPos == Pos; }
+MATCHER_P(Kind, SymKind, "") { return arg.SymInfo.Kind == SymKind; }
 
 TEST(IndexTest, Simple) {
   auto Index = std::make_shared<Indexer>();
   tooling::runToolOnCode(new IndexAction(Index), "class X {}; void f() {}");
   EXPECT_THAT(Index->Symbols, UnorderedElementsAre(QName("X"), QName("f")));
 }
 
 TEST(IndexTest, IndexPreprocessorMacros) {
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(AllOf(QName("std::foo"), Kind(SymbolKind::Using))));
+}
+
 } // namespace
 } // namespace index
 } // namespace clang