Index synthesized wrapper refs by substituting the Clang decl.

The goal of this change is replace the references to synthesized declarations, whose definitions are never contained in the indexstore, with references to the underlying declarations which are contained in the indexstore. The current behavior prevents code navigation from the references to the declaration.

Reference: #79912

- I added the EnumElementDecl generated from the underlying Clang EnumConstantDecl to the imported decl cache for ClangImporter.
- I took the effective Clang node and corresponding imported decl to substitute for "synthesized wrapper decls".

This has a weird outcome, where a reference to the `Code` enum inside of the synthesized struct can emit 2 references to the underlying enum. There's an example in the test case, where `TestError.Code` is referenced.

Fixes 79912

adding emitDataForSwiftSerializedModule emits the decls but:
- The locations are all 0:0
- The decls are emitted in the file "module.modulemap

Author: dylansturg

lib/ClangImporter/ImportDecl.cpp

@@ -2000,6 +2000,8 @@ namespace {
             nominal->addMember(decl);
           };
 
+          Impl.ImportedDecls[{constant->getCanonicalDecl(), getVersion()}] =
+              enumeratorDecl;
           addDecl(result, enumeratorDecl);
           for (auto *variant : variantDecls)
             addDecl(result, variant);

lib/Index/Index.cpp

@@ -30,10 +30,12 @@
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/StringExtras.h"
+#include "swift/ClangImporter/ClangImporter.h"
 #include "swift/IDE/SourceEntityWalker.h"
 #include "swift/IDE/Utils.h"
 #include "swift/Markup/Markup.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "clang/AST/Decl.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -431,6 +433,7 @@ struct MappedLoc {
 
 class IndexSwiftASTWalker : public SourceEntityWalker {
   IndexDataConsumer &IdxConsumer;
+  ASTContext &Ctx;
   SourceManager &SrcMgr;
   std::optional<unsigned> BufferID;
   bool enableWarnings;
@@ -468,6 +471,31 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
   // let bindings.
   llvm::DenseMap<ValueDecl *, ValueDecl *> sameNamedCaptures;
 
+  bool isImporterSynthesizedWrapper(ValueDecl *D) {
+    const ClangImporterSynthesizedTypeAttr *attr =
+        D->getAttrs().getAttribute<ClangImporterSynthesizedTypeAttr>();
+    if (!attr) {
+      const VarDecl *var = dyn_cast_or_null<VarDecl>(D);
+      if (!var) {
+        return false;
+      }
+      const NominalTypeDecl *type =
+          var->getDeclContext()->getSelfNominalTypeDecl();
+      if (!type ||
+          !type->getAttrs().hasAttribute<ClangImporterSynthesizedTypeAttr>()) {
+        return false;
+      }
+      attr = type->getAttrs().getAttribute<ClangImporterSynthesizedTypeAttr>();
+    }
+    switch (attr->getKind()) {
+    case ClangImporterSynthesizedTypeAttr::Kind::NSErrorWrapper:
+    case ClangImporterSynthesizedTypeAttr::Kind::NSErrorWrapperAnon:
+      return true;
+    default:
+      return false;
+    }
+  }
+
   bool getNameAndUSR(ValueDecl *D, ExtensionDecl *ExtD,
                      StringRef &name, StringRef &USR) {
     auto &result = nameAndUSRCache[ExtD ? (Decl*)ExtD : D];
@@ -594,7 +622,7 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
 public:
   IndexSwiftASTWalker(IndexDataConsumer &IdxConsumer, ASTContext &Ctx,
                       SourceFile *SF = nullptr)
-      : IdxConsumer(IdxConsumer), SrcMgr(Ctx.SourceMgr),
+      : IdxConsumer(IdxConsumer), Ctx(Ctx), SrcMgr(Ctx.SourceMgr),
         BufferID(SF ? std::optional(SF->getBufferID()) : std::nullopt),
         enableWarnings(IdxConsumer.enableWarnings()) {}
 
@@ -901,6 +929,23 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
         return false;
     }
 
+    if (isImporterSynthesizedWrapper(D)) {
+      auto *Importer = static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
+      const ClangNode node = Importer->getEffectiveClangNode(D);
+      if (!node.isNull()) {
+        if (auto named = dyn_cast_or_null<clang::NamedDecl>(node.getAsDecl())) {
+          if (const auto imported = Importer->importDeclCached(named)) {
+            if (imported && imported.has_value()) {
+              if (ValueDecl *VD =
+                      dyn_cast_or_null<ValueDecl>(imported.value())) {
+                D = VD;
+              }
+            }
+          }
+        }
+      }
+    }
+
     if (auto *GenParam = dyn_cast<GenericTypeParamDecl>(D)) {
       D = canonicalizeGenericTypeParamDeclForIndex(GenParam);
     }

test/Index/index_imported_objc.swift

@@ -21,6 +21,18 @@
 @property int categoryAddedProperty;
 @end
 
+extern NSErrorDomain const TestErrorDomain;
+
+typedef NS_ERROR_ENUM(TestErrorDomain, TestError){
+    TestErrorFoo = 0,
+    TestErrorBar = 1,
+};
+
+typedef NS_ENUM(NSInteger, ErrCategory) {
+  ErrCategoryA = 0,
+  ErrCategoryB = 1,
+};
+
 //--- module.modulemap
 module objc_decls {
   header "objc_decls.h"
@@ -48,3 +60,34 @@ class SubObjCClass: ObjCClass {
   // CHECK-NEXT: RelOver | instance-method/Swift | protocolAddedMethod() | c:objc(pl)MemberAdding(im)protocolAddedMethod
   // CHECK-NEXT: RelChild | class/Swift | SubObjCClass | c:@M@swift_ide_test@objc(cs)SubObjCClass
 }
+func testEnumIndex() {
+  let _: TestError.Code = .bar
+  // CHECK: [[@LINE-1]]:10 | enum/Swift | Code | c:@E@TestError | Ref | rel: 0
+  // CHECK: [[@LINE-2]]:20 | enum/Swift | Code | c:@E@TestError | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-3]]:28 | enumerator/Swift | bar | c:@E@TestError@TestErrorBar | Ref,RelCont | rel: 1
+  let e = TestError.foo
+  // CHECK: [[@LINE-1]]:11 | enum/Swift | Code | c:@E@TestError | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-2]]:21 | enumerator/Swift | foo | c:@E@TestError@TestErrorFoo | Ref,RelCont | rel: 1
+  switch e {
+    case TestError.foo: break
+    // CHECK: [[@LINE-1]]:10 | enum/Swift | Code | c:@E@TestError | Ref,RelCont | rel: 1
+    // CHECK: [[@LINE-2]]:20 | enumerator/Swift | foo | c:@E@TestError@TestErrorFoo | Ref,RelCont | rel: 1
+    case .bar: break
+    // CHECK: [[@LINE-1]]:11 | enumerator/Swift | bar | c:@E@TestError@TestErrorBar | Ref,RelCont | rel: 1
+    default: break
+  }
+  let _ = ErrCategory.B
+  // CHECK: [[@LINE-1]]:11 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-2]]:23 | enumerator/Swift | B | c:@E@ErrCategory@ErrCategoryB | Ref,RelCont | rel: 1
+  let c: ErrCategory = .A
+  // CHECK: [[@LINE-1]]:10 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+  // CHECK: [[@LINE-2]]:25 | enumerator/Swift | A | c:@E@ErrCategory@ErrCategoryA | Ref,RelCont | rel: 1
+  switch c {
+    case ErrCategory.A: break
+    // CHECK: [[@LINE-1]]:22 | enumerator/Swift | A | c:@E@ErrCategory@ErrCategoryA | Ref,RelCont | rel: 1
+    // CHECK: [[@LINE-2]]:10 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+    // CHECK: [[@LINE-3]]:22 | enum/Swift | ErrCategory | c:@E@ErrCategory | Ref,RelCont | rel: 1
+    case .B: break
+    // CHECK: [[@LINE-1]]:11 | enumerator/Swift | B | c:@E@ErrCategory@ErrCategoryB | Ref,RelCont | rel: 1
+  }
+}