[Index] Remove reference to `UnresolvedUsingIfExists`

[bnbarham]

Summary

Assuming ns::foo doesn't exist, given:

using ns::foo __attribute__((using_if_exists));

The AST will look something like:
UsingDecl

UsingShadowDecl
  UnresolvedUsingIfExistsDecl

Thus we end up adding a reference to UnresolvedUsingIfExistsDecl when
processing UsingDecl, but never add the decl itself. In this case the
decl is really the UsingDecl anyway though (which we do output), so it
makes more sense to just remove the extra reference.

[bnbarham]

clang/test/Index/using_if_exists.cpp

9

The AST here is:
UsingDecl -> UsingShadowDecl -> UnresolvedUsingIfExistsDecl

So the UnresolvedUsingIfExistsDecl is a reference, which is a bit weird since there is no decl. But... there is no decl ("foo" doesn't exist), so this seems somewhat reasonable. Any objections?

[bnbarham]

After speaking with Ben, we decided it makes more sense to just remove the reference entirely.

[bnbarham]

Update title/message

[benlangmuir]

Minor suggestion for the test case, but otherwise LGTM.

clang/test/Index/using_if_exists.cpp

10

Could we drop the [[@LINE-2]]:11 | part of the CHECK-NOT to make it a bit more robust?

[bnbarham]

Remove line for <unknown> check

clang/include/clang/Index/IndexSymbol.h

enum class SymbolSubKind : uint8_t {
   None,
   CXXCopyConstructor,
   CXXMoveConstructor,
   AccessorGetter,
   AccessorSetter,
   UsingTypename,
   UsingValue,
   UsingEnum,
+  UnresolvedUsing,
 };
 
 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,

clang/lib/Index/IndexSymbol.cpp

case Decl::Using:
       Info.Kind = SymbolKind::Using;
       Info.Lang = SymbolLanguage::CXX;
       break;
     case Decl::UsingEnum:
       Info.Kind = SymbolKind::Using;
       Info.Lang = SymbolLanguage::CXX;
       Info.SubKind = SymbolSubKind::UsingEnum;
       break;
+    case Decl::UnresolvedUsingIfExists:
+      Info.Kind = SymbolKind::Using;
+      Info.SubKind = SymbolSubKind::UnresolvedUsing;
+      Info.Lang = SymbolLanguage::CXX;
+      break;
     case Decl::Binding:
       Info.Kind = SymbolKind::Variable;
       Info.Lang = SymbolLanguage::CXX;
       break;
     case Decl::MSProperty:
       Info.Kind = SymbolKind::InstanceProperty;
       if (const CXXRecordDecl *CXXRec =
               dyn_cast<CXXRecordDecl>(D->getDeclContext())) {
StringRef index::getSymbolSubKindString(SymbolSubKind K) {
   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::UsingEnum:
     return "using-enum";
+  case SymbolSubKind::UnresolvedUsing:
+    return "using-unresolved";
   }
   llvm_unreachable("invalid symbol subkind");
 }
 
 StringRef index::getSymbolLanguageString(SymbolLanguage K) {
   switch (K) {
   case SymbolLanguage::C: return "C";
   case SymbolLanguage::ObjC: return "ObjC";

clang/lib/Index/USRGeneration.cpp

public:
   void VisitTypedefDecl(const TypedefDecl *D);
   void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
   void VisitVarDecl(const VarDecl *D);
   void VisitBindingDecl(const BindingDecl *D);
   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
   void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
   void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
+  void VisitUnresolvedUsingIfExistsDecl(const UnresolvedUsingIfExistsDecl *D);
 
   void VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
     IgnoreResults = true; // No USRs for linkage specs themselves.
   }
 
   void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
     IgnoreResults = true;
   }
void USRGenerator::VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D) {
   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
     return;
   VisitDeclContext(D->getDeclContext());
   Out << "@UUT@";
   printQualifier(Out, D->getASTContext(), D->getQualifier());
   Out << D->getName(); // Simple name.
 }
 
-
+void USRGenerator::VisitUnresolvedUsingIfExistsDecl(
+    const UnresolvedUsingIfExistsDecl *D) {
+  if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
+    return;
+  VisitDeclContext(D->getDeclContext());
+  Out << "@UUIE@";
+  Out << D->getName();
+}
 
 //===----------------------------------------------------------------------===//
 // USR generation functions.
 //===----------------------------------------------------------------------===//
 
 static void combineClassAndCategoryExtContainers(StringRef ClsSymDefinedIn,
                                                  StringRef CatSymDefinedIn,
                                                  raw_ostream &OS) {

clang/test/Index/using_if_exists.cpp

+// RUN: c-index-test core -print-source-symbols -- %s -target x86_64-unknown-unknown 2>&1 | FileCheck %s
+
+namespace ns {
+//  void foo();
+}
+
+using ns::foo __attribute__((using_if_exists));
+// CHECK: [[@LINE-1]]:11 | using/C++ | foo | c:@UD@foo | <no-cgname> | Decl | rel: 0
+// CHECK: [[@LINE-2]]:11 | using/using-unresolved/C++ | foo | c:using_if_exists.cpp@UUIE@foo | <no-cgname> | Ref | rel: 0