[SourceKit] For clang enums imported as error domains, make sure to use unique USRs.

lib/AST/USRGeneration.cpp

@@ -18,6 +18,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Attr.h"
 #include "clang/Index/USRGeneration.h"
 #include "clang/Lex/PreprocessingRecord.h"
 #include "clang/Lex/Preprocessor.h"
@@ -55,7 +56,39 @@ bool ide::printDeclUSR(const ValueDecl *D, raw_ostream &OS) {
 
   ValueDecl *VD = const_cast<ValueDecl *>(D);
 
-  if (ClangNode ClangN = VD->getClangNode()) {
+  auto interpretAsClangNode = [](const ValueDecl *D)->ClangNode {
+    ClangNode ClangN = D->getClangNode();
+    if (auto ClangD = ClangN.getAsDecl()) {
+      // NSErrorDomain causes the clang enum to be imported like this:
+      //
+      // struct MyError {
+      //     enum Code : Int32 {
+      //         case errFirst
+      //         case errSecond
+      //     }
+      //     static var errFirst: MyError.Code { get }
+      //     static var errSecond: MyError.Code { get }
+      // }
+      //
+      // The clang enum and enum constants are associated with both the
+      // struct/nested enum, and the static vars/enum cases.
+      // But we want unique USRs for the above symbols, so use the clang USR
+      // for the enum and enum cases, and the Swift USR for the struct and vars.
+      //
+      if (isa<clang::EnumDecl>(ClangD)) {
+        if (ClangD->hasAttr<clang::NSErrorDomainAttr>() && isa<StructDecl>(D))
+          return ClangNode();
+      } else if (auto *ClangEnumConst = dyn_cast<clang::EnumConstantDecl>(ClangD)) {
+        if (auto *ClangEnum = dyn_cast<clang::EnumDecl>(ClangEnumConst->getDeclContext())) {
+          if (ClangEnum->hasAttr<clang::NSErrorDomainAttr>() && isa<VarDecl>(D))
+            return ClangNode();
+        }
+      }
+    }
+    return ClangN;
+  };
+
+  if (ClangNode ClangN = interpretAsClangNode(D)) {
     llvm::SmallString<128> Buf;
     if (auto ClangD = ClangN.getAsDecl()) {
       bool Ignore = clang::index::generateUSRForDecl(ClangD, Buf);

test/SourceKit/DocSupport/Inputs/MyError.h

@@ -0,0 +1,14 @@
+@import Foundation;
+
+#define NS_ERROR_ENUM(_type, _name, _domain)  \
+  enum _name : _type _name; enum __attribute__((ns_error_domain(_domain))) _name : _type
+
+@class NSString;
+extern const NSString *const MyErrorDomain;
+/// This is my cool error code.
+typedef NS_ERROR_ENUM(int, MyErrorCode, MyErrorDomain) {
+	/// This is first error.
+	MyErrFirst,
+	/// This is second error.
+	MyErrSecond,
+};

test/SourceKit/DocSupport/Inputs/module.modulemap

@@ -0,0 +1,4 @@
+module "MyError" {
+  header "MyError.h"
+  export *
+}

test/SourceKit/DocSupport/doc_error_domain.swift

@@ -0,0 +1,32 @@
+// REQUIRES: OS=macosx
+// RUN: %sourcekitd-test -req=doc-info -module MyError -- -I %S/Inputs \
+// RUN:         %mcp_opt -sdk %sdk | %sed_clean > %t.response
+// RUN: FileCheck -input-file=%t.response %s
+
+// CHECK: struct MyError {
+// CHECK:     enum Code : Int32 {
+// CHECK:         case errFirst
+// CHECK:         case errSecond
+// CHECK:     }
+// CHECK:     static var errFirst: MyError.Code { get }
+// CHECK:     static var errSecond: MyError.Code { get }
+
+// CHECK:         key.kind: source.lang.swift.decl.struct,
+// CHECK-NEXT:    key.name: "MyError",
+// CHECK-NEXT:    key.usr: "s:VSC7MyError",
+// CHECK-NEXT:    This is my cool error code.
+
+// CHECK:             key.kind: source.lang.swift.decl.enum,
+// CHECK-NEXT:        key.name: "Code",
+// CHECK-NEXT:        key.usr: "c:@E@MyErrorCode",
+// CHECK-NEXT:        This is my cool error code.
+
+// CHECK:                 key.kind: source.lang.swift.decl.enumelement,
+// CHECK-NEXT:            key.name: "errFirst",
+// CHECK-NEXT:            key.usr: "c:@E@MyErrorCode@MyErrFirst",
+// CHECK-NEXT:            This is first error.
+
+// CHECK:             key.kind: source.lang.swift.decl.var.static,
+// CHECK-NEXT:        key.name: "errFirst",
+// CHECK-NEXT:        key.usr: "s:ZvVSC7MyError8errFirstOS_4Code",
+// CHECK-NEXT:        This is first error.